Random Picker & Decision Maker
Flip a coin, roll dice, draw a random number, pick winners from a list, or split names into fair teams — all using cryptographically strong randomness.
Interactive Client Prototype Sandbox
Flip a fair coin — heads or tails.
Disclaimer: This free tool is provided “as is,” without warranties of any kind, and is for general informational purposes only — not professional, legal, financial, medical, tax, or engineering advice. Results may contain errors; verify anything important independently and use at your own risk. We accept no liability for any loss or damage arising from its use. See our Terms of Use for details.
Step-by-Step Guide
Choose a mode from the tabs: Coin Flip, Dice, Number, Pick from List, or Split into Teams.
Coin Flip: press Generate to flip a fair coin — heads or tails, each with exactly 50% probability. Use Again to reflip.
Dice: set the number of dice and the number of sides per die (standard options are 4, 6, 8, 10, 12, and 20 sides, or enter a custom number). Press Generate to roll all dice and see each result plus the total.
Number: enter a minimum and maximum integer. Press Generate for a random integer in that range, inclusive of both endpoints.
Pick from List: paste one item per line (names, options, prizes). Set how many to pick. Press Generate to draw the specified number of unique items at random. Items are not repeated in a single draw.
Teams: paste names one per line and set the desired team size. Press Generate to shuffle the list and divide it into evenly-sized teams, with any remainder noted.
Dice: 2 six-sided dice → results might be [4, 6], total 10. Number: 1 to 100 → picks a single random integer, e.g. 73. Pick from List: paste 8 names, pick 3 → draws 3 unique names at random without repetition. Teams: 10 names, team size 3 → creates 3 teams of 3 and 1 leftover.
Who it's for
Teachers, event hosts, gamers, raffle organizers, and indecisive groups.
Core Features
- Coin flip, custom dice (N dice of M sides), and ranged random integers.
- Pick a number of unique items from a pasted list.
- Split a list of names into fair teams of a chosen size.
- Uses crypto.getRandomValues with Fisher–Yates for unbiased results.
🛡️ No tracking — your inputs, keys, and details never leave this client sandbox.
Is the randomness truly fair?
Yes. All modes use the browser's crypto.getRandomValues function, which is a cryptographically secure pseudo-random number generator (CSPRNG). It uses hardware entropy sources and is indistinguishable from true randomness for practical purposes. This is significantly stronger than the Math.random() function used in many web tools, which is only suitable for non-security purposes.
How does the team shuffler ensure fairness?
The team generator uses the Fisher-Yates shuffle algorithm to randomly permute the list of names, then divides the shuffled list into groups of the chosen size. Fisher-Yates guarantees that every possible ordering of the names is equally likely — there is no bias toward any particular arrangement. The result is the same quality of randomness as physically shuffling cards and dealing them.
What does 'pick without replacement' mean?
Pick from List draws items without replacement, meaning the same item cannot be selected twice in a single draw. If you pick 3 from a list of 8, you will always get 3 distinct items. This models lottery drawings, prize raffles, and contest winner selection. If you want items to be potentially picked multiple times (with replacement), you would need to run multiple individual picks — or simply paste the same item multiple times in the list.
How do I use this for a classroom raffle or office giveaway?
Paste the list of participants one per line in the Pick from List mode, set the count to the number of prizes, and press Generate. The tool picks the specified number of unique winners at random. For multiple rounds (e.g., different prizes), run Generate again — the picker does not track previous results across sessions, so winners from a prior run may be picked again in a new run.
Why the quality of randomness actually matters for a classroom name picker
For a coin flip that decides who buys the first round of drinks, the quality of the random number generator is irrelevant. For a classroom raffle where a student's name being drawn determines whether they receive a prize, or a team-shuffling exercise where a student might notice they are always in the same group, the randomness quality starts to matter. And if you are generating cryptographic keys, API tokens, or contest winners in a legally binding giveaway, weak randomness is a genuine security and fairness problem. This tool uses the same cryptographically strong random source regardless of use case — not because a coin flip needs it, but because using a strong source everywhere is simpler and never makes things worse.
Math.random() vs. crypto.getRandomValues(): a practical difference
JavaScript's Math.random() is a pseudo-random number generator (PRNG) seeded from the system clock. It produces sequences that look random but are algorithmically predictable if an attacker knows the seed or can observe enough outputs. For UI animations, game mechanics, and casual decisions it is fine. For anything where an observer gaining advance knowledge of the output would be a problem — raffle winners, password generation, session tokens — it is not. The browser's Web Crypto API (crypto.getRandomValues()) gathers entropy from hardware sources: CPU timing jitter, thermal noise, mouse events, and other unpredictable physical phenomena. It is computationally infeasible to predict and is the same source that browsers use internally for TLS certificate verification and password manager key generation.
The Fisher-Yates shuffle and why naïve shuffling is biased
The team generator and the Pick from List mode both need to randomly permute a list. The naïve approach — for each item, pick a random position to place it — is subtly wrong: some orderings appear more frequently than others because different items can "compete" for the same position. The Fisher-Yates (Knuth) shuffle avoids this: starting from the last element, swap each element with a randomly chosen element at or before its position. This produces a provably uniform distribution where every possible ordering of n items is equally likely with probability 1/n!. The algorithm runs in O(n) time and is the standard approach in every serious implementation.