Random Number & Dice Generator: Seeded, Fair, Exportable

Last updated: July 7, 2026

30-Second Start

Pick a mode: roll dice, pull a number, or shuffle a list, then hit generate. That's the whole workflow. Need a random roll for a board game? Type the dice expression and go. Need a number from 1 to 100? Set the range. Need to randomize a seating chart? Paste your names and shuffle. Every outcome sits on a uniform distribution, meaning each value has an equal shot at being picked. That is exactly what “fair” means in probability.

Five rolls of a fair die come up 3, 3, 4, 3, 5 and it looks rigged. It isn't. Three threes in five rolls sits well inside normal variance. Small samples don't owe you variety, and expecting them to is the fastest way to misread a perfectly honest die.

Rolling Dice: dX Notation for the Tabletop

The dice mode speaks standard tabletop notation, so if you play D&D, Pathfinder, or anything with polyhedral dice, type the roll the way the rulebook writes it. NdM means N dice of M sides: 1d20 for an attack, 3d6 for a stat line, 1d100 for a percentile roll. Anything from a d4 up to a d100 (and well beyond) works. Add a flat bonus with +, so 1d20+5 rolls the die and tacks on your modifier.

The heavier notation is here too. 4d6kh3 keeps the highest three of four dice, the classic way to roll ability scores. 2d20kh1 is advantage, 2d20kl1 is disadvantage. A trailing ! makes dice explode, rerolling and adding whenever one lands on its top face. Set “rolls per click” higher to fire the same expression many times when you want a whole encounter's worth of damage at once. Each result shows the individual dice and the total, not just the sum, so nobody at the table has to trust a black box.

Reproducible Randomness

Enter a seed value and the generator becomes deterministic: same seed, same settings, same sequence every time. That sounds like it defeats the purpose, but it's genuinely useful. A teacher can hand out seed 42 to a class of thirty students, and every student gets the identical dataset for a homework problem. A developer debugging a simulation can replay the exact scenario that triggered a bug. A tabletop group can audit a contested roll after the fact.

Under the hood, the tool uses a pseudo-random number generator (PRNG), an algorithm that churns a seed through a formula to produce a long, unpredictable-looking sequence. Without a seed, it grabs the system clock as a starting value, making each run appear unique. With a seed, you control the starting point and own the entire sequence. That is the difference between pseudo-random and truly random: pseudo-random is repeatable, while hardware-based true random (like atmospheric noise on random.org) is not. For games, classrooms, and quick simulations, pseudo-random is more than enough.

What the Output Tells You

For integer mode, you get a list of numbers inside the range you set. Each one was drawn independently. The generator doesn't remember or avoid previous picks unless you explicitly turn on “no repeats.” The expected frequency of any particular value over many draws is 1 / (range size). Generate 1,000 numbers between 1 and 10 and each number should appear roughly 100 times. If one shows up 115 times and another 88, that's normal, and a chi-square goodness-of-fit test would confirm the generator is behaving fairly.

For dice mode, you see each die's face value and the total. Rolling multiple dice produces a sum that is not uniformly distributed. 2d6 peaks sharply at 7 because six of the thirty-six possible outcomes land there, while only one combination makes a 2 or a 12. The tool shows the individual rolls so you can verify this yourself over many trials.

For shuffle mode, you get a reordered version of your list. Every permutation is equally likely, so no name or item has a positional advantage. This is the digital equivalent of cutting a deck of cards, fair by construction. Drawing one name or reshuffling the order is where this tool stops, though. If the list is people and you want them dealt into even teams rather than just reordered, that's a different job. The Random Team & Group Generator splits a roster into balanced groups and reports how close the sizes landed.

Try This

Roll 2d6 one hundred times with seed 7777. Record how often each sum (2 through 12) appears. Here's what the theoretical distribution predicts and roughly what you'll see:

Your actual counts will deviate, maybe sum 7 shows up 14 times or 20, but the shape of the distribution (a triangle peaking at 7) should be clearly visible. Switch to 1,000 rolls and the bars tighten against the theoretical line. That tightening is the law of large numbers at work: more trials, closer to the expected proportions.

Now try an extreme: roll 1d100 ten times with no seed. You'll likely get a scatter of values with no obvious pattern. That's correct behavior. Uniform distributions look random precisely because they are. There's no clustering or central tendency. Contrast that with 10d6 summed, which will hover near 35 (the expected value of 3.5 per die times 10 dice) every time.

Where People Slip Up

Expecting small samples to “look fair.” Ten rolls of a d6 might give you four sixes. That doesn't mean the die is loaded. Short runs routinely produce lopsided results; the law of large numbers needs hundreds or thousands of trials before frequencies settle near 1/6.

Thinking seeds make things “more random.” A seed does the opposite. It locks the sequence. Two people using seed 12345 with the same range get identical output. Seeds are for reproducibility, not extra unpredictability.

Using this for security-sensitive tasks. A PRNG is predictable if you know the algorithm and seed. Passwords, encryption keys, and regulated lotteries need cryptographically secure generators that resist reverse-engineering. This tool is built for games, classwork, and quick picks, not for anything where someone could gain an advantage by predicting the output.

Confusing dice sums with individual rolls. Each face of a d6 has a 1/6 chance, but the sum of 2d6 is not uniform. A 7 is six times more likely than a 2. Treating multi-dice sums as flat distributions leads to wrong probability estimates in board games, tabletop RPGs, and homework alike.

Common Questions

Is this generator truly random? No, it's pseudo-random. The output passes standard statistical tests for uniformity and independence, but the sequence is deterministic underneath. That gap is irrelevant for classroom demos, game night, and everyday picks, and disqualifying for cryptography.

Can I trust it for a raffle? For an informal raffle among friends, sure. For a regulated contest with legal requirements, use an auditable service like random.org that provides certificates of true randomness.

Why did I get the same number twice in a row? Because each draw is independent. Getting 4 twice in a row on a d6 has a probability of 1/36, uncommon but far from impossible. Over many rolls you should expect occasional repeats; the absence of repeats would actually be suspicious.

What's the biggest die I can roll? The tool supports custom-sided dice, so you can roll a d100 (percentile die common in RPGs), a d1000, or anything your scenario requires. Each face gets an equal 1/N probability regardless of how many sides you choose.

Curious what happens when you stop rolling once and start running thousands of trials, watching a proportion creep toward its true value? That's the probability lesson, not a quick pick, and the Coin Flip & Random Events Simulator is built for exactly that, with running-average charts that make the Law of Large Numbers visible.

Sources

• Khan Academy: Probability. Visual lessons on uniform distributions, dice outcomes, and the law of large numbers.
• Random.org: Randomness. Explanation of true random vs pseudo-random generation and statistical testing methods.
• MDN: Math.random(). Technical reference for the browser-based PRNG that powers most web-based generators.