Wheel versus coin versus dice

A coin, a die and a numbered wheel are three shapes of the same thing: a list of outcomes that should each be exactly as likely as the others. On SpinThatWheel they are one engine with a different list loaded — the coin flip wheel is a 2-entry list, the dice wheel a 6-entry list, and the number wheel any range from 1 up to 100. This guide covers what changes between them (the geometry, and how many random bytes are thrown away) and what never changes (the probability per entry, and the pick happening before the wheel moves). Every figure below is computed at build time by calling the engine that runs the wheels. The worked draws use scripted bytes so you can reproduce them; live spins draw from crypto.getRandomValues, the browser's cryptographically secure generator.

Three lists, one draw

For a list of N entries the engine divides the circle into N equal segments of 360/N degrees in list order, draws one index uniformly, and rotates the wheel so that segment's midpoint lands under the pointer. The table is built from those calls.

The last two columns are where the shapes differ. The engine takes the smallest number of bits whose range covers N, masks the rest of the byte away, and discards any candidate at or beyond N before drawing again. The coin's 2 faces need 1 bit, which covers them exactly, so every byte value maps to a face and nothing is discarded. The bits that cover 6 faces span more values than that, so 64 of the 256 byte values are thrown away and redrawn; the d20 discards 96 and the d100 discards 56. A discard is a discard: the engine never folds a rejected value onto a low-numbered entry with a remainder, which is the modulo bias the methodology page describes. Driving every byte value through the mapping — which is what produced this table — hits each die face exactly 32 times, each d20 face exactly 8 times and each d100 number exactly 2 times. Because the mask keeps acceptance above half, redraws are rare and spins stay instant.

The coin: 2 segments, 1 bit

A 2-entry wheel needs 1 bit, so the engine keeps only the lowest bit of the byte it draws. Scripted example: the byte 182 is 10110110 in binary; its lowest bit selects index 0, the entry Heads, and the wheel decelerates to 90°, the midpoint of that segment. The byte 183 is 10110111 — identical except for that lowest bit — and selects Tails at 270°. Each face occupies 180° and wins with probability 50.00%. There is no launch side, no catch and no surface for a wheel to favour: heads and tails are 2 entries of exactly equal probability because the draw is an index, and the half-circles exist for the eyes only.

The die: 6 segments and the first redraw

With 6 faces the engine masks the byte down to a few bits and rejects anything at or beyond 6. Scripted example with the bytes 7 then 3: the first candidate is at or beyond 6, so it is discarded and the engine asks for another byte — 1 redraw, counted by the scripted source. The second is accepted as index 3, the face 4, whose segment runs from 180° to 240°; the wheel decelerates to its midpoint at 210°. Each face is 60° wide and wins with probability 16.67%.

The d20 and the d100: thin slivers, same odds

Set the number wheel's maximum to 20 and the list becomes 20 entries of 18° each, every number at 5.00%. Scripted bytes 250 then 13: the first is rejected (1 redraw) and the second lands on 14 at 243°. Push the maximum to 100 and each entry is a 3.6° sliver at 1.00%; scripted bytes 255 then 41 reject the first (1 redraw) and land on 42 at 149.4°. The labels get small at 100 entries, and it changes nothing about fairness. As the methodology page puts it, 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.

One spin is one draw

The draw is one operation: pick one index from one list. So two dice means two spins. A scripted pair of bytes, 2 then 5, run through two consecutive spins of the 6-face list gives 3 and then 6, for a total of 9 — two independent draws, added afterwards, both visible in the history below the wheel. What the wheel will not do is pretend one spin over the numbers 2–12 equals two dice: the sums are not equally likely, and a single wheel would misrepresent that.

Independence between spins

Each spin is an independent draw. The engine holds no state between picks: nothing about the wheel's resting position, the timing of the press or any previous result reaches the next draw, and the history is a record, not an input. On the 2-entry coin wheel a run of 5 identical results has probability (1/2)^5 = 3.125%. On the 6-face dice wheel the chance that one specific face does not appear in 6 spins is (1 − 1/6)^6 = 33.5%. Both come from the segment counts above and describe ordinary behaviour: runs and gaps are what independent draws look like. The wheel keeps no memory of what it "owes".

Editing the list to any die

Every preset is a starting list. One entry per line is the default; a single line containing commas splits on the commas instead, so both pasting styles work: the engine parses 1, 2, 3, 4 and a 4-line list to the same 4 entries, a d4 of 90° segments at 25.00% each. Multi-line input keeps commas inside entries, so a house-rule face like "move 2, lose a turn" survives as one entry, and "roll again" is as legitimate a face as "6" because the engine picks an index, not a number. The caps are 100 entries and 80 characters per entry. Asking for a d120 by pasting 120 lines returns: A wheel holds at most 100 entries — this list has 120. Remove some entries; nothing was silently dropped.

Dealing faces without repeats

A die can repeat; a deal cannot. Eliminator mode turns the dice wheel into a dealer: each spin removes the picked face, and the next spin is a fresh uniform draw over the faces still on the wheel — 1/6 first, then 1/5, and so on. Here is a full elimination of the 6 faces, replayed through the engine with the scripted bytes 6, 5, 0, 3, 1, 1:

1. Spin 1: 6 faces remain, each at 1/6; the draw removes 6, leaving 1, 2, 3, 4, 5.
2. Spin 2: 5 faces remain, each at 1/5; the draw removes 1, leaving 2, 3, 4, 5.
3. Spin 3: 4 faces remain, each at 1/4; the draw removes 5, leaving 2, 3, 4.
4. Spin 4: 3 faces remain, each at 1/3; the draw removes 3, leaving 2, 4.
5. Spin 5: 2 faces remain, each at 1/2; the draw removes 4, leaving 2.

The survivor is 2; the removal order was 6, 1, 5, 3, 4. The script needed 6 bytes for 5 spins — 1 candidate was rejected and redrawn. Every entry survives with probability exactly 1/6, each state is an immutable value the test suite can replay step by step, and editing the list mid-elimination restarts it on the new list. That is how to seat 6 players in 6 starting positions with no duplicates.

Sharing a die

Copy share link percent-encodes each entry and joins them with | into a #items= fragment on the page address. A d20 built on the dice wheel shares as https://spinthatwheel.net/dice-wheel/#items=1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20, whose encoded list is 50 characters; the full 1–100 list encodes to 291 characters, against a cap of 1800. Browsers do not include fragments in web requests, so opening the link rebuilds the same list locally without sending it anywhere. The link carries the list and only the list — never a result or a history — so the recipient's spins are their own draws.

Why the announcement and the history matter

The draw is finished the instant you press Spin; the roughly four-second ease-out rotation that follows lands on a segment that already won. If your system asks for reduced motion, the animation is skipped and the identical draw is announced immediately — the clearest demonstration that the spinning was never the deciding part. The result is announced as text, so there is no dispute about which side is showing at a glance and no cocked-die state to re-roll. And the history keeps a visible record of the session while living only on the page: spins, results and history die with the tab, and the network tab will show that no request carries your entries.

Which page to open

For 2 outcomes, the coin flip wheel loads Heads / Tails and needs no configuration. For 6, the dice wheel loads 1–6 with eliminator mode for dealing. For any range, the number wheel has a maximum control that regenerates the list from 1 to your number, up to 100. Whatever the page, the draw is the one described in how the wheel picks a winner, and the rest of the guides cover eliminator mode and how to check a wheel for yourself.

Frequently asked questions

For games and tie-breaks: whether it is loaded as a coin, a die or a range of numbers, the wheel decides fairly, but it cannot know your situation — do not delegate consequential decisions to it. Everything runs locally in your browser; see the methodology page for how the draw works.