How to Seed a Random Number Generator Properly in Go

By the end of this page, you will understand how Go's pseudo-random number generator works, why seeding should usually happen only once, and how to generate random strings more efficiently. You will also see better patterns for reusable randomness in real Go programs.

Go's math/rand package generates pseudo-random numbers. That means the numbers are not truly random; they come from a deterministic sequence.

A seed is the starting point for that sequence.

• If you use the same seed, you get the same sequence.
• If you use a different seed, you get a different sequence.

The key idea is:

• Seed once when your program starts.
• Do not seed before every random number.

In your code, rand.Seed(time.Now().UTC().UnixNano()) runs inside randInt(), so it is called every time you want a number. That causes two problems:

1. Performance problem: seeding repeatedly is unnecessary work.
2. Randomness problem: if two calls happen very close together, they may get the same seed or nearly identical seeds, producing repeated values.

For most programs using math/rand, the usual pattern is:

rand.Seed(time.Now().UnixNano())

and then call rand.Intn(...) as many times as needed.

Also, your current function calls randInt() twice per loop iteration:

if string(randInt(, )) != temp {
    temp = (randInt(, ))

Think of a pseudo-random number generator like a shuffled playlist machine.

• The seed is the initial shuffle setup.
• Once the playlist is prepared, you just keep asking for the next song.
• If you keep rebuilding the playlist before every song, you waste time and may keep starting from almost the same point.

So instead of saying, "shuffle again" every second, you should:

• shuffle once
• keep taking the next item from the sequence

That is what seeding once does in Go.

The common pattern in Go is to seed once, then generate values many times.

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())

    fmt.Println(rand.Intn(10)) // 0 to 9
    fmt.Println(rand.Intn(10))
    fmt.Println(rand.Intn(10))
}

rand.Intn(10) returns a number in the range:

• minimum: 0
• maximum: 9

If you want uppercase letters, you can map random indexes into a character set.

package main

import (
    "fmt"
    "math/rand"
    "time"
)

const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

func randomString(n int) string {
    b := make([]byte, n)
    for i :=  b {
        b[i] = letters[rand.Intn((letters))]
    }
     (b)
}

 {
    rand.Seed(time.Now().UnixNano())
    fmt.Println(randomString())
}

Consider this example:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

const letters = "ABC"

func randomString(n int) string {
    b := make([]byte, n)
    for i := range b {
        b[i] = letters[rand.Intn(len(letters))]
    }
    return string(b)
}

func main() {
    rand.Seed(time.Now().UnixNano())
    fmt.Println(randomString(5))
}

Possible execution:

1. rand.Seed(time.Now().UnixNano())

   • The random generator is initialized once.

2. randomString(5) is called.

   • A byte slice of length 5 is created.

3. First loop iteration:

   • rand.Intn(3) returns 2

This concept appears in many practical situations:

• Generating test data

  • random usernames
  • sample order IDs
  • fake labels for demos

• Game development

  • random enemy movement
  • loot drops
  • map variation

• Simulations

  • random sampling
  • trial runs
  • probabilistic models

• Load testing and scripting

  • creating varied request payloads
  • generating temporary values for mock APIs

• Shuffling or selecting items

  • picking a random record
  • randomizing quiz questions
  • sampling input data

In all of these, the same rule applies: initialize the random source once, then reuse it.

In real Go codebases, developers usually avoid calling the global seed repeatedly. Common patterns include:

Seed once in main

func main() {
    rand.Seed(time.Now().UnixNano())
    // start app
}

This is fine for small programs.

Use a dedicated rand.Rand

For better control, create your own generator:

src := rand.NewSource(time.Now().UnixNano())
r := rand.New(src)

fmt.Println(r.Intn(100))

This pattern is useful when:

• you want separate random generators
• you want predictable tests with a fixed seed
• you want to pass randomness into functions or structs

Fixed seed for tests

r := rand.New(rand.NewSource(42))

This makes random behavior reproducible in tests.

Validation and guard clauses

Developers often validate input before generating data:

func randomString(n )  {
     n <=  {
         
    }
    
}

1. Seeding on every call

Broken code:

func randInt(min int, max int) int {
    rand.Seed(time.Now().UnixNano())
    return min + rand.Intn(max-min)
}

Why it is a problem:

• repeated seeding is slow
• calls close together may repeat the same sequence

Better:

func main() {
    rand.Seed(time.Now().UnixNano())
}

2. Calling random generation twice when you only need one value

Broken code:

if string(randInt(65, 90)) != temp {
    temp = string(randInt(65, 90))
}

Why it is a problem:

• the if check uses one random value
• the assignment uses another random value
• the comparison does not match what you actually store

Better:

Another useful comparison:

import (
    "math/rand"
    "time"
)

Seed once:

rand.Seed(time.Now().UnixNano())

Random int from 0 to n-1:

rand.Intn(n)

Random int from min to max-1:

min + rand.Intn(max-min)

Uppercase letters:

const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ch := letters[rand.Intn(len(letters))]

Random string:

func randomString(n int) string {
    b := make([]byte, n)
    for i := range b {
        b[i] = letters[rand.Intn(len(letters))]
    }
     (b)
}

Why should I seed math/rand only once in Go?

Because seeding resets the pseudo-random sequence. If you do it repeatedly, especially in a tight loop, you can get repeated or low-quality results and unnecessary overhead.

Why do I get repeated random values when using time.Now()?

If calls happen very close together, the time-based seed may be the same or too similar, which can restart the generator at nearly the same point.

Is math/rand good enough for passwords or tokens?

No. Use crypto/rand for anything security-sensitive.

What does rand.Intn(n) return?

It returns an integer from 0 up to n-1.

How do I include Z when generating uppercase letters?

Use an exclusive upper bound of 91, because ASCII Z is 90.

Should I use rand.Seed in every package?

Usually no. Seed once at program startup, or create a dedicated rand.Rand instance and pass it where needed.

• math/rand — the standard Go package for pseudo-random values
• crypto/rand — used when randomness must be secure
• byte slices — useful for building strings efficiently in Go
• strings and runes — important when converting numeric values to characters
• functions in Go — relevant because random generation is often wrapped in helper functions
• guard clauses — useful for validating input like string length
• off-by-one errors — important when working with numeric ranges
• testing with fixed seeds — helps make random behavior reproducible