Random Number Generator

Generate cryptographically secure random numbers, roll dice, or flip coins. All randomness is generated in your browser using the Web Crypto API.

Understanding Random Number Generation

Random number generation is one of the most fundamental operations in computing, underpinning everything from video games and statistical simulations to cryptography and scientific research. At its core, generating a random number means producing a value that cannot be predicted in advance, even by someone with complete knowledge of the algorithm being used. This seemingly simple requirement turns out to be surprisingly difficult to achieve with deterministic machines like computers, which follow precise instructions and always produce the same output for the same input.

The distinction between true randomness and pseudo-randomness is critical. True random number generators (TRNGs) derive their output from physical phenomena such as atmospheric noise, radioactive decay, or thermal fluctuations in electronic circuits. These sources are inherently unpredictable because they are governed by quantum mechanical processes. Pseudo-random number generators (PRNGs), on the other hand, use mathematical algorithms to produce sequences of numbers that appear random but are entirely determined by an initial value called a seed. Given the same seed, a PRNG will always produce the same sequence.

For most practical applications, the difference between true and pseudo-random numbers is negligible. Modern PRNGs produce sequences that pass rigorous statistical tests for randomness and are indistinguishable from truly random sequences for any practical purpose. However, there is a crucial third category: cryptographically secure pseudo-random number generators (CSPRNGs). These generators combine the speed of PRNGs with security guarantees that make their output unpredictable even to an attacker who knows the algorithm and has observed previous outputs. This random number generator uses a CSPRNG through the Web Crypto API, providing the best balance of speed and security available in a web browser.

Crypto.getRandomValues vs Math.random

JavaScript provides two built-in mechanisms for generating random numbers, and understanding the difference between them is essential for choosing the right tool for each situation. The older and more commonly known method is Math.random(), which returns a floating-point number between 0 (inclusive) and 1 (exclusive). Most JavaScript engines implement Math.random using the xorshift128+ algorithm, a fast PRNG that produces statistically good output but has a critical limitation: its internal state can be reconstructed from observed outputs, making it fundamentally predictable.

The Web Crypto API method crypto.getRandomValues() fills a typed array with cryptographically secure random values drawn from the operating system's entropy pool. On Windows, this uses the BCryptGenRandom function. On Linux, it reads from the kernel's random number generator via the getrandom system call. On macOS, it uses the Security framework's SecRandomCopyBytes. All of these sources collect entropy from hardware events such as interrupt timings, disk seek times, mouse movements, and keyboard input, then process this raw entropy through a deterministic algorithm to produce a uniform output stream.

The practical difference is significant. An attacker who observes the output of Math.random can, with enough samples, reconstruct the internal state and predict all future outputs. This is not a theoretical concern: researchers have demonstrated practical attacks against Math.random in various browsers. With crypto.getRandomValues, no amount of observed output helps an attacker predict future values. For this random number generator, we use crypto.getRandomValues exclusively to ensure that every number, dice roll, and coin flip is as unpredictable as modern computing allows.

Performance is the primary trade-off. Math.random can generate hundreds of millions of values per second, while crypto.getRandomValues is typically 10-50 times slower due to the overhead of accessing the OS entropy pool. For generating a handful of random numbers as in this tool, the difference is imperceptible. For applications requiring billions of random values, such as Monte Carlo simulations, Math.random or specialized fast PRNGs may be more appropriate.

Avoiding Modulo Bias

A subtle but important challenge in random number generation is modulo bias, which occurs when you try to map a uniformly distributed random value to a smaller range using the modulo (remainder) operator. Suppose you have a random 32-bit integer (values 0 to 4,294,967,295) and you want a random number from 0 to 9. The naive approach is to compute randomValue % 10. However, since 4,294,967,296 is not evenly divisible by 10, the values 0 through 5 each have a slightly higher probability (429,496,730 out of 4,294,967,296) than the values 6 through 9 (429,496,729 out of 4,294,967,296).

This bias is small (less than 0.0000002% in this example) but becomes significant when the range is larger relative to the source range. The standard solution is rejection sampling: compute a threshold that is the largest multiple of the target range that fits within the source range, and discard any random value at or above that threshold, generating a new one instead. This guarantees a perfectly uniform distribution at the cost of occasionally needing to generate an extra random value. This tool implements rejection sampling to ensure that every number within your specified range has exactly equal probability of being selected.

Dice Probability and Statistics

Dice rolling is one of the oldest and most intuitive forms of random number generation, dating back thousands of years to ancient Mesopotamia. The mathematics of dice probability provide an accessible introduction to probability theory. A single fair die with N faces produces a uniform distribution: each face has a probability of exactly 1/N. For a standard six-sided die, each number from 1 to 6 has a probability of 1/6 or approximately 16.67%.

When rolling multiple dice and summing the results, the distribution shifts from uniform to approximately normal (bell-shaped) as the number of dice increases. This is a direct consequence of the Central Limit Theorem, one of the most important results in statistics. For two six-sided dice, the sum ranges from 2 to 12, but these values are not equally likely. A sum of 7 can be achieved in six different ways (1+6, 2+5, 3+4, 4+3, 5+2, 6+1) and has a probability of 6/36 or 16.67%, while a sum of 2 can only be achieved one way (1+1) with a probability of 1/36 or about 2.78%. This probability distribution is fundamental to the design and balance of countless tabletop games.

Different dice types serve different purposes in gaming and simulation. The four-sided die (d4) produces values 1-4 and is often used for small damage values. The six-sided die (d6) is the most common and familiar. The eight-sided die (d8) provides moderate ranges. The ten-sided die (d10) is useful for percentile systems when two are rolled together. The twelve-sided die (d12) and twenty-sided die (d20) are staples of role-playing games like Dungeons and Dragons, where the d20 is used for most ability checks, attack rolls, and saving throws.

Coin Flipping and Bernoulli Trials

A coin flip is the simplest possible random event: a Bernoulli trial with two equally likely outcomes. Despite its simplicity, the coin flip is surprisingly rich in mathematical significance. The probability of getting exactly k heads in n flips follows the binomial distribution, which is one of the most important probability distributions in statistics. The expected number of heads in n flips is n/2, and the standard deviation is the square root of n/4.

The Gambler's Fallacy is a common misconception about coin flips (and all independent random events). After seeing several heads in a row, many people believe that tails is "due" or "more likely" on the next flip. In reality, each flip is independent, and the coin has no memory of previous results. The probability of heads on the next flip is always exactly 50%, regardless of what happened before. Understanding this principle is fundamental to correct reasoning about probability and is directly relevant to gambling, risk assessment, and decision-making.

Practical Use Cases for Random Number Generators

How This Tool Ensures Fairness

This random number generator implements several measures to ensure that results are as fair and unbiased as possible. All randomness is sourced from crypto.getRandomValues(), which provides cryptographic-grade random numbers. Rejection sampling eliminates modulo bias, ensuring that every number within your specified range has exactly equal probability. For the dice roller, each die is rolled independently using the same unbiased algorithm. For the coin flipper, each flip is an independent event with precisely 50/50 odds.

All computation happens entirely in your browser. No random numbers are generated on a server, transmitted over the network, or stored anywhere. You can verify this by disconnecting from the internet and confirming that the tool continues to work. This client-side architecture ensures that no one, including the operators of this website, can predict or influence your results.

Frequently Asked Questions

How does this random number generator work?

This random number generator uses the Web Crypto API (crypto.getRandomValues) to produce cryptographically secure random numbers. Unlike Math.random(), which uses a deterministic pseudo-random algorithm, the Web Crypto API draws from the operating system's entropy pool, producing numbers that are truly unpredictable and suitable for games, simulations, and decision-making. All generation happens in your browser with no data sent to any server.

Are the generated numbers truly random?

The numbers are generated using a cryptographically secure pseudo-random number generator (CSPRNG) provided by the Web Crypto API. While technically pseudo-random, these numbers are seeded from hardware entropy sources like thermal noise, mouse movements, and disk timings, making them indistinguishable from true random numbers for all practical purposes including gaming, statistics, and decision-making.

What is the difference between crypto.getRandomValues and Math.random?

Math.random() uses a pseudo-random number generator (typically xorshift128+) that is fast but predictable if the internal state is known. crypto.getRandomValues() uses the operating system's cryptographic random number generator, which draws from hardware entropy sources. The crypto API is slower but produces unpredictable output suitable for security-sensitive applications, while Math.random() is adequate for animations and non-critical uses.

Related Tools