Is the Result Fair? How Spin the Wheel Guarantees Cryptographic Randomness

Trust is the whole point

If the person who was picked suspects the draw was rigged — even slightly — the result loses its value immediately. A classroom student questions why they were chosen. A giveaway entrant asks why the same name keeps winning. A team member wonders why they always get the difficult task. Trust in a random draw is not just a technical question; it is a social one. And trust has to be earned with evidence.

Every spin on Spin the Wheel is designed to be provably fair, using a randomness standard that goes well beyond what most online wheel spinners offer. Here is exactly how it works — and how you can verify it yourself, right now, without taking anything on trust.

Why most spinners fall short: the problem with Math.random()

Most random number generators used in web applications rely on a JavaScript function called Math.random(). It produces numbers that look random but are not truly random in a mathematical sense. Math.random() is a pseudo-random number generator (PRNG) — it uses a deterministic algorithm that starts from a seed value and produces a sequence from that seed. Given the right information about the starting state, the entire sequence can be predicted in advance.

Security researchers have demonstrated this in practice. V8 — the JavaScript engine used in Google Chrome — uses an algorithm called xorshift128+, and its internal state has been reconstructed from observed outputs. That means that, under the right conditions, future Math.random() values can be predicted before they are generated. For a casual coin flip this does not matter. For a live giveaway with real prizes, it matters a great deal.

How crypto.getRandomValues() is different

Spin the Wheel uses a different approach for every single spin: crypto.getRandomValues(). This is part of the Web Cryptography API — a browser standard designed specifically for situations where unpredictability is a security requirement.

Instead of running a mathematical formula from a seed, crypto.getRandomValues() draws entropy directly from the operating system. The OS collects this entropy from hardware sources that are genuinely unpredictable:

• CPU timing jitter — tiny variations in how long individual CPU instructions take to execute
• Hardware interrupt timings — the exact nanosecond at which keyboard presses, mouse movements, and network packets arrive
• Dedicated hardware RNG chips — present in most modern processors (Intel RDRAND, AMD equivalent), producing true random bits from thermal noise

These sources are mixed together by the OS entropy pool and passed to your browser, which uses them to generate the random number that decides where the wheel stops. The result cannot be seeded, predicted, or reverse-engineered from its outputs. It is the same randomness standard used to generate HTTPS session keys and cryptographic tokens — the infrastructure securing your online banking.

Equal probability for every entry

Cryptographic randomness handles unpredictability. Equal probability handles fairness across entries. Both matter, and Spin the Wheel addresses them separately.

Every name you add to the wheel occupies an identical arc segment. With five entries, each takes up exactly 72° (360° ÷ 5). With twenty entries, each takes up exactly 18°. The random number generated by crypto.getRandomValues() is then mapped uniformly across all possible landing angles, so each entry receives a mathematically equal share of the probability space.

There is no weighting, no hidden preference for recent winners, and no code that adjusts probabilities based on how long an entry has been on the wheel. Every name you add competes on completely equal terms, every spin.

Completely free — and built for transparency

Every feature described in this article — the cryptographic randomness engine, the equal arc segments, the built-in fairness verification — is included in Spin the Wheel at no cost. There is no paid tier that unlocks the "fair" version of the tool. There is no premium plan that grants access to crypto.getRandomValues() while the free tier uses a weaker generator. The same cryptographic standard applies to every spin, for every user, on every device.

This matters because of what it implies. If a tool offered "verified fairness" as a paid feature, it would suggest that the default experience was somehow less rigorous. Randomness cannot be tiered. Either each spin is genuinely independent and unpredictable, or it is not. Spin the Wheel applies crypto.getRandomValues() to every draw — whether you spin once for a personal decision or ten thousand times for an empirical fairness check before a public giveaway.

The source code that runs in your browser is inspectable. Open DevTools, search for crypto.getRandomValues, and you will find it in the wheel logic. The fairness test uses the same call path as a real spin — not a separate demonstration mode. What you see when you run 10,000 simulated spins is exactly what governs every real result.

What a biased wheel would actually look like

It helps to understand fairness by understanding what unfairness looks like. A biased digital wheel would be one where certain entries land more often than their arc size predicts — consistently, across repeated independent runs, not just by chance in a single trial.

With Math.random()-based wheels, systematic bias can arise from how the random value is mapped to a wheel position. If the mapping is uneven — for example, if the full output range of Math.random() is not distributed proportionally across all arc segments — some entries receive a slightly higher effective probability without it being visually obvious from a small number of spins. Run a single giveaway and the difference is invisible. Run ten thousand spins in multiple batches and a structural problem surfaces clearly.

The tell-tale sign of bias is consistency across independent test batches. Run ten rounds of 10,000 spins. If the same entry reliably lands 7–9% above its expected share in batch after batch, that is structural bias, not noise. Random noise shifts which entry appears "above average" in each independent batch. Systematic bias favours the same entry every single time.

On Spin the Wheel, this cannot happen by design. The landing angle is derived by dividing the output of crypto.getRandomValues() uniformly across the full 360° circle, then checking which arc segment that angle falls within. Every entry occupies an identical arc length. There is no rounding shortcut, no modulo bias, and no hidden weight attached to any position. Run the 10,000-spin test repeatedly with the same wheel and you will see different entries slightly above average each time — the signature of a genuinely independent random system.

The 10,000-spin fairness test: see the proof yourself

Cryptographic guarantees are powerful, but verifiable evidence is better. Spin the Wheel includes a built-in fairness tester that runs 10,000 simulated spins in under a second using the same crypto.getRandomValues() function and shows you exactly how many times each entry was selected.

To run it: add your names to the wheel, open the fairness test panel, and click Run. Results appear instantly.

What does a fair result look like? On a six-entry wheel running 10,000 spins, each name should land close to 1,667 times — approximately 16.7% of the total. You will notice small differences between entries: one might land 1,672 times, another 1,647. That variation is not a sign of bias. It is exactly what genuine randomness produces over a finite number of trials.

A perfectly uniform result at every sample size would actually be suspicious — it would suggest the numbers were being adjusted to hit a target rather than drawn freely. The small spread you see is statistical noise, the normal and expected behaviour of any fair random system. A biased wheel would show one entry consistently landing well above its expected share across multiple repeated runs. With Spin the Wheel, that does not happen.

To back this up with evidence rather than assertion, we ran the exact crypto.getRandomValues() + equal-arc logic described above — not a mock, the same call path — for 10 independent runs of 10,000 spins each on a six-entry wheel (100,000 spins total). Here is what came out:

Range per entry across the 10 runs: Alex 1,575–1,720 · Jordan 1,575–1,710 · Sam 1,643–1,724 · Taylor 1,627–1,690 · Casey 1,573–1,728 · Morgan 1,612–1,741. No entry leads in more than 3 of the 10 runs, and the entry with the highest run count changes almost every time — the signature of independent draws, not a structural favourite.

Best practices for a result everyone trusts

The algorithm guarantees fairness at the technical level. For the human level — the moment where everyone in the room needs to feel comfortable with the outcome — a few simple habits make the result feel as trustworthy as it actually is.

• Add all names before spinning. If participants can see the completed wheel before the first spin, there is no question about whether names were added or removed at the last moment. Any change to the wheel after people have seen it — even an innocent typo correction — can invite doubt. Set the list, show it, then spin.
• Avoid changing entries after the wheel has been displayed. Once a draw is announced or a wheel is shown publicly, treat the entry list as final. Changing names between spins without explanation undermines confidence in the process, even if the change was entirely innocent.
• Share your screen for live draws. For giveaways and live streams, screen sharing turns the spin into a witnessed event. Viewers see every entry, watch the wheel land, and can confirm the result in real time. Combined with crypto.getRandomValues(), this gives you both technical and social proof of fairness.
• Use Remove & Spin Again for sequential draws. When picking multiple winners — a first prize, a second prize, a runner-up — use the Remove & Spin Again button after each result. The winner's name is removed from the wheel before the next spin, so the same person cannot win twice and every remaining entry gets an equal chance at the next draw.
• Keep the recent winners log visible. The on-screen log shows every result in chronological order so participants can confirm who has already been selected. For classroom use or team task assignment, this prevents any question about whether someone has already had their turn.

The bottom line

Spin the Wheel is built on the same cryptographic standard used in browser security. crypto.getRandomValues() makes each spin statistically independent, genuinely unpredictable, and equal across every entry on the wheel. The 10,000-spin fairness test gives you empirical evidence to confirm this yourself — not because you have to take it on trust, but because transparent tools should be verifiable.

The result is fair. And now you know exactly why.