Entry lists and parsing rules

Every wheel on this site — the custom wheel and each preset — has the same entries box under it, and one small function turns whatever is in that box into segments. This guide walks through its rules in the order the engine applies them: lines and commas, trimming, duplicate removal, the two caps, and what happens when you repeat an entry on purpose. Every count, angle, probability and error message below was produced at build time by running that parser and the wheel geometry on short example lists. The other guides are collected on the guides index.

One box, one function, one honest answer

The parser takes the raw text of the box and returns one of two things: an accepted list of entries, or an error with a plain-language message. There is no third outcome — the parser never accepts part of a list, never shortens an entry to fit a cap, and never quietly discards anything. (How a long label is painted on the canvas is a separate, cosmetic matter, covered under the misreadings below.) An error is shown under the box and Spin is disabled until you change the text; an accepted list is what the wheel draws from, in the order you typed it. The methodology page states the rules in its parsing section, with worked examples of its own; the sections below show each one running on different inputs.

Rule one: one entry per line

The default reading is the obvious one. Each line of the box is one entry, and the wheel gets its segments in that order, clockwise from the pointer.

Punctuation, capitals, digits and accented characters pass through unchanged. The build parsed 3 lines carrying an accent, a hash sign, a digit and inverted punctuation and got back 3 entries reading exactly as typed: "Café on the harbour", "Rooftop #2", "¿Old Mill again?". Apart from the single-line comma rule below, only line breaks are structural.

Rule two: a single line with commas splits on the commas

A list typed on a single line, as Rooftop, Harbour, Old Mill, should still build a wheel; that is the one reason this rule exists. So when the box holds exactly one non-blank line and that line contains a comma, the parser splits on commas instead, trims each piece, and drops any piece that is empty.

Both pastes produce the same 3 entries in the same order, which is the point: both pasting styles build the same wheel. The trailing comma in the second row adds nothing, because an empty piece is dropped rather than turned into a blank segment.

Rule three: multi-line input keeps its commas

The comma rule is decided by line count alone, never by reading the words. The moment there is a second non-blank line, commas stop being separators and become ordinary characters inside entries — which is what you want when an option is a phrase.

The second and third rows are the misreading to watch for. A phrase with a comma typed as the only line is read as a list of 2, because the parser cannot tell a one-item list from a sentence and picks the reading that gives you a wheel. Add any second line and the phrase stays whole: the box parses to 2 entries with the comma intact. If a comma ever splits something you meant to keep together, give the other entries their own lines.

Trimming and blank lines

Before any rule above runs, each line is trimmed of leading and trailing whitespace, and lines that are empty after trimming are dropped; spaces inside an entry are kept, so "Old Mill" stays two words. A box typed as 7 raw lines — leading spaces before the first name, blank lines, a line holding only a tab, and trailing spaces after the last name — parses to 3 entries: "Rooftop", "Harbour", "Old Mill". This is also why the comma rule counts non-blank lines: a comma list followed by an accidental empty line is still a single-line list.

Duplicates: off by default, case-insensitive when on, first wins

The parser keeps duplicates unless you tick Remove duplicate entries under the box. With the switch on, entries are compared with case folded, and the first occurrence of each is kept exactly as typed while later ones are removed.

Note which spelling survives: Harbour, the first as typed, not a normalised lower-case form. The default matters too: a roster pasted twice by accident really does become a wheel with everyone on it twice. The switch never rewrites the text in the box, so turning it off brings the repeats straight back.

The two caps and their exact messages

A wheel holds at most 100 entries, and an entry may be at most 80 characters long, so segments and labels stay readable on a circle. Both caps are enforced with an error rather than a silent cut, and the checks run in a fixed order: entry length first, then duplicate removal if it is on, then the entry count.

The number wheel's list generator will not go past 100, so the over-cap message is what one more line produces. The build made that list with the engine's own numberRange helper: 101 lines holding the numbers 1 through 101, the same text you would get by typing them by hand. The parser answered with this message, quoted from the engine:

A wheel holds at most 100 entries — this list has 101. Remove some entries; nothing was silently dropped.

The same helper stopped at 100 parses cleanly, so the cap is inclusive. Because duplicate removal runs before the count is checked, a list whose excess is repeats passes once the switch is on: 101 lines where the last repeats the one before it fail with "A wheel holds at most 100 entries — this list has 101. Remove some entries; nothing was silently dropped." with the switch off, and parse to 100 entries with it on.

The length cap reads the same way. An entry of 82 characters anywhere in the list stops the whole list with a message that quotes its beginning so you can find it:

Entries are limited to 80 characters — "The long way round p…" is too long to fit on a segment.

An entry of exactly 80 characters is accepted — the build parsed one, which came back as 1 entry. Because the length check runs first, an over-long entry fails even when it is a duplicate the switch would have removed. There is also the case of nothing at all: parsing an empty box succeeds with 0 entries — an empty list is a valid list — but no wheel can be built from it, and the geometry step reports "Add at least one entry to build a wheel." The page keeps Spin disabled until an entry exists.

Weighting by repetition

The wheels have no weight sliders, and that is a design decision. The parser keeps repeats, the geometry gives every entry its own equal segment, and the draw picks a segment index uniformly — so repeating an entry is exactly how you make it more likely, and the result is visible to anyone looking at the wheel.

The list Rooftop · Harbour · Harbour gives, by the engine's own arithmetic:

• Segments drawn: 3, each 120° wide
• Segments labelled Harbour: 2
• Harbour wins: 2/3 = 66.67%
• Rooftop wins: 1/3 = 33.33%

Each draw picks one of the indexes with equal probability, so the repeated label simply owns more of them, and copies never merge into one wide segment: they sit where the list puts them, each coloured by its position like every other segment. A scripted draw shows the mechanics. With the byte source scripted to return 2, the spin function picks index 2, whose label is Harbour, and asks the animation to settle at 300°; live spins draw those bytes from crypto.getRandomValues instead, which is the only difference.

This is the framing the Yes or No wheel already uses: add Yes twice and No once for a transparent bias. Built from the preset, that list has 2 of its 3 segments labelled Yes, so Yes wins 66.67% of spins and No wins 33.33%. A hidden weight would give the same odds while still showing the preset's 2 equal segments; the repeated segment shows the odds it carries. Two consequences follow. Leave Remove duplicate entries off when repeats are intentional — with it on, the weighted list collapses to 2 entries at 50.00% each. And in eliminator mode each spin removes one segment, not every copy of a label: on the weighted list, a byte source scripted to return 1 removes the copy of Harbour sitting at index 1, leaving Rooftop and Harbour on the wheel — 2 entries, the other copy included, each at 1/2.

What the parsed list looks like in a share link

Copy share link encodes the parsed list, not the raw text of the box, so the rules above have already been applied by the time a link exists. Each entry is percent-encoded and the entries are joined with a bar, which is why commas inside multi-line entries survive the trip. The 3-entry list from rule three encodes as Rooftop%2C%20then%20Harbour|Old%20Mill|Skip%20it%2C%20stay%20home, 65 characters against a cap of 1800. Opening the link runs the same caps as typing, and a damaged link is reported rather than decoded into a garbled wheel. What does and does not leave your browser is covered in the guide to share links and privacy.

Reading the box: the common misreadings

• "The wheel dropped one of my entries." It did not — the line was blank after trimming, the duplicate switch removed a repeat, or a comma inside a single-line paste split it.
• "My long entry got cut off." The parser never shortens an entry: past the 80-character cap the whole list is refused, and anything that parsed is stored in full. What you saw is the canvas. Each wheel has a character budget for the labels it paints, which shrinks as the wheel fills with segments, and a label over that budget is abbreviated with an ellipsis where it is drawn. The entry itself is intact: the result line and the spin history announce the full text, and the full text is what a share link carries.
• "I only have 100 entries and it still refuses." Look for a stray comma turning one line into several — the error states the count the parser actually saw.
• "Repeating an entry made one big segment." It made several equal ones. The probability is copies over total, and every copy is drawn on the wheel.

Frequently asked questions

For lists and tie-breaks: the parser never guesses silently — every dropped, split or refused entry follows one of the rules above, and every figure in this guide was computed at build time by the same engine that runs the wheels. Everything runs locally in your browser; see the methodology page for how the draw works.