BrowserTools
Advertisement
Home / Misc / Random Picker — List, Coin, Dice, Number

Random Picker — List, Coin, Dice, Number

Pick a random item from a list, flip a coin, roll dice, or generate a random number.

Loading Random Picker — List, Coin, Dice, Number… If nothing happens, please enable JavaScript.

Frequently asked questions

Are my lists or results stored or sent to a server?
No. Everything you enter into the tool and every result the tool produces exists only in your browser tab. No data is transmitted over the network, no lists are saved to any database, and no results are logged. Closing the tab discards everything permanently.
What is the difference between Math.random() and crypto.getRandomValues()?
`Math.random()` uses a pseudorandom number generator — typically xorshift128+ in modern engines — that is fast but seeded deterministically and not designed to be unpredictable. `crypto.getRandomValues()` draws from the operating system's entropy pool, fed by hardware noise sources, and is designed to be computationally infeasible to predict. This tool uses `crypto.getRandomValues()` for all random selections.
How does the coin flip work — is it really 50/50?
Yes. The coin flip generates a single cryptographically random bit: a random 32-bit integer from `crypto.getRandomValues`, then tests whether it is even or odd. Each flip is entirely independent of all previous flips, and the probability of heads or tails is exactly 50% on every single flip — the same as a physical coin with no memory.
Can I use this for a fair raffle or competition?
Yes, and this is one of the best use cases. Enter all participant names or ticket numbers in the list, one per line, and pick one (or multiple without replacement). Because the underlying generator is cryptographically secure and runs in your browser, there is no operator who can influence the result. For high-stakes draws, consider screen-recording the browser console showing the raw random values for an audit trail.
Can I pick multiple items from a list without repeating the same item?
Yes. In list mode, set the "Pick N" count to the number of items you need and enable the "No repeats" option. The tool performs a Fisher-Yates shuffle — which produces a uniformly random permutation — and returns the first N items from the shuffled list. Each item appears at most once in the result.
How does rolling dice work with multiple dice types?
For each die, the tool generates a cryptographically random integer in the range 1 to the die's face count (1d6 gives 1–6, 1d20 gives 1–20, and so on). Multiple dice are rolled independently and their values are summed where applicable. You can combine different die types — such as 2d6 + 1d8 — to replicate the mechanics of specific tabletop role-playing game systems.
Is this tool suitable for generating random numbers for cryptographic purposes?
The random values are generated with `crypto.getRandomValues`, which is cryptographically secure. However, this tool is designed for human-facing random selection and does not output raw entropy or byte arrays. For generating cryptographic keys, nonces, or tokens, use a dedicated key generation library or tool rather than reading off the numbers displayed here.
What is a Fisher-Yates shuffle and why does it matter?
The Fisher-Yates algorithm (also called the Knuth shuffle) is the standard method for producing a uniformly random permutation of a list. It iterates from the last element to the first, swapping each element with a randomly chosen element at or before its current position. Every possible ordering of the list is equally probable. Naive shuffle algorithms — like sorting by random keys — produce biased distributions where some orderings are more likely than others.
Can I pick a random item with different items having different probabilities?
This tool treats all list items as equally likely. To simulate weighted probabilities, add items to the list multiple times in proportion to their desired weight — for example, if item A should be twice as likely as item B, list A twice and B once. This is equivalent to a weighted lottery ticket system and requires no special tool features.
What happens if two people run this tool at the same time — could they get the same result?
Yes, theoretically. Each browser instance generates its own independent random sequence, with no coordination between users. Two people running the tool simultaneously could get the same result by coincidence, with the same probability as any other matching outcome. For draws where uniqueness across multiple simultaneous users is required — such as assigning non-overlapping random IDs — a server-coordinated approach is needed instead.

About Random Picker — List, Coin, Dice, Number

True randomness is surprisingly hard to achieve with a computer. Computers are deterministic machines: given the same starting state, they produce the same output. Early random number generators for games and simulations used mathematical formulas — typically linear congruential generators — that produce sequences appearing random but that are entirely predictable if you know the seed value and the algorithm. This distinction between true randomness and pseudorandomness matters enormously in contexts like cryptography, where a predictable sequence can be exploited, but also in fair draws, raffles, and games where verifiable unpredictability is part of the social contract.

The need to pick randomly comes up constantly in everyday life and in technical contexts. Teachers use random pickers to call on students without showing favouritism. Raffle organisers draw prize winners from large entry lists. Game masters roll dice for tabletop roleplaying outcomes. Developers need to randomly assign test users to A/B experiment cohorts, shuffle arrays of data, or generate random sample datasets. Decision-makers use coin flips and random number generators to break ties or introduce deliberate variability into processes that might otherwise develop systematic biases. Sports leagues use random draws to assign brackets and fixtures.

This tool uses `crypto.getRandomValues` — the same Cryptographically Secure Pseudo-Random Number Generator (CSPRNG) that browsers use for TLS key material and password generation. Unlike `Math.random()`, which uses an unseeded algorithm that can be predicted from observed output and is explicitly not suitable for security purposes, `crypto.getRandomValues` draws its entropy from the operating system's hardware noise sources: interrupt timing, thermal noise, and other unpredictable physical phenomena. This means each pick is independent of all previous picks and cannot be predicted or reversed. Everything runs in the browser — no server is involved, and no lists or results are stored.

A few practical notes: when picking multiple items from a list without replacement (each item can only be chosen once), the tool performs a Fisher-Yates shuffle of the list and returns the first N items. This is mathematically equivalent to putting names in a hat and drawing them one by one. For dice rolls, you can combine multiple dice types — 1d6 + 1d20 + 2d8 — to replicate tabletop RPG mechanics. For number ranges, the endpoints are inclusive on both sides. If you want a weighted random draw — where some items are more likely than others — duplicate those items in your list proportionally before running the picker.

Rolling Bones to Quantum Noise: Five Millennia of Trying to Generate Randomness

Humans have sought reliable randomness for as long as they have needed to make fair decisions, divide inheritances, or consult the divine. The oldest known randomness devices are knucklebones (astragali) — the ankle bones of sheep, used as dice in Mesopotamia and Egypt as early as 3000 BC. The Roman practice of casting lots (sortes) used pebbles, pottery shards, or wooden tokens drawn from a container. Julius Caesar is said to have settled disputes by lot, and the word "lottery" itself derives from the Old French "lot," meaning fate or portion.

The first algorithmic random number generator was published by John von Neumann in 1946 as the middle-squares method: take a number, square it, extract the middle digits, and repeat. Von Neumann himself was under no illusions — he noted that anyone who uses arithmetic methods to produce random numbers is in a state of sin. The method was deterministic and quickly became periodic, repeating its sequence after a few hundred iterations. Linear congruential generators (LCGs), introduced formally by D. H. Lehmer the same year, were more robust and remained the standard in languages like C's `rand()` for decades.

The recognition that deterministic pseudorandomness is fundamentally unsuitable for cryptography drove the development of hardware random number generators (HRNGs) and later the OS-level entropy pools that underlie `crypto.getRandomValues()` today. Linux's `/dev/random` and `/dev/urandom`, introduced in the mid-1990s, harvest entropy from keyboard timing, disk seek times, and network interrupts. Modern CPUs include dedicated hardware instructions — Intel's RDRAND, AMD's equivalent — that measure thermal noise in transistors to produce true random bits at gigabit speeds. What von Neumann described as sin has been replaced by quantum physics.

Related tools

UUID Generator (v1, v4, v7)

Generate RFC 4122 UUIDs in version 1, 4 or 7 — single or in bulk, copy or download.

Password & Passphrase Generator

Generate strong random passwords and memorable passphrases locally, fully customizable.
Advertisement