Letter Wheel

Using this wheel with a class, a meeting, or a household? The guide Using the wheel for groups: classrooms, meetings, households walks through loading a roster, removing duplicates, running eliminator mode so nobody is picked twice, sharing the finished wheel by link, and resetting it afterwards. This page covers the letter preset itself: its geometry, how one spin picks a letter, how the list parser reads your edits, and how eliminator mode walks through the alphabet. All guides are listed at /guides/.

What a random letter is actually for

The letter wheel is the referee for every game that starts "name a …" — countries, animals, foods, bands, Scattergories-style category rounds. It also earns its keep in classrooms: phonics practice ("find something in the room starting with…"), spelling warm-ups, and picking whose surname initial goes first without anyone claiming the teacher plays favorites. Writers use it as a cheap prompt: a random initial for a character name breaks the habit of reaching for the same three sounds.

Humans are terrible letter randomizers

Ask a room to "pick a random letter" and you will hear a chorus of M, R, and S — letters from the comfortable middle of the alphabet — and almost never a J, Q, or X. That bias matters the moment a letter decides who goes first or which category is in play. The wheel replaces the chorus with a uniform draw: J and Q come up exactly as often as M, which is precisely what makes the hard rounds memorable.

The preset: 26 letters, 13.85° each

The list behind this wheel is the alphabet, A through Z, as 26 entries in order — a preset the engine's automated tests pin at exactly 26 letters. When the page builds, computeSegments divides the circle into 26 equal segments of 360/26 = 13.85° each, measured clockwise from the pointer at the top and laid out in list order. A occupies 0.00° to 13.85°; M, the 13th entry, runs from 166.15° to 180.00°; Z, the last, ends at exactly 360°. Every boundary is an exact multiple of 360/26, so no letter gains or loses a fraction of a degree to rounding. Colours cycle through the fixed 8-colour palette in order — 3 complete cycles plus 2 more segments — with one adjustment reserved for wheels where the last segment would otherwise match the first; on this wheel the engine gives A and Z different colours.

The geometry exists for the eyes only. When a spin picks index 12, the wheel is rotated so that M's midpoint, 173.08°, comes to rest under the pointer — but the number that decided the winner was the index, chosen before a single degree of rotation. Each of the 26 segments wins with probability 100/26 = 3.85%; the arc merely draws that share. All of these figures are computed at build time by the same engine that runs the wheel above, which is why the prose cannot drift from the code.

One spin, byte by byte

Live spins take random bytes from crypto.getRandomValues, the browser's cryptographically secure generator. To make the mapping demonstrable, the examples in this section feed the engine a scripted byte sequence instead — the same technique the automated tests use to pin the mapping — so every number below was produced by the real engine at build time and reproduces identically on every build. Only the bytes are scripted; the rules are the ones every live spin follows.

For 26 letters, the engine needs the smallest number of bits whose range covers all 26 indexes: 5 bits, which span the values 0 through 31. It draws a random byte, keeps only its low 5 bits, and checks the result against 26. Values from 26 to 31 — 6 of the 32 possibilities — are at or beyond the list, so they are discarded entirely and a fresh byte is drawn. Nothing is ever mapped by remainder. That is what keeps every letter at exactly 3.85%: folding the 32 masked values onto 26 letters with a naive % 26 would hand the 6 overflow values to A, B, C, D, E, F as extra chances, and those letters would come up slightly more often than the rest.

Scripted example one — rejection. Script the bytes 30 then 12. The first, 30, fits within 5 bits but is at or beyond 26, so the engine discards it and draws again. The second, 12, is below 26 and is accepted: the spin lands on index 12, the letter M, and the animation is handed 173.08° — that segment's midpoint — as the angle to decelerate onto. Had the engine taken a remainder instead of redrawing, the first byte would have decided the spin.

Scripted example two — masking. Script the single byte 200, which is 11001000 in binary and far wider than 5 bits. The engine keeps its low 5 bits, 01000, which read as 8; that is below 26, so it is accepted and the wheel lands on I. Because the mask keeps the acceptance rate above half — here 81.25%, or 26 accepted values out of 32 — redraws are rare and spins stay instant.

Whichever bytes arrive, the index exists before the wheel moves. The roughly four-second ease-out rotation is calculated to decelerate onto the segment that already won; nothing about the resting position, the timing of your click, or any previous spin feeds the draw. If your system asks for reduced motion, the animation is skipped and the identical draw is announced immediately — the plainest demonstration that the spinning was never the deciding part.

Dropping letters: how the parser reads your edits

Every preset is a starting list, not a cage. The entries box under the wheel holds the alphabet one letter per line, and the engine's parseEntries reads whatever you leave there. Its rules: one entry per line; a single line containing commas is treated as a comma-separated list instead; entries are trimmed and blank lines dropped; the Remove duplicate entries switch removes repeats case-insensitively, first occurrence winning; and lists cap at 100 entries and 80 characters per entry, with an honest error rather than a silent truncation.

Worked example — a trimmed alphabet. Replace the box with the single line A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, R, S, T, U, V, W, Y: the alphabet minus Q, X, and Z, as a category game might want. Because it is one line with commas, the parser splits on the commas into 23 entries, and computeSegments lays them out at 15.65° each, so every remaining letter now wins with probability 4.35% instead of 3.85%. The 3 removed letters do not linger as blanks or zero-width slivers; they are simply not on the wheel.

The comma rule is strictly single-line. Type Q, X, Z on one line and J on the next and the commas do not split: the parser returns 2 entries, the first of which is the literal label "Q, X, Z". Multi-line input keeps its commas so that an entry like "Go out, or stay in?" stays whole; if you want separate letters, put them on separate lines or all on one line together.

Duplicates are kept unless you ask otherwise. The five-line input A, a, B, b, A parses as 5 entries with the switch off — 3 of the 5 segments read A or a, which is no longer a fair alphabet. Turn Remove duplicate entries on and the same input parses as 2 entries, A and B, keeping the first spelling of each.

The caps refuse rather than trim. Paste the numbers 1 through 101 one per line and the parser answers: "A wheel holds at most 100 entries — this list has 101. Remove some entries; nothing was silently dropped." An entry of 81 characters is refused too: "Entries are limited to 80 characters — "QQQQQQQQQQQQQQQQQQQQ…" is too long to fit on a segment." In neither case does the wheel quietly spin a shortened list.

Eliminator mode: through the alphabet without repeats

Tick Eliminator mode and the reading of a spin inverts: each spin's pick is removed from the wheel, and the overall winner is the last letter standing. For a letter wheel the practical effect is a room working through the alphabet in random order with no letter drawn twice — every spin's letter is gone from the next spin — and the spin history under the wheel records the order.

Scripted walk-through (bytes 12, 0, 23, one per spin, scripted for illustration and run through the real engine at build time; live spins draw from crypto.getRandomValues). Spin one draws over all 26 letters, each at 1/26; the byte is index 12, so M is eliminated and 25 letters remain. Spin two draws over those 25, each now at 1/25; index 0 is A, leaving 24. Spin three shows the rule that trips people up: the index refers to the letters still on the wheel, not to the original alphabet. Index 23 of the 24 remaining letters is Z — on the untouched alphabet the same index would have been X. After three spins the eliminated list reads M, A, Z, 23 letters remain, and the elimination is not finished, because a survivor is declared only when a single entry is left.

The fairness argument is the same one the methodology page makes for any list: 1/26 on the first spin, then 1/25, and so on, gives every letter exactly a 1/26 — 3.85% — chance of being the last one standing, identical to its chance on a single plain spin. Elimination states are immutable values in the engine, so a sequence can be replayed and checked step by step. Editing the list while an elimination is running restarts the elimination on the new list, and Reset list brings back the full alphabet.

Sharing a trimmed letter wheel

Copy share link percent-encodes each entry, joins the entries with |, and places the result in the page address as a #items= fragment. Encoded at build time by the engine, the full alphabet becomes A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z — 51 characters. The 23-letter list from the parsing example becomes https://spinthatwheel.net/letter-wheel/#items=A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|R|S|T|U|V|W|Y, a 45-character fragment against a cap of 1800. Browsers do not include fragments in web requests, so the recipient's browser rebuilds the wheel locally and the list never reaches the hosting server. An over-long list gets an honest error instead of a truncated link, a damaged link is reported as damaged rather than decoded into a garbled wheel, and legacy ?items= links still open.

Between visits, an edited list is saved in this browser's local storage — on your device, removable with Reset list or by clearing site data — while spins, results, and the spin history exist only on the page and die with the tab. A share link you copy and send is the only path a list ever takes off your machine, and you can check the claim: open your browser's network tab and spin.

Reading the result, and the common misreadings

The result line under the wheel names the letter, and the pointer rests on that segment's midpoint. Three misreadings come up often enough to answer here. First, no letter is ever "due": a letter that has not appeared for a while has the same 3.85% on the next spin as any other, because nothing about previous spins reaches the draw. Since each spin is an independent draw, the chance that the next spin repeats the letter you just got is also 3.85%, and the chance that a particular letter never appears across 26 consecutive spins is (1 − 1/26)²⁶ ≈ 36.1% — plain spins can skip letters and repeat them, which is exactly what eliminator mode exists to prevent when every letter must come up once.

Second, thin segments are not unlucky segments. The 13.85° slices of this wheel are far narrower than the half-circles of a two-entry wheel, yet each is precisely as likely as its share of the list — probability comes from the draw, not the drawing. Third, the animation is an announcement, not a decision: the letter existed before the first frame, and a reduced-motion spin skips the frames and reports the same letter. What the wheel cannot do is know your game. It will pick Q exactly as readily as M; if Q should be out, take it out of the list.

Related wheels

Need a number instead? The Number Wheel spins a short default range and goes up to 100. For a quicker six-way draw there is the Dice Wheel, and for game-night prompts the Question Wheel spins original icebreakers. For rosters, meetings, and households, read Using the wheel for groups, and browse the rest of the guides.

Frequently asked questions

Local only: your edited letter list stays in this browser and is never transmitted. The draw mechanics are documented on the methodology page.