Random Picker

A random picker selects one item from a list without requiring a person to choose manually. Common uses include classroom participation, meeting order, lightweight giveaways, task assignment, lunch choices, team warmups, and any situation where a visible neutral choice helps avoid bias. This page works with a line-by-line list, can animate the draw, can keep a local draw history, and can optionally avoid repeated selections by removing chosen items from the remaining pool. Randomness can make a choice fair in the statistical sense, but it does not validate identities, prevent duplicate names in the input, or provide audit evidence. For official raffles, compliance, eligibility checks, and prize distribution, use a process with records and rules appropriate to the event.

Random Picker is built on the Web Crypto API (W3C, WHATWG), specifically crypto.getRandomValues(typedArray), which is the only cryptographically secure random source exposed in browsers. Under the hood the browser calls into the operating system's CSPRNG: CryptGenRandom on Windows (AES-256 in CTR-DRBG mode since Windows 10), getrandom(2) on Linux (which reads from the same ChaCha20-based pool that feeds the kernel's /dev/urandom), SecRandomCopyBytes on macOS, and the equivalent on iOS, Android, and BSD. The output is suitable for key generation, nonces, salts, IVs, and any place where predictability would be a security problem. The 'crypto-grade' distinction matters. Math.random() in V8 uses xorshift128+ (a fast, low-entropy algorithm) and returns a 64-bit float in [0, 1); a hostile actor who observes a few outputs can in principle reconstruct the 128-bit state and predict every future value. The same is true for SpiderMonkey and JavaScriptCore. This makes Math.random() unfit for any use where the result must be unguessable — fair selection of a winner, a token, a one-time password, a deal in a card game, an audit sample. crypto.getRandomValues(typedArray) is the only choice for those. Mapping uniform 32-bit integers to a uniform index in [0, N) without modulo bias is the second engineering detail that separates correct from broken. Naively, idx = randomUint32 % N is wrong: if N does not divide 2³², the first 2³² mod N values are slightly more likely. The correct algorithm is rejection sampling: compute limit = 2³² - (2³² mod N); draw a 32-bit value r; if r >= limit, redraw; otherwise return r % N. The bias falls from O(N / 2³²) to zero. For N = 2 or N a power of 2 the modulo is exact, but rejection sampling is the safe default and costs at most one redraw on average (and always terminates). The picker stores results in localStorage with a versioned key, so a session can survive a page reload and a user can review the draw history. The history is not encrypted or signed — it is local, non-sensitive, and easy to clear. For no-repeat mode the algorithm draws without replacement using a Fisher-Yates partial shuffle: at step k of N, swap element k with a uniformly chosen element in [k, N) and lock element k as drawn. This is O(N) time, O(1) extra space, and gives every permutation equal probability, which is the right combinatorial guarantee. (The naive 'draw N times, rejecting repeats' is also correct but O(N²) and can stall on long sessions.) For weighted picks (each option has its own probability), the standard algorithm is inverse-CDF sampling with a prefix-sum array: build a prefix sum of weights, draw a uniform real in [0, total), and binary-search for the smallest i such that prefix[i] >= u. That is O(log N) per draw, and the prefix sum is built once per change. Alias method (Walker-Vose) gives O(1) per draw at the cost of O(N) setup, which is worthwhile only when N is large and the distribution is fixed.

• Source of randomness: crypto.getRandomValues(typedArray) — the only cryptographically secure RNG in browsers, backed by OS-level CSPRNG (AES-256 CTR-DRBG on Windows 10+, ChaCha20 on Linux/macOS/iOS/Android).
• Math.random() is xorshift128+ on V8 (and variants on other engines): fast but predictable. Never use it for fair selection, tokens, OTPs, or audit samples — only for visual noise, animations, or non-security sampling.
• Unbiased index mapping: rejection sampling, not modulo. Compute limit = 2³² - (2³² mod N); if the random uint32 >= limit, redraw; else return r % N. Avoids the classic 'modulo bias' where short-range indices appear more often.
• No-repeat draws use Fisher-Yates partial shuffle in O(N) time, O(1) space: at step k swap element k with a uniform element in [k, N), then lock k. Every permutation is equally likely.
• Weighted picks use inverse-CDF sampling: build a prefix sum of weights once, draw a uniform real in [0, total), binary-search for the smallest prefix[i] >= u. O(log N) per draw.
• Draw history is persisted in localStorage with a versioned key, so a session survives a page reload. The history is local-only and not security-sensitive — clear it from the UI when finished.
• Fisher-Yates vs 'draw N times with rejection': both are correct in distribution, but Fisher-Yates is O(N) total and O(1) memory, while naive rejection is O(N²) in the worst case (lots of repeats near the end of a long list).
• Output range and types: getRandomValues accepts Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, BigInt64Array, BigUint64Array — and the page always uses Uint32Array to feed the index-mapping step.