Methodology & Accuracy

Every wheel on SpinThatWheel is a thin interface over one small, pure, automatically tested engine. This page documents exactly how a winner is chosen, what the animation does and does not do, how eliminator mode and share links work, and what never leaves your browser — so you can judge precisely how far to trust a spin.

The pick happens before the animation

The moment you press Spin, the engine draws the winner. Only after the winner exists does the wheel begin its roughly four-second, ease-out rotation — a rotation calculated to decelerate onto the segment that already won. The animation is presentation; the pick is cryptographically uniform and happens first. Nothing about the wheel's resting position, the timing of your click, the deceleration curve, or any previous spin influences the result. If your system asks for reduced motion, the animation is skipped entirely and the identical draw is announced immediately — which is the clearest demonstration that the spinning was never the deciding part. We state this plainly because most wheel sites do not, and a randomizer that hides its mechanism does not deserve your trust.

Cryptographic uniformity, no modulo bias

Random bytes come from crypto.getRandomValues, the browser's cryptographically secure generator. Mapping those bytes onto N segments uses true rejection sampling: the engine takes the minimal number of bits whose range covers N, masks away the excess top bits, and if the resulting value is N or larger, discards it entirely and draws again — it never takes a remainder. The naive alternative, randomValue % N, silently favors low-numbered segments whenever the byte range does not divide evenly by N; rejection sampling redraws instead, so every segment's probability is exactly 1/N. Because the mask keeps the acceptance rate above half, redraws are rare and spins stay instant. The automated tests drive every possible byte value through this mapping and assert that each outcome is hit exactly equally often, and that rejected values map to nothing at all.

Segment geometry

A wheel of N entries divides the circle into N equal segments of 360/N degrees, in list order, with the boundary angles computed as exact multiples — the tests pin start, end, and midpoint angles for wheels from 1 to 100 segments. Colors cycle through a fixed eight-color palette, with one adjustment so the last and first segments never match. The geometry exists for the eyes only: the winner is picked by index, then the wheel is rotated so that segment's midpoint lands under the pointer. A 3.6° sliver on a 100-entry wheel is exactly as likely as a half-circle on a 2-entry wheel of equals — probability comes from the draw, not the drawing.

Eliminator mode: last one standing

Eliminator mode inverts the usual reading of a spin: each spin's pick is removed from the wheel, and the overall winner is the final entry left after every other has been eliminated. Each elimination is a fresh uniform draw over the entries still remaining — first spin 1/N, next 1/(N−1), and so on — which makes the survivor exactly as likely to be any entry: every entry ends up with probability 1/N of winning, provably. Elimination states are immutable values in the engine; the tests replay full scripted sequences and assert every intermediate state, the elimination order, and the survivor. Editing the list mid-elimination restarts the elimination on the new list.

Entry lists and parsing

Lists accept one entry per line; a single line containing commas is treated as a comma-separated list instead, so both pasting styles work — and commas inside multi-line entries are preserved. Entries are trimmed, blank lines dropped, and an optional switch removes duplicates case-insensitively (first occurrence wins). Wheels cap at 100 entries and 80 characters per entry; hitting a cap produces an error saying exactly what happened — nothing is ever silently truncated or dropped.

Share links carry the list, and only the list

Copy share link percent-encodes each entry and joins them into the page address as an ?items= parameter — unicode, emoji, commas, and even the separator character itself survive the round trip, which the tests verify. Opening such a link rebuilds the wheel locally in the recipient's browser; nothing is fetched from or stored on any server, because there is no server application. Links are length-capped with an honest error, and a damaged link is reported as damaged rather than decoded into a garbled wheel.

Privacy: what stays in the browser

Everything, unless you export it yourself. Lists you edit are saved to your browser's local storage so they survive a reload — on your device, under your control, removable with the Reset button or by clearing site data. Spins, results, and history exist only on the page and die with the tab. The only path a list ever takes off your machine is a share link you yourself copy and send. You can verify the claim: open your browser's network tab and spin — no request carries your entries.

Honest limits

This site's randomness is cryptographically strong, but the site is not a certified gambling or raffle system: there is no auditor, no seed escrow, and no protection against the operator of a screen simply re-spinning until they like the result. For casual fairness among people who trust each other's screens it is excellent; for money-staked drawings it is the wrong tool, and we say so rather than sell it.

Tested against reference behavior

The engine ships with an automated suite well past a hundred tests: exhaustive byte-mapping uniformity checks, exact segment-angle assertions, scripted eliminator sequences, share-link round trips including unicode, parser edge cases, and pinned preset lists (exactly 50 states, exactly 26 letters, twelve signs). Worked figures in page copy are computed at build time by the same engine that runs the wheels, so documentation cannot drift from implementation. If you believe a spin or a number is wrong, that is exactly the report we want — see the contact page; confirmed issues are fixed in the engine and locked in with a new test.