How WheelOurNames randomness works

Randomness comes from one module, secureRandomInt(), which calls the browser's crypto.getRandomValues — the same cryptographically secure generator browsers use for security-sensitive work. It fills a 32-bit unsigned integer and reduces it into the range we need.

Unbiased reduction (rejection sampling). Taking a 32-bit value modulo the number of entries would very slightly favour the first few entries, because 2³² is not usually divisible by your list length. So we discard any draw at or above the largest whole multiple of the range and draw again. The leftover values are thrown away rather than folded in, which removes the modulo bias entirely.

Math.random() is not used. Math.random() is a fast, non-cryptographic generator with no guarantees about its seeding or output quality, and it is not used anywhere in a WheelOurNames draw. There is deliberately no silent fallback to it: if a browser did not expose Web Crypto, the draw would fail with an explicit error rather than quietly downgrade to a weaker source.

Selection and animation are separate. The winner is decided the moment you spin. The wheel then computes the rotation that puts that slice under the pointer and animates to it. The physics you see are cosmetic: spin duration, easing curve, the number of turns and the small random landing offset inside the winning slice all change what the spin looks like, never who wins.

On an ordinary wheel every entry carries weight 1, so every entry has an identical chance. Three entries means 33.33% each; six entries means 16.67% each. The chance does not depend on where an entry sits in the list or which colour it happens to get.

Duplicates are separate entries, on purpose. If your list contains "Truth" three times and "Dare" once, that is four entries: Truth has a 75% chance and Dare 25%. This is often exactly what people want, so we never merge duplicates behind your back. Use Dedupe in the entries panel to collapse identical labels into one row — and if weights are switched on, Dedupe adds the merged rows' weights together so each surviving label keeps the same overall probability.

Weights let one entry count more than another. A weight is a whole number from 1 upwards, and an entry's chance is simply its weight divided by the total of all weights. With A = 1, B = 2 and C = 3, the total is 6, so A wins 1/6 of the time (16.67%), B 2/6 (33.33%) and C 3/6 (50%).

One module builds the cumulative weight ranges, and everything derives from it: the winner draw, the width of each slice, the target rotation, which slice the pointer resolves to, and the simulator's expected percentages. Because there is a single model rather than parallel calculations, the wheel you see and the odds you get cannot disagree — a slice that occupies half the wheel wins half the time.

The weighted draw itself uses one integer draw across the weight total and a cumulative walk, so no floating-point rounding enters the selection at all.

Below is the same simulator that runs on the wheel pages, loaded with six demo entries. It performs the requested number of draws through the identical selection code a real spin uses, then charts the observed share of each entry against the expected share.

What a simulation shows. It shows that the observed distribution of many draws is consistent with the expected probabilities, and it makes an obvious bias — an entry that never wins, or wins far too often — easy to spot.

What it does not show. It is a statistical check, not a proof. It does not verify the whole application, it does not certify the random source, and it cannot rule out every possible defect. Randomness also produces real variation in finite samples: in 100 draws across 6 entries you should expect visibly uneven bars, and results that were suspiciously even would be the strange outcome. The bars settle towards the expected values as the number of draws grows, and they never land on them exactly.

The Giveaway Wheel can produce a Draw Record: a file, generated in your browser, documenting a draw you just made.

A Draw Record contains:

• the number of entrants and each entrant's weight, in wheel order
• the draw settings — weights on or off, repeat winners allowed or not, how many winners were requested
• the winners, in draw order, each with a timestamp
• the randomness method used
• a SHA-256 hash of a canonical, deterministic text form of those recorded inputs and outputs — an integrity fingerprint of the record itself

The hash is best understood as a deterministic fingerprint of the recorded data. Any two records with the exact same entries, weights, settings, winners, order and timestamps will produce the same hash. Any change to those recorded details, even a single character or digit, will produce a different hash. If someone kept an earlier copy of the record or just the hash, they can compare it later and see whether the data still matches.

What the hash does not do:

• it does not authenticate who created the record
• it does not prevent anyone from creating a different record and computing a valid hash for it; it only makes it possible to detect that two records differ
• it is not third-party certification, an audit, or legal proof
• it is not a digital signature, blockchain verification, or a provably-fair protocol
• it is not a guarantee that the entrant list was complete or honest

It is useful for exactly one thing, and it is genuinely useful for that: giving everyone a clear, shareable statement of what was entered, what the settings were, and who was drawn.

Random-picker sites often claim more than they can support. We try not to. You will not find us saying WheelOurNames is "100% random", "perfectly random", "certified", "provably fair", "tamper-proof", "industry audited" or "impossible to manipulate" — none of those are things a browser-based tool can honestly assert about itself.

What we do say is precise: a cryptographically secure random source, unbiased integer selection, a transparent probability model, expected probabilities you can check with the simulator, and documented draw inputs.