What Is a Random Seed in Programming? Same Seed, Same Arena

What is a random seed in programming? It is a starting number you give a random number generator. Give it the same number and it produces the same "random" sequence every time. That idea is behind the phrase same seed, same arena: if a game builds a level from a seed, the seed decides the level, not luck at the moment you press play.

What is a random seed in programming?

A computer does not roll dice. It follows steps. When code asks for a random number, it runs a formula on a hidden number called the state, returns a result, and updates the state. The first value of that state is the seed.

Because the formula never changes, the seed fixes everything that follows. Start at 42 and you get one list of numbers. Start at 43 and you get a different list. Start at 42 again tomorrow, on another machine, and you get the first list again.

That is why this kind of randomness is called pseudorandom. Wikipedia's entry on random seeds gives the same definition. It looks unpredictable, but it is fully determined by where it began.

How pseudorandom number generators work

A pseudorandom number generator, or PRNG, is a small machine with three parts:

• State: a number, or a few numbers, the generator remembers.
• Step: a formula that scrambles the state into a new state.
• Output: a value taken from the new state, often scaled to a range like 0 to 1.

The seed sets the first state. Every call to the generator runs the step once. Nothing else feeds in, so two generators with the same seed stay in lockstep for as long as you keep asking the same questions in the same order.

That last part matters. The sequence is fixed, but your program has to consume it in the same order. If one run asks for five numbers before building the map and another run asks for six, the map changes even though the seed did not.

Same seed, same arena: a game example

Tank City Zero Day is a good place to see this. In that game, every wave is a freshly generated arena. Each arena is a 13 by 13 grid of tiles, a mirror image left to right, and it is drawn from a seed. (If grids of tiles are new to you, this explainer on 2D arrays covers the idea.)

Think about what the seed has to do here. This is a simplified sketch of how a seeded arena can be built, not Zero Day's own code:

1. Start the generator with the seed.
2. For each tile in the left half of the grid, ask for a number and decide whether it becomes open floor, firewall, silicon or coolant.
3. Copy the left half onto the right half as a mirror image.
4. Keep clear the spots that must stay open.

Mirroring is a nice trick because you only make half the decisions, and the result looks designed rather than scattered. In a sketch like this, the seed controls those half-decisions: same seed, same left half, same arena. The game's arenas are indeed mirrored, as the sketch's third step assumes.

Zero Day keeps three things clear in every arena: the three enemy gates on the top row, the player start, and the wall around the CPU core. Then it checks that the arena is fair. An arena counts as fair when every gate and the player start can reach the core by going around silicon and coolant. Firewall counts as open for this check, because any tank can shoot through it.

If the check fails, the arena is thrown away and drawn again from the next seed. That is a tidy use of seeds. The redraw is still repeatable, because "try the next seed" is also a fixed rule.

You can play Tank City Zero Day and look at how the arenas differ from wave to wave. Notice the left-right symmetry and the open lanes from the top gates to the core.

How to set a seed in Python and JavaScript

In Python, the standard random module lets you set the seed directly. Call random.seed(42) (documented in Python's random module page), then call random.random() or random.randint(1, 6) as usual. Run the script twice and you get the same values both times. If you want a generator that is separate from the rest of your program, make your own with random.Random(42) and call methods on it.

JavaScript is different. Math.random() picks its own starting seed and the user cannot choose or reset it, according to MDN. If you need repeatable numbers, you have two choices:

• Write or copy a small seeded generator, a function that keeps a state number and returns a new value on each call.
• Use a library that provides a seedable generator.

Either way, the pattern is the same. Create the generator once from a seed, pass it to the code that needs randomness, and never call Math.random() in the middle of seeded code, or you break the repeatability.

Why seeds matter: testing, debugging and sharing

Seeds turn "it happened once" into "it happens every time". That helps in three ways.

Testing

A test that uses random input can pass on Monday and fail on Tuesday. With a fixed seed, the input is the same on every run, so a failure means the code changed, not the dice.

Debugging

Say a generated level has a bug: a gate walled in, or a core you cannot reach. If you log the seed that built it, you can rebuild that exact level and step through it. Without the seed, you are hunting for something you may never see again. A fairness check like the one in Zero Day is the same idea turned into code: it tests the arena the seed produced.

Sharing and fairness

Two people who use the same seed see the same level. That lets you compare results on equal terms, or say "try seed 1234, it has a nasty corner". Even a plain tile game benefits. The game's own random numbers for power-up drops and arenas work the same way: a seed is what would make any one of them repeatable.

Picking a seed: fixed, time-based or player-entered

There are three common ways to choose the number.

• Fixed: you hard-code something like 42. Best for tests and demos. Every run is identical.
• Time-based: you use the clock, or a value from the operating system. Each run differs.
• Player-entered: the player types a seed, or copies one from a friend. Good for sharing levels. It only works if your code uses the seed for everything that shapes the level.

A common pattern is to pick a time-based seed by default, then save it. Show it on screen or write it to a log. Now you get variety for normal play and repeatability when you need it.

Common seed mistakes to avoid

• Seeding more than once. If you call the seed function again inside a loop with the same value, you get the same number every time. Seed once, at the start.
• Mixing random sources. One call to an unseeded generator inside seeded code ruins the repeat. Route all randomness through one generator.
• Changing the order of calls. Adding one extra random call before the map is built shifts everything after it. When you change generation code, old seeds may give new maps. Expect that.
• Using seeds for security. A seeded PRNG is predictable by design. Do not use it for passwords, tokens or anything an attacker should not guess. Use your platform's secure random source for that.
• Forgetting to record the seed. If a bug shows up in a time-based run and you never saved the seed, you cannot reproduce it.
• Assuming small seeds are weak. Seeds 1, 2 and 3 are fine for games. The quality comes from the generator, not from how big the seed looks.

Frequently asked questions

What is a random seed in programming?

It is the starting value for a pseudorandom number generator. The same seed always gives the same sequence of numbers, as long as the code asks for them in the same order.

Is a seeded random number truly random?

No. It is pseudorandom, which means a formula produces it from the seed. It looks random, but anyone with the seed and the formula can reproduce it exactly.

What does "same seed, same arena" mean?

It means a level built from a seed will come out identical each time that seed is used. In Tank City Zero Day, each arena is drawn from a seed, and an unfair one is redrawn from the next seed.

Can I seed Math.random in JavaScript?

No, Math.random() cannot take a seed. Use a small seeded generator function or a library that offers one.

Should I use a random seed for security?

No. Seeded generators are predictable. For anything secret, use your platform's secure random source instead.

Get started

The quickest way to feel what a seed does is to watch it work. Play a few waves of Zero Day and look at how each arena is built: mirrored left to right, with the gates, your start and the core always reachable. Then try random.seed(42) in Python and change the number. You will see the same idea at small scale.

Play Tank City Reboot: it is free, plays in your browser on a computer or a phone, and needs no account.