To implement a rate limit system in Go, you can use the `time` package along with a goroutine and a channel to control the rate of execution. Here’s an example implementation:

go
package main
import (
    "fmt"
    "time"
)

func main() {
    // Create a channel to control the rate of execution
    rateLimit := make(chan struct{}, 3) // Allow 3 requests per second
    
    // Start a goroutine to add tokens to the rate limit channel
    go func() {
      for range time.Tick(time.Second) {
        select {
          case rateLimit <- struct{}{}:
            fmt.Println("Token added to rate limit channel")
          default:
            fmt.Println("Rate limit reached, dropping request")
        }
      }
    }()

    // Simulate making 10 requests
    for i := 1; i <= 10; i++ {
      fmt.Printf("Making request %d\n", i)
      // Wait for a token from the rate limit channel
      <-rateLimit
      // Simulate some work
      time.Sleep(time.Second)
    }
}

In the above example, a channel called `rateLimit` is created with a buffer size of 3, allowing 3 requests per second. A goroutine is started to add tokens to the channel every second.

In the main loop, 10 requests are simulated. Before making each request, the `<-rateLimit` statement waits for a token from the `rateLimit` channel. If the rate limit is reached and the channel is full, the request will be dropped.

You can adjust the buffer size of the `rateLimit` channel to control the rate limit. For example, setting it to 10 would allow 10 requests per second. You can also modify the sleep duration inside the main loop to simulate different processing times for each request.

Note that this is a basic example and doesn’t take into account factors like burst limits or rate limit precision. There are more advanced libraries available, such as `golang.org/x/time/rate`, that provide a more comprehensive and configurable rate-limiting solution.