Wheel Cue Fairness Report

The short version

Every winner on Wheel Cue is chosen by one small file, random.js. For this report that exact file was run outside the browser and asked for 30.9 million random numbers across eight tests: coin flips, dice, a twenty-slice wheel, a hundred-slice wheel, weighted entries, consecutive results, shuffles, and the step that removes modulo bias.

No test fell below the p = 0.001 threshold that would point to a problem. The lowest p-value in this run was 0.096.

How to read the results

Each test is a chi-squared goodness-of-fit test, the standard way to check whether counts match what a fair process should produce.

• Draws is how many results were picked. Largest deviation is how far the most unusual count landed from its expected value.
• χ² adds up how far every count is from its expected value. df, the degrees of freedom, is roughly the number of possible outcomes minus one.
• p-value answers one question: if everything were perfectly fair, how often would counts at least this uneven turn up by chance?

A test fails here only below p = 0.001, a one-in-a-thousand result. That line is strict on purpose. With a fair generator, p-values are themselves spread evenly between 0 and 1, so a value like 0.04 appears regularly and means nothing on its own. A generator with a real bias does not produce the occasional low p-value: over millions of draws, even a bias of a few tenths of a percent pushes the p-value towards zero, run after run.

What each test checks

Equal slices: a coin, a die, 20 and 100 slices

The simplest claim on the site is that equal entries have equal chances. The coin and the die are the tests anyone can picture; twenty slices is the largest wheel that fits in a share link; one hundred checks a wheel far bigger than most people spin.

Weighted entries

With weights of 3, 1, 2 and 1, each entry's share should equal its weight divided by the total of 7. The observed shares below come from 3,500,000 weighted draws.

Consecutive results

A generator can produce perfectly even totals and still be predictable — if, say, one result made another more likely next. This test draws 3,000,000 pairs of results from a six-slice wheel and checks that all 36 combinations of "this result, then that one" turn up equally often.

Shuffling

Shuffle and the team generator rely on the Fisher–Yates shuffle, which is easy to get subtly wrong. Six items were shuffled 600,000 times, and every item should land in every position equally often.

Rejection sampling

Turning a random 32-bit number into a slice with a plain remainder slightly favors the first slices, because 4,294,967,296 does not divide evenly by most wheel sizes. Wheel Cue throws away numbers from the incomplete final block and draws again. On a normal wheel that happens far too rarely to measure, so this test uses a modulus of 3,000,000,000, where about 30% of numbers must be thrown away.

In this run 30.114% of the numbers were discarded, against a theoretical 30.151%, and the 1,000,000 accepted numbers were spread evenly across ten equal ranges.

What this shows, and what it does not

It shows that Wheel Cue's code turns random numbers into results the way the site says it does: equal slices are equally likely, weights produce their declared shares, a result does not depend on the one before it, shuffles are even, and modulo bias is removed.

It does not show:

• That your browser's random source is secure. These runs used the Node.js implementation of crypto.getRandomValues(). Your browser has its own implementation of the same standard; what Wheel Cue does with the numbers it receives is identical in both.
• That any single spin was fair. No statistical test can say that about one result. Every result window shows its own raw draw and arithmetic instead, so a single result can be checked by hand — see how randomness works.
• Anything about a modified copy of the site. The report belongs to one version of random.js, identified by the SHA-256 fingerprint at the top of this page.

Check it yourself

In your browser. How randomness works has a simulation that runs up to 200,000 draws through the same code, inside the page.

On your computer, with Node.js 18 or later:

1. Save random.js and fairness-report.mjs into the same folder.
2. Confirm it is the file tested here: certutil -hashfile random.js SHA256 on Windows, or shasum -a 256 random.js on macOS and Linux. The result should match the fingerprint at the top of this page.
3. Run node fairness-report.mjs random.js report.json.

It takes about a minute. Your numbers will differ in the details — that is what random means — but no test should fail.