About

Decision paralysis costs time. When two or more options carry equal weight, rational analysis fails and you need an external tiebreaker. This tool uses crypto.getRandomValues() - the same cryptographic entropy source used in security applications - to run a single-elimination tournament bracket across n items you provide. Each matchup is resolved by sampling a uniform distribution over [0, 1), meaning no item has a statistical advantage. The bracket structure ensures exactly n − 1 rounds are played, and every elimination is visualized as an animated particle collision on a Canvas element. Results are persisted locally so you can track historical outcomes, upvote community brawls, and detect if your RNG has any streaks worth noting. Note: this tool approximates "fairness" under the assumption that the browser's crypto RNG is unbiased - which holds for all modern implementations, but edge cases exist on outdated or compromised systems.

Formulas

The probability that a specific item wins a single-elimination tournament of n items, assuming uniform random selection at each matchup:

P(win) = 1n

The total number of matchups (rounds fought) in a single-elimination bracket:

M = n − 1

The number of bracket rounds (depth of the tournament tree):

R = ceil(log₂ n)

Fisher-Yates shuffle ensures unbiased permutation. For each position i from n − 1 down to 1, swap element at i with a uniformly random element from [0, i]:

j = floor(random() × (i + 1))

The vote score uses Reddit-style aggregation:

S = n∑i=1 v_i

Where v_i ∈ {−1, 0, +1} for each user. n = total items in the brawl. M = total matchups played. R = bracket depth (number of elimination rounds). S = net community score.

Reference Data

RNG Method	Entropy Source	Bias Risk	Speed	Use Case
Math.random()	PRNG (xorshift128+)	Low but non-zero	~50ns	Games, non-critical
crypto.getRandomValues()	OS entropy pool	Negligible	~200ns	Cryptography, fair selection
Hardware RNG (HRNG)	Thermal noise / quantum	None (physical)	Variable	Key generation, lotteries
Linear Congruential	Seed-based formula	High (periodic)	~10ns	Legacy systems
Mersenne Twister	Seed-based (MT19937)	Low but predictable	~30ns	Simulations, Monte Carlo
Atmospheric Noise	Radio static	None (physical)	~500ms (network)	Random.org, audited draws
Lava Lamp Wall	Chaotic fluid dynamics	None (physical)	Variable	Cloudflare TLS seeds
Radioactive Decay	Quantum events	None (quantum)	Variable	Research, national lotteries
Fisher-Yates Shuffle	Depends on RNG source	Inherits source bias	O(n)	Unbiased permutation generation
Rejection Sampling	Any uniform source	Eliminates modulo bias	1.5× base	Uniform range from power-of-2 source
Von Neumann Extractor	Biased coin flips	Removes known bias	~25% throughput	Debiasing weak sources
Fortuna PRNG	Multiple entropy pools	Negligible	High	FreeBSD, macOS /dev/random

Frequently Asked Questions

The tool uses crypto.getRandomValues() which draws from the operating system's entropy pool (thermal noise, interrupt timing, etc.). Items are first shuffled using a Fisher-Yates algorithm seeded by this crypto RNG, which produces an unbiased permutation. After shuffling, bracket matchups are resolved with independent random draws. Item input order has zero statistical effect on win probability - each item has exactly a 1/n chance of winning.

When the number of items is not a power of 2, the bracket awards "byes" to some items in the first round. Specifically, if you have n items and the next power of 2 is 2^k, then 2^k − n items receive a bye and advance to round 2 without fighting. Byes are assigned to the first items in the shuffled order, so the randomness of the shuffle ensures bye assignment is also fair.

Yes. The "My Brawls" tab stores every brawl result with timestamps. If you run the same set of items repeatedly, you can observe win frequencies. Over a large sample (n > 30 runs), each item's win rate should converge to 1/n by the law of large numbers. Significant deviation would suggest a browser-level crypto RNG issue, which is extremely rare in modern engines (V8, SpiderMonkey, JavaScriptCore all use ChaCha20 or equivalent).

The tool treats each input line as a distinct entry regardless of name. Duplicate names are allowed - they are internally assigned unique indices within the bracket. If you enter "Pizza" twice, both instances compete independently and each has a 1/n probability of winning. The results display will show position numbers to disambiguate duplicates.

Mathematically, a single random pick and a single-elimination tournament both give each item a 1/n win probability. The bracket exists for entertainment value - it creates a narrative arc with upsets, underdogs, and a progression that makes the randomness feel meaningful. The bracket also produces a full ranking (elimination order), not just a single winner, which is useful for prioritizing multiple options.

No. The winner of each matchup is determined before the animation begins. The particle physics simulation is purely cosmetic - the "winning" particle is given a slight advantage in the choreography so the visual result matches the pre-determined RNG outcome. If you enable reduced-motion in your OS settings, animations are skipped entirely and results appear instantly.