Color Wheel Picker

Small disputes, instantly settled

Color choices are strange: they are almost never important and yet reliably contested. Which color each player gets in the board game. Which team is "red team" in training. Which color the kids' rooms get painted first. What color tonight's art-class still life should feature. The wheel converts each of these from a negotiation into a draw that nobody can relitigate — the spin history stands as the record.

Everything below is a walk through what the engine actually does with this preset. Every angle, percentage and count on the page is computed at build time by the same code that runs the wheel, and the worked draws use scripted bytes so they can be replayed — a live spin draws its bytes from crypto.getRandomValues instead. The distinction this wheel depends on — the names being picked versus the fills the segments are drawn in — has its own guide, Segment geometry and colours; the full mechanism is on the methodology page, and the rest of the guides are collected at /guides/.

What the preset is, and how to change it

The preset is 16 color names in a fixed order: Red, Orange, Yellow, Green, Teal, Cyan, Blue, Navy, Purple, Magenta, Pink, Brown, Black, Gray, White, Gold. They are ordinary text labels loaded into the same editable entry list every other wheel uses, so nothing about them is special to the engine. A wheel of 16 names is divided into 16 equal segments of 360/16 degrees, in list order, each 22.5° wide, and each name wins 6.25% of spins. Edit the list and the wheel is rebuilt from whatever you leave: delete the neutrals, add the two shades you are actually arguing about, or replace everything with a palette of your own. Edited lists are saved in your browser's local storage so they survive a reload, and Reset list puts the 16 default names back. Because the entries are labels, a name does not have to be a color at all; the engine cares only that it fits on a segment.

16 names, 8 fills

The one thing this wheel has to be clear about is that the color you see on a segment is not the color being picked. Segments are painted from the site's fixed drawing palette of 8 fills, cycled in list order, chosen so that neighbouring segments contrast and the white label text stays readable on every fill. The pick is the name on the segment; the fill is only where the name is drawn. The table is the engine's own output for this preset — index, name, the angles the segment occupies clockwise from the pointer, the midpoint the pointer rests on when that name wins, and the fill it is painted with.

Two things follow from that table. First, the fills repeat: 16 divided by 8 leaves a remainder of 0, so the palette cycles exactly 2 times and every fill appears on 2 segments — Red and Purple share one, for instance. A shared fill means nothing: those are indices 0 and 8, separate outcomes at 6.25% each. Second, the fill belongs to the position, not the word. The segment labelled Red sits at index 0 and takes the first palette fill, #7e22ce; reverse the list and the engine reports the same fill, #7e22ce, at index 0 — now under the name Gold. Whether a fill happens to resemble the name printed on it is coincidence, and the wheel does not try to arrange one. The palette's single adjustment — the last segment takes the second palette fill whenever plain cycling would give it the same fill as the first — stays quiet on this preset, because a remainder of 0 never hands the last segment the first fill. Trim the list to 9 names, one more than the palette holds, and it wakes: the remainder becomes 1, the last segment (Purple) would wrap to #7e22ce beside the first, and the engine paints it #2563eb instead. The segment geometry guide walks through the cycle and the boundary arithmetic for every wheel size.

One scripted spin, byte by byte

The mask is doing the work there. The engine keeps just enough bits to cover the 16 names and ignores the rest of the byte, which you can see by feeding it two bytes that differ only in their top bits: byte 3 and byte 195 both produce Green. Rejection sampling is the other half of the mechanism — any masked value at or beyond the segment count is discarded and a fresh byte drawn — but on this particular count it never fires. The build ran every one of the 256 values a byte can hold through uniformInt as the first byte of a spin on the 16-name wheel: all 256 were accepted on the first draw, 0 were rejected, and the accepted bytes fall on the 16 names exactly 16 times each. That is a property of the count, not a shortcut in the engine. Delete one name — Gold, say — and the same exhaustive run on 15 names accepts 240 bytes, rejects 16 and redraws for each, and still lands exactly 16 bytes on every name. A remainder would not discard those 16 values at all — it would silently favour low-numbered segments, the modulo bias the methodology page describes. Scripted, the redraw looks like this: bytes 15 then 195 on the 15-name wheel cost 2 draws — the first masked value fell at or beyond 15 and was discarded, and the second gave Green. On a live spin the bytes come from the browser's cryptographically secure generator, the pick is made the instant you press Spin, and only then does the roughly four-second ease-out rotation begin — a rotation calculated to decelerate onto the segment that already won. If your system asks for reduced motion, the rotation is skipped and the identical draw is announced at once.

Assigning colors to several teams

Tick eliminator mode and each spin removes the name it picks, which is exactly what handing out team colors needs: no two teams can land the same color, and nobody chooses. The convention is yours to fix before the first spin — the walk-through gives the first pick to Team A and works down the list — and the engine supplies the draws. Each one is a fresh uniform draw over the names still on the wheel: 1/16 for the first team, 1/15 for the second, and so on. Below, 4 teams are assigned with scripted bytes; every row is the engine's own output.

Result: Team A Magenta, Team B Yellow, Team C Blue, Team D White, with 12 names still on the wheel for anyone who joins late. Spin 2 needed 2 draws because a scripted byte fell outside the shrinking range and was rejected — the redraw rule applies at every step, and it is what keeps the second draw at exactly 1/15 rather than tilted toward the top of the list. Elimination states are immutable values, so the sequence above can be replayed exactly; the spin history of a live run lives only on the page and dies with the tab. Let the mode run to the end and it becomes a knockout: with a tape that hands over byte 0 every time, the engine removes Red first, continues in list order, and needs 15 spins to leave Gold as the survivor — an order entirely of the bytes' making, which is the point. Because every spin is uniform over what remains, each of the 16 names survives a full run with probability exactly 1/16, or 6.25%. Two practical rules follow from the mechanism: eliminator mode needs at least two entries — with one, the engine answers "Eliminator mode needs at least two entries." — and editing the list mid-elimination restarts the elimination on the new list, so settle the roster of colors before the first team spins. Eliminator mode has its own guide, Eliminator mode, explained, and running a wheel for a room of people another, Using the wheel for groups.

Custom palettes through the parser

Multi-line input keeps its commas. Type "Rust, dusty", "Mint, pale", "Navy, inky" on 3 separate lines and the parser returns 3 entries with the commas intact — the first is "Rust, dusty" — because splitting on commas happens only when the whole input is a single line. Entries are trimmed and blank lines dropped, so stray spaces and empty lines cost nothing. Duplicates are the trap worth naming. Type Red, red, RED, Blue on 4 lines and the parser keeps all 4, because each line is an entry: the name red then occupies 3 segments and wins 75% of spins, which is either a deliberate weighting or an accident. Tick Remove duplicate entries and later copies are dropped case-insensitively, first occurrence wins: the list collapses to 2 names, "Red" keeps the capitalisation it was first typed with, and each name is back to 50%. The caps are equally plain and never silent. A single label of 83 characters is refused with "Entries are limited to 80 characters — "Ultramarine Ultramar…" is too long to fit on a segment." — the limit is 80 characters so a label still fits on a segment — and a palette of 101 shades is refused with "A wheel holds at most 100 entries — this list has 101. Remove some entries; nothing was silently dropped." Nothing is trimmed and nothing dropped in either case. The parser's rules are collected in Entry lists and parsing rules.

Sharing a palette by link

Copy share link percent-encodes each entry and joins them with | into a #items= fragment on this page's address, so a palette travels as text and nothing else. The paint finalists become https://spinthatwheel.net/color-wheel-picker/#items=Sage|Terracotta|Ochre|Slate|Oatmeal, 87 characters in all. Commas survive the trip because they are encoded rather than interpreted: the 3 yarn lines encode to Rust%2C%20dusty|Mint%2C%20pale|Navy%2C%20inky, and decoding returns the same 3 entries, commas included. The full preset encodes to 91 characters against a cap of 1800, so the default list fits with room to spare; a list that would not fit gets an honest error rather than a truncated link, and a damaged link is reported as damaged. Browsers do not include the fragment in web requests: whoever opens the link has the identical wheel rebuilt locally, and the list is never sent to the hosting server. The details are in Share links and privacy.

As a creative constraint

Artists and crafters use random color draws as deliberate constraints: spin twice and work only in those two colors; spin daily for a month-long palette challenge; spin to break the habit of reaching for the same comfortable blues. A constraint you did not choose pushes work somewhere your taste would not have gone — which is the entire value of randomness in creative practice.

Reading the result, and four misreadings

The winner is drawn the instant you press Spin; the result line under the wheel is written when the rotation settles onto it — or at once if your system asks for reduced motion — and the animation is presentation, not the draw. The spin history lives only on the page and dies with the tab. Four readings of that history are wrong, and each is wrong for the same reason: the pick comes from the bytes, not from the drawing. First, "that fill happens to resemble the name on it, so the wheel was built to favour that segment" — fills follow position, every fill appears on 2 segments, and each name wins 6.25% of spins. Second, "it slowed right past Gold, so Gold nearly won" — the rotation was calculated to stop on the winner, and no other segment was ever in contention. Third, "Red has not come up all afternoon, so it is due" — each spin is an independent draw at 6.25%, whatever came before. Fourth, "eliminator mode changes the odds" — it changes what remains, and each remaining name stays exactly as likely as the others at every step. To check rather than trust, the rigging guide walks through what to look for, and the browser's network tab will show that no request carries your list.

Related wheels

Assigning colored teams usually means assigning people first — the custom wheel with eliminator mode deals out names without repeats. The Dice Wheel handles turn order once teams exist, and the Zodiac Wheel is the other fixed-theme wheel on the site.

Frequently asked questions

Names, not color science: this wheel picks from a list of names with uniform probability; it makes no claims about color theory. Lists stay in your browser — see the methodology page.