How a Wheel Picker Chooses a Winner Fairly

What “fair” means for a wheel

A wheel picker is fair when every entry has the same chance of winning, and when no earlier spin, no position on the wheel and no outside party can change those chances. That sounds obvious, but it is a stricter standard than “it looks random”. A wheel can look chaotic and still favour some entries, for example if its slices are uneven or if the software behind it uses a flawed way of turning random numbers into positions.

It helps to separate the show from the decision. The spinning animation, the optional clicking sound and the slow-down near the end are presentation. What matters is the step that decides which entry wins, and whether that step treats all entries equally.

Equal slices, equal chances

On a physical prize wheel, fairness depends on engineering: slices of identical size, a balanced axle and a pointer that does not catch unevenly. A browser wheel has none of those problems, because the wheel is just a drawing. Each entry gets an equal share of the circle, so with 10 entries each slice covers 36 degrees and with 20 entries each covers 18.

Equal slices only matter visually, though. On a screen, the wheel does not “land” by physics. The winner can be chosen first and the animation can then be drawn so that it comes to rest on that slice. That is a sound design, as long as the choice itself is made fairly.

Choosing the winner with a secure random source

A wheel picker such as this one chooses the winner with crypto.getRandomValues(), the browser’s built-in secure random number function. According to MDN, browsers implement it with a pseudo-random generator that is seeded with high-quality entropy from the operating system, and the result is suitable for cryptographic purposes. It is the same source browsers use for security-sensitive tasks, and a much stronger choice than the everyday Math.random(), which the documentation says should not be used for security.

For a casual wheel, you might ask whether that level of quality is overkill. It is not harmful, and it brings one practical benefit: the outcome cannot be predicted from earlier results. If you watch ten spins, you gain no information about the eleventh. The next article in this series, on pseudo-random versus true random numbers, explains why that property matters.

Avoiding modulo bias

Getting random numbers is only half the job. The picker must turn a raw random number into an entry number, such as 0 to 11 for twelve entries. The shortcut is to take the remainder after division, written % in code. That shortcut is subtly unfair.

Here is a simple example. Suppose the random source gives numbers from 0 to 255 (one byte) and you have 10 entries. Dividing 256 by 10 leaves a remainder of 6, so entries 0 to 5 can be produced by 26 different byte values each, while entries 6 to 9 can be produced by only 25. The first six entries are slightly more likely to win. With fewer raw values per entry, the gap grows; with a very large range, it shrinks to something negligible, but it never quite vanishes.

The standard fix is rejection sampling: if the random number falls in the uneven leftover part of the range, throw it away and draw again. Every entry then corresponds to exactly the same number of accepted values. The wheel picker described here chooses its winner without modulo bias in this way.

Why the spin itself changes nothing

People sometimes worry that spinning the wheel, or the moment they click, influences the result. In a well-built picker it does not. The click starts the process, but the outcome comes from the random draw, not from timing, mouse position or how long the animation runs. Spinning again simply makes a new, independent draw.

Independence has a consequence that surprises many people: past results do not matter. If the same entry wins twice in a row, that is not a malfunction. With five entries, the chance of a repeat is one in five on every spin, regardless of history. A wheel that avoided repeats would actually be less random, because it would be using memory to steer the outcome.

What you can do to keep a draw fair

The software handles the maths, but the person running the wheel still controls several things that affect fairness:

• Check the list before spinning. Make sure every eligible entry is present exactly once. This wheel can remove duplicates, ignoring upper and lower case, so a name typed twice does not get a double chance by accident.
• Decide the rules first. Agree who is eligible and how many spins will be made before anyone sees a result, not afterwards.
• Accept the result. Re-spinning until you get the answer you like defeats the purpose.
• Keep the list readable. The wheel stays legible up to roughly 50 entries; beyond that, slices become hard to read, even though the draw is still equal.

Shuffling the order of entries on each spin does not change anyone’s odds. It only means that the same names do not always sit next to each other on the wheel, which makes the display less predictable.

Where a wheel is and is not the right tool

A fair wheel is ideal for low-stakes choices: who goes first, which film to watch, who presents next. For anything with real consequences, such as hiring, grading or money, a random pick is rarely the whole answer, and the people involved deserve a proper process. If a draw does form part of that process, such as a prize draw, the rules that apply differ by country and platform, and the organiser should check them; nothing here is legal advice.

Within its proper scope, a wheel offers something valuable: a decision that nobody has to argue about because everyone could see the same equal slices and the same random draw.