🔢 Random Number Generator

How Random Number Generators Really Work — And Why Your Browser Can Do It Right

Every time you roll a die, shuffle a deck, or pick a lottery ticket, you're interacting with randomness. But what does "random" actually mean when a computer is doing it — a machine that by definition runs on deterministic logic? This question sits at the heart of how random number generators (RNGs) work, and understanding it changes how you use them.

Pseudo-Random vs. True Random: The Core Distinction

Computer-generated randomness almost always falls into one of two categories: pseudo-random number generators (PRNGs) and cryptographically secure random number generators (CSPRNGs).

A PRNG uses a mathematical algorithm that takes a starting value — called a seed — and produces a long sequence of numbers that look random but are entirely deterministic. Given the same seed, a PRNG always produces exactly the same sequence. The most famous PRNG algorithm is the Mersenne Twister, which has a period of 2¹⁹⁹³⁷−1 — meaning it produces that many numbers before repeating. That's astronomically long, far exceeding any practical use. JavaScript's Math.random() typically uses a variant of the xorshift algorithm internally (implementation varies by engine — V8 uses xorshift128+), seeded automatically from system entropy at startup.

A CSPRNG, by contrast, draws on genuinely unpredictable physical events — CPU thermal noise, timing jitter between hardware interrupts, mouse movement entropy — to produce numbers that cannot be predicted even if you know the algorithm. In browsers, this is exposed as crypto.getRandomValues(), available via the Web Cryptography API. For generating lottery numbers or passwords, this is the gold standard.

For the vast majority of everyday uses — deciding who goes first in a game, picking random survey respondents, generating test data — Math.random() is perfectly adequate. The sequences are statistically well-distributed, fast to generate, and sufficient for anything that isn't a security-sensitive application.

The Math Behind Min-Max Range Selection

Getting a random integer between min and max (inclusive) seems trivial, but naive implementations introduce a subtle bias called modulo bias. If you do Math.floor(Math.random() * max) % range, the distribution isn't perfectly flat — some numbers appear slightly more often than others, depending on how the floating-point range maps onto the integer range.

The correct formula is:

Math.floor(Math.random() * (max - min + 1)) + min

This works because Math.random() returns a value in [0, 1) — including 0, excluding 1. Multiplying by (max - min + 1) gives a range of [0, max − min + 1), and Math.floor() snaps it to an integer in [0, max − min]. Adding min shifts the whole range to [min, max]. The distribution is as flat as a floating-point implementation allows, which is extremely close to perfect for typical ranges.

No-Repeat Draws: The Fisher-Yates Shuffle

The "no-repeat" or "unique draw" mode is fundamentally different from regular random generation. You're sampling without replacement — like dealing cards from a shuffled deck rather than rolling dice. The classic algorithm for this is the Fisher-Yates shuffle, formalized by Richard Durstenfeld in 1964 and popularized by Donald Knuth.

The algorithm works by building an array of all possible values in the range, then repeatedly picking a random element from the remaining unshuffled portion and swapping it to the back. After k steps, the last k elements of the array are a perfectly uniform random sample without repeats.

The key insight is that a full Fisher-Yates shuffle is unnecessary when you only need a few picks from a large range. A partial shuffle — running only count iterations instead of iterating through the full range — is O(count) time and space efficient. This tool implements exactly that optimization: if you pick 5 numbers from a range of 1–100, it only performs 5 swap operations rather than shuffling all 100 elements.

For extremely large ranges (say, 1 to 10,000,000) where building the full pool array would exhaust memory, a different approach is needed: rejection sampling. Generate numbers randomly and track which you've seen in a hash set; skip repeats. This works beautifully when count is small relative to range size, because the probability of collision stays low. As you approach half the range filled, collisions increase and performance degrades — but for typical use cases, it's extremely fast.

Range Size, Count, and Edge Cases

One constraint that trips people up: you cannot draw more unique numbers than the range contains. If your range is 1–10 (10 possible values), you can't request 15 unique numbers — there simply aren't enough. This tool validates this upfront and gives a clear error rather than hanging in an infinite loop.

Another edge case is inclusive vs. exclusive bounds. When someone says "between 1 and 10," they almost always mean 1 and 10 are valid outputs. This is called a closed interval [1, 10]. Some older tools silently exclude one or both endpoints — something to watch for if your results ever seem to skew away from boundary values.

Sorting is also worth understanding correctly. Sorting the output of a random draw doesn't make it less random — you're just reordering the same unbiased sample. The randomness came from the selection process, not the order in which results are displayed. Ascending sort is especially useful for lottery-style picks, bingo callers, and anywhere the human reader benefits from ordered output.

What "Uniform Distribution" Actually Means for You

A well-implemented RNG produces a uniform distribution — every integer in the range has an equal probability of being selected on any given draw. This sounds obvious, but it breaks down in surprising ways. Faulty implementations, poorly seeded generators, or simple coding mistakes produce numbers that cluster around certain values, bias toward low or high ends, or repeat patterns that cycle after thousands of draws.

You can informally test any generator by requesting 10,000 numbers from a small range (say 1–10) and counting frequencies. A uniform generator will show each number appearing roughly 1,000 times, with natural variation. Systematic deviation from uniformity — one number appearing 1,500 times while another appears 700 — is a red flag.

Practical Applications Where Range and Count Matter

The power of a configurable random number generator becomes clear across real-world scenarios. Statistical sampling might require 50 unique IDs drawn from a pool of 1,000. A classroom teacher might need 6 unique student numbers (1–30) for group assignments. A raffle organizer needs 3 winning ticket numbers from 1–500, drawn without repeats and sorted for easy announcement. A game developer needs 20 random damage values between 15 and 85, with repeats allowed, displayed in the order rolled.

Each of these scenarios benefits from specific controls — unique/repeat mode, count, sort order — that a single fixed "roll a random number" button cannot serve. Configuring the generator for your exact need isn't over-engineering; it's the difference between a useful tool and a toy.

Why Browser-Based Generation Is Sufficient (and Private)

Running the generator entirely in your browser has a major privacy advantage: no numbers are sent to any server. There's no logging, no analytics on your ranges, no record of what you generated. This matters more than it might seem — if you're randomly selecting from sensitive lists (employee IDs, patient numbers, internal codes), keeping that off the network is the right call.

Browser performance is also more than sufficient. Modern JavaScript engines can generate and sort 100,000 unique numbers from a large range in under a second on typical hardware. The partial Fisher-Yates approach this tool uses keeps memory usage bounded even at high counts.

True randomness, at the level required for everyday decision-making, games, and sampling, has been a solved problem in software for decades. What varies is implementation quality, usability, and transparency — and those are the things worth demanding from any tool you rely on.