About

Uniform random selection from a finite set is a deceptively hard problem. Most naive implementations rely on Math.random, which uses a pseudo-random number generator (PRNG) with predictable periodicity. This tool uses the browser's crypto.getRandomValues API, drawing from an operating-system-level entropy source (CSPRNG) to produce selections with a bias below 2⁻⁶⁴. The selection index i is computed via rejection sampling over a 32-bit unsigned integer space, eliminating modulo bias entirely. If your list has n items, each item's selection probability is exactly 1n within measurement tolerance.

The tool supports weighted selection, multi-pick without replacement (Fisher-Yates partial shuffle), and maintains a history log so you can audit past draws. Note: "randomness" here means statistical uniformity over large sample counts. For small draws (10 picks), perceived clustering is normal and expected per the birthday paradox. Import lists from files or paste directly. Results are not stored on any server.

Formulas

For uniform random index selection from a list of n items, we generate a 32-bit unsigned random integer r via crypto.getRandomValues and apply rejection sampling to eliminate modulo bias:

limit = 2³² − (2³² mod n)

Repeat: r ← getRandomUint32() until r < limit

index = r mod n

Where n = total number of items in the list, r = raw 32-bit unsigned integer from CSPRNG, limit = rejection threshold ensuring uniform distribution, and index = the unbiased random index (0 ≤ index < n).

For weighted selection, each item i has weight w_i. We build a cumulative distribution:

C_k = k∑i=1 w_i

A uniform random float u ∈ [0, C_n) is generated. The selected index is the smallest k such that C_k > u. For multi-pick without replacement, a partial Fisher-Yates shuffle is applied: swap the chosen element to the end and reduce the pool by 1 per pick.

Reference Data

Feature	This Tool (CSPRNG)	Math.random (PRNG)	Physical Dice
Entropy Source	OS-level (e.g., /dev/urandom)	Algorithmic seed (xorshift128+)	Physical chaos
Bias	< 2⁻⁶⁴	Modulo bias possible	Manufacturing imperfection
Period	Effectively infinite	2¹²⁸ − 1	N/A
Speed (per pick)	< 1 µs	< 0.1 µs	2 - 5 s
Reproducible	No (by design)	Yes (if seed known)	No
Auditable	History log	No built-in	Video recording
Multi-pick w/o replacement	Fisher-Yates shuffle	Manual dedup needed	Remove dice/card
Weighted selection	CDF inversion	Manual implementation	Loaded dice (unfair)
Max list size	2³² − 1 items	Same	~6 faces
Cross-platform	All modern browsers	All JS environments	Physical presence
Cryptographic safety	Yes (CSPRNG)	No	N/A
Use case: Lottery	Suitable	Not recommended	Traditional
Use case: A/B testing	Recommended	Acceptable	Impractical
Use case: Game jams	Overkill but fine	Ideal	Fun
Offline capable	Yes	Yes	Yes

Frequently Asked Questions

When selecting a random index from n items using a 32-bit random integer, naive modulo (r mod n) creates bias if 2³² is not evenly divisible by n. This tool uses rejection sampling: it calculates limit = 2³² − (2³² mod n) and discards any random value ≥ limit. The expected number of rejections is less than 1 for any practical list size, so performance is unaffected.

The random index is generated from a 32-bit unsigned integer, supporting up to 4,294,967,295 items. In practice, browser memory limits the textarea input to roughly 50,000 - 100,000 lines depending on item length. For lists exceeding 10,000 items, the animation is automatically disabled to maintain responsiveness.

Each item can be assigned a numeric weight using the format item|weight (e.g., Pizza|3). The tool computes a cumulative distribution function (CDF) from the weights. A uniform random float is generated and mapped to the CDF via binary search. An item with weight 3 in a pool totaling weight 10 has a 30% chance of selection.

Yes. Set the pick count to any value up to your list size. The tool uses a partial Fisher-Yates shuffle: for each pick, a random index is chosen from the remaining pool, the item is swapped to the end, and the pool shrinks by 1. This guarantees no duplicates and runs in O(k) time where k is the number of picks.

No. History is stored in localStorage and can be edited by anyone with browser dev tools. This tool provides an audit log for convenience, not for legal or contractual randomness verification. For legally binding draws, use a notarized third-party service with published seeds and cryptographic commitments.

With replacement enabled (default for single picks), every draw is independent. For a list of n items, the probability of the same item appearing twice consecutively is 1n. For a 10-item list, that is 10% per draw. This is expected behavior, not a flaw. Disable replacement or use multi-pick mode to avoid repeats.