Yes or No Wheel

Why spin a wheel instead of flipping a coin?

A physical coin flip is fine — when you have a coin, a hard surface, and no argument about whether the catch counted. The wheel removes the logistics and the disputes: the draw is a single uniform pick between two outcomes, the result is announced in text (no squinting at a rolling coin), and the spin history below the wheel keeps a record of the session — useful when "best of five" gets invoked, as it always does.

Everything below is the mechanism behind that draw, and every figure in it — each angle, probability, count and error message — is computed at build time by the same engine that runs the wheel above, not typed in. If your first question is whether the spin can be trusted at all, start with the guide Is the wheel rigged? How to check, which walks through the checks you can run yourself; the sections here explain what those checks are checking.

What the two-segment wheel does

The preset behind this page is the 2-entry list Yes and No. The engine divides the circle into 2 equal segments of 180° each, in list order, clockwise from the pointer at the top: Yes runs from 0° to 180° with its midpoint at 90°, and No from 180° to 360° with its midpoint at 270°, each taking the next color from a fixed eight-color palette. That geometry is for your eyes. When you press Spin, the engine first draws an index into the list, and only then rotates the wheel so that segment's midpoint lands under the pointer — the roughly four-second ease-out rotation is calculated to decelerate onto a winner that already exists. With 2 entries each has probability exactly 1/2, which is 50%. If your system asks for reduced motion, the animation is skipped and the identical draw is announced at once, which shows directly that the spinning was never the deciding part.

How one random byte becomes Yes or No

Random bytes come from crypto.getRandomValues, the browser's cryptographically secure generator. The engine takes the minimal number of bits whose range covers the number of outcomes, masks away the excess top bits, and if the value left is at or beyond the count, discards it entirely and draws again. It never takes a remainder: the naive randomValue % N favors low-numbered segments whenever the byte range does not divide evenly by N, and rejection sampling exists to refuse that shortcut.

For 2 outcomes the engine needs 1 bit, so each byte is masked down to its lowest bit and every byte value is usable: Yes when that bit is 0, No when it is 1. To make that concrete, this page runs the engine at build time with a scripted byte source — bytes chosen for illustration, where a live spin draws from crypto.getRandomValues. Fed the byte 6, spin() picks Yes and tells the animation to land on 90°; fed the byte 9, it picks No and lands on 270°. Each of those spins consulted the byte source 1 time. The same build step also drives every one of the 256 possible byte values through the engine once, the way the automated tests do: 128 land on Yes, 128 land on No, and 0 are rejected, an acceptance rate of 100%. Equal counts are what "exactly 1/2" means in practice — there is no byte value that favors either answer.

The Maybe toggle: three equal segments

Tick Include Maybe and the entries box is refilled with the 3-entry preset Yes, No, Maybe — the same box, the same engine, one more line. The circle is now cut into 3 segments of 120° each, with midpoints at 60°, 180°, 300°, and each outcome has probability exactly 1/3, or 33.33%. Untick the box and the two-entry preset returns; Reset list does the same and also clears any edited list saved in this browser.

Three outcomes are where rejection sampling starts to matter. The engine now needs 2 bits, which can express 4 values, but only 3 of them name a segment; the leftover value is discarded and redrawn. The scripted run on this page shows it happening: fed the bytes 255 and then 6, the first byte masks to a value at or beyond 3 and is thrown away, the second is accepted, and spin() picks Maybe, landing on 300° — the engine consulted the byte source 2 times for one result. Across all 256 byte values, 64 land on Yes, 64 land on No, 64 land on Maybe, and 64 are rejected and redrawn: an acceptance rate of 75%, which is why redraws are rare and the spin stays instant. Had the engine taken a remainder instead, those 64 leftover values would have been folded back onto the low-numbered segments — exactly the modulo bias it refuses to have.

Weighting by repetition, in the open

There is no weight slider, deliberately: a hidden weight is a rigged wheel. What the list does allow is repetition. Put Yes on two lines and No on one — the list Yes, Yes, No — and the engine builds 3 equal segments of 120° each, 2 of them labelled Yes. The draw is still a uniform pick of one segment, so Yes wins with probability 2/3, or 66.67%, and No with 1/3, or 33.33%; Yes covers 240° of the circle, and anyone watching can see that it does. Three Yes lines and one No make it 75% to 25% across 4 segments of 90°. The rule is copies divided by total entries, which also sets the limit: a wheel of N segments can only express steps of 1/N.

One caution. The Remove duplicate entries switch under the list does the opposite of weighting. Run the same three-line list through the parser with dedupe on and it collapses to 2 entries, Yes and No, and the wheel is back to 50% each. The match is case-insensitive and the first occurrence wins: Yes, yes, YES and No on four lines come out as 2 entries, Yes and No. Leave dedupe off when repetition is the point.

Editing the list: the comma rule and the caps

The preset is a starting list, not a cage, and anything you type into the entries box goes through the same parser as every other wheel on the site. It has two rules worth knowing. One entry per line is the default. A single line containing commas is treated as a comma-separated list instead, so pasting “Yes, No, Maybe” on one line yields 3 entries. Once the input has more than one line, commas stay inside entries: “Yes, but later” on one line and “No, not this year” on the next parse to 2 entries, exactly as written. Entries are trimmed and blank lines dropped.

The caps are honest errors, never silent truncation. A wheel holds at most 100 entries and each entry at most 80 characters. Hand the parser a 240-character entry and it refuses with “Entries are limited to 80 characters — "YesYesYesYesYesYesYe…" is too long to fit on a segment.”. Hand it 101 lines and the message is “A wheel holds at most 100 entries — this list has 101. Remove some entries; nothing was silently dropped.”. Both messages are produced here by calling the parser at build time, and it is the same parser the entries box calls as you type. An edited list is saved in this browser's local storage under this page's own key, so it survives a reload; Reset list removes it and restores the preset.

Sharing this wheel

Copy share link encodes the current entries — the list, and only the list — into the page address as a #items= fragment: each entry is percent-encoded and the entries are joined with |. For the Maybe wheel the link is https://spinthatwheel.net/yes-no-wheel/#items=Yes|No|Maybe. The weighted list above encodes as Yes|Yes|No, 10 characters, and the two comma entries become Yes%2C%20but%20later|No%2C%20not%20this%20year, which is how commas, spaces and any other character survive the trip intact. Browsers do not include the fragment in web requests, so opening a link rebuilds the wheel locally without sending the list to the server. The encoded value is capped at 1800 characters with an honest error, and a damaged link is reported as damaged rather than decoded into a garbled wheel. The link carries entries, not switches: a recipient of the three-entry link sees Yes, No and Maybe in the box with the toggle unticked, which is the right state, because the toggle only ever swaps lists.

Why there is no eliminator toggle here

The custom wheel offers eliminator mode, where each spin removes its pick and the last entry standing wins. This page does not, and the engine shows why. Start an elimination on the 2-entry list and run one scripted spin: it eliminates Yes, leaves 1 entry, and the state is already finished with No as the survivor. Ask for another spin and the engine refuses: “This elimination is finished — reset to run it again.”. With two entries, eliminating one is the same uniform draw as picking the other with the labels swapped — the survivor is each entry with probability 1/2 — so the toggle would add a step without adding a thing. Eliminator mode earns its place on longer lists, where every entry still survives with probability exactly 1/N; the guide Eliminator mode, explained works through one.

Reading a run of spins

Each spin is an independent draw. The engine keeps no memory of the last result, and nothing about the wheel's resting position, the timing of your click or the deceleration curve feeds into the next pick. A run of identical answers is therefore not a stuck wheel: 5 Yes results in a row has probability 1/2 multiplied by itself 5 times, which is 3.13%, and the same streak of one answer on the three-segment wheel is 0.41% — uncommon, not impossible, and computed here rather than guessed. The spin history under the wheel lists each result in order, so a best-of series is settled by the record rather than by memory. History and results exist only on the page and die with the tab; your list, by contrast, is saved locally so it survives a reload. Nothing is transmitted either way — open your browser's network tab and spin, and no request carries your entries.

Check it yourself

Because the draw precedes the animation, the checks are simple and you can run them: reduced motion shows the same draw without any animation, the network tab shows nothing leaving, and the figures on this page are recomputed by the engine on every build, so the documentation cannot drift from the code. Is the wheel rigged? How to check collects those checks step by step, and the guides index covers the rest of the site. The wheel's limits are stated just as plainly on the methodology page: the randomness is cryptographically strong, but this is not a certified gambling or raffle system — there is no auditor, no seed escrow, and no protection against someone simply re-spinning until they like the result.

A decision tool, used honestly

Randomness is genuinely the right tool when options are close enough that deliberation has stopped adding information — where to get coffee, who calls the restaurant, which of two near-identical plans to try first. It is the wrong tool for anything with real stakes. The useful middle ground is the gut check: commit to obeying the wheel, spin it, and pay attention to your reaction. Relief and disappointment are data no pro/con list gives you.

Related wheels

For the same two-outcome draw in different clothes, try the Coin Flip Wheel. Deciding whether to leave the house is what the Go or Stay Wheel is framed for, and invitations get the Accept or Decline Wheel. For more than a handful of options, the custom wheel takes any list up to 100 entries.

Frequently asked questions

For fun and tie-breaks: 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.