Rastgele Seçici

A free random picker and name wheel that runs in your browser

This random picker turns any list into a fair draw. Paste your names or options one per line, then spin the wheel to reveal a winner — or skip the animation and pick instantly with Quick Pick. It works as a random name picker, a raffle picker, a random number generator and a list shuffler, all on one page.

There's nothing to install and no account to create. Your list never leaves your device — unlike Wheel of Names (wheelofnames.com), which processes your entries on their server. Whatever you paste is remembered locally in your browser, so it's still waiting for you the next time you visit. No sign-up, no limits, no watermarks on results.

Spin a wheel of names

The spinning wheel of names is the format people expect from a name picker — every entry becomes a colored slice, and a single click sends the wheel spinning with a satisfying tick before it lands on a winner. Teachers use it as a classroom name picker to call on students without bias; streamers and marketers use it for giveaways and contests; families spin it for chores, Secret Santa pairings or deciding who picks the movie.

The winner is chosen by the secure random function before the animation starts — the wheel is animated to land on that result, not the reverse. This means the result is fair regardless of spin speed or duration. Wheel of Names works the same way but uploads your list to their servers; every list item here stays on your device.

Pick one winner or many — and remove as you draw

Need more than one winner? Set how many to pick and switch on No repeats to draw several distinct names at once — ideal for a raffle with multiple prizes. For an elimination-style draw, turn on remove winner after each spin so every name that's drawn is taken out of the wheel, exactly like pulling a name out of a hat.

A running winners history records every result in order, so you can copy the full list of drawn names — first, second and third place included — the moment your draw is done. Copy the history and post it to your group chat or giveaway page as an auditable record.

Random numbers, shuffles and quick picks

Switch to Number mode to generate a random number in any range. Pick a single number between 1 and 100, or draw several unique numbers for bingo, lotteries and ticketed giveaways. Tick 'Unique' and 'Sort' to get an ordered set of non-repeating numbers. The numbers come from crypto.getRandomValues — the same cryptographic randomness source random.org uses, but without sending your request to their servers.

The Shuffle button reorders your entire list at random, and Quick Pick draws winners instantly without spinning animation — handy when your list runs to hundreds of entries and a wheel with tiny slices would be impractical.

A simpler alternative to Wheel of Names, random.org, and spreadsheet formulas

Wheel of Names (wheelofnames.com) is the most popular name picker wheel but it uploads your list to their server and shows ads. random.org is excellent for verified randomness but requires an internet connection and transmits your request. In Excel or Google Sheets you can pick with =INDEX(A:A, RANDBETWEEN(1, COUNTA(A:A))), but it recalculates every time the sheet changes and removing drawn names by hand is slow.

This random list picker does the same job in a click: keeps a history, removes winners automatically, and exports results as plain text. Copy a column from your spreadsheet, paste it in, draw your winners, done. No formulas, no server uploads, no account. Bookmark it for the next time you need to pick a name, settle a decision, draw a winner or run a fair raffle.

Truly random and completely private

Every draw uses your browser's cryptographically secure random generator (crypto.getRandomValues) with rejection sampling to remove bias, so each entry has a genuinely equal chance. This is the same class of randomness used by password managers and cryptographic protocols — far more unpredictable than Math.random(), which most casual tools use and which can be predicted under certain conditions.

Because everything happens locally, the random picker keeps working offline and never uploads your names, numbers or results. Your entrant list, your draw history, and your winners stay entirely on your device. There are no ads, no account requirements, and no usage caps.

Sampling with replacement vs without replacement

Sampling with replacement means that after an item is picked, it goes back into the pool — so the same item can theoretically be chosen on the very next draw. Lotteries where a single ticket can win multiple prizes are a classic example. In statistics, this is the foundation of bootstrapping: researchers repeatedly resample from the same dataset (with replacement) to estimate the variability of a statistic without collecting new data. With replacement, the probability of drawing any specific item never changes: if there are n items, every draw has a 1-in-n chance, regardless of what was drawn before.

Sampling without replacement removes each chosen item so it cannot appear again. Drawing teams, assigning desks, dealing cards and seating arrangements all follow this model. The probability shifts as the pool shrinks: the first pick has a 1/n chance, the second has a 1/(n−1) chance, and so on. This is why a card dealt from a standard deck changes the odds for every subsequent card — there are now only 51 remaining possibilities. Enabling Remove winner after each spin in this tool switches it to without-replacement mode, making every spin an independent draw from the shrinking pool.

A special case of without-replacement sampling is a complete random ordering of the entire list — better known as a shuffle. When you shuffle all n items, you are essentially drawing the whole pool without replacement until nothing is left, which produces one of the n! possible orderings with equal probability. Every fair card game, sports draft and classroom rotation ultimately relies on this operation.

The Fisher-Yates shuffle: how fair random ordering actually works

The Fisher-Yates shuffle — also called the Knuth shuffle after Donald Knuth, who popularized the Durstenfeld formulation — is the standard algorithm for producing a uniformly random permutation of a list in O(n) time. The process is straightforward: starting from the last element (index n−1) and working backwards to index 1, swap the current element with a randomly chosen element from any position between 0 and the current index (inclusive). After n−1 such swaps, every one of the n! possible orderings has an exactly equal probability of occurring.

The naive alternative — assigning each element a random number and then sorting the list by those numbers — appears simpler but is subtly wrong. Because sort algorithms require a consistent comparison relation to produce correct results, feeding them random comparisons creates non-uniform distributions: some orderings appear far more often than others. The Fisher-Yates algorithm avoids this entirely by working directly with index swaps, so there is no dependency on sort stability or comparison count. The Shuffle button in this tool uses Fisher-Yates powered by crypto.getRandomValues, meaning each of the n! orderings is chosen with equal weight.

A common off-by-one error — swapping with a position from 0 to n−1 (the full array) rather than 0 to i — looks minor but completely destroys uniformity. This is sometimes illustrated with a birthday-problem analogy: a small systematic bias in how you generate permutations compounds across millions of draws, eventually making some orderings vanishingly rare. Every card game engine, music playlist shuffle and random team generator that is properly implemented uses the Fisher-Yates algorithm for exactly this reason.

How computers generate random numbers: PRNGs, CSPRNGs and why it matters

A pseudorandom number generator (PRNG) is a deterministic algorithm that produces a sequence of numbers that appear statistically random but are entirely determined by an initial value called the seed. Give the same seed to the same PRNG and you always get the same sequence — which is useful for reproducible simulations but catastrophic for security. The Linear Congruential Generator (LCG) is one of the oldest PRNGs: it multiplies the current state by a constant, adds another constant, and takes a modulus. LCGs are fast and simple, but their period is short and their output shows clear patterns in multiple dimensions. Early versions of Java's Math.random() and many C standard library implementations used LCGs. The Mersenne Twister (MT19937), developed in 1997, dramatically improved on LCGs with a period of 2^19937−1 and excellent statistical properties; it remains the default PRNG in Python's random module and many scientific computing environments.

A cryptographically secure pseudorandom number generator (CSPRNG) adds a much stronger guarantee: even if an attacker observes a large portion of the output, they cannot predict past or future values. ChaCha20, a stream cipher developed by Daniel J. Bernstein, is one of the most widely deployed CSPRNGs today; browsers expose it through crypto.getRandomValues(), which seeds from the operating system's own entropy pool (hardware events, interrupt timing, and similar unpredictable sources). The critical distinction is that CSPRNGs are computationally infeasible to invert — knowing a million outputs tells an attacker nothing about the next one.

Math.random() should never be used for anything security-sensitive — including token generation, password salts, and shuffle operations in games with money at stake — because browser implementations have historically been seeded with weak entropy and the internal state can be reconstructed from as few as a few hundred observed outputs. This tool avoids Math.random() entirely, using crypto.getRandomValues() for every pick, shuffle and number draw. For a casual classroom spin or a giveaway with friends this distinction may feel academic, but for any draw where the stakes are real or the result needs to be auditable, the difference between a PRNG and a CSPRNG is the difference between fair and exploitable.

A brief history of random selection: lots, sortition and the draft lottery

Humans have been using random selection to make decisions and resolve disputes for thousands of years. Casting lots — distributing stones, sticks or marked objects and drawing one without looking — appears throughout the ancient world. The Old Testament records lots being used to divide the land of Canaan among the twelve tribes of Israel (Numbers 26:55) and to identify Jonah as the person responsible for the storm threatening his ship. Ancient Rome used lots to assign provincial governorships, minimizing (in theory) the patronage and corruption that direct appointment invited.

The most sophisticated ancient application was sortition: the Athenian democratic practice of choosing public officials by lot rather than by election. Citizens eligible for office placed tokens in a device called the kleroterion — a stone slab with rows of slots — and a randomizing mechanism drew names to fill civic roles. Roughly 6,000 citizens per year were selected this way to staff the courts, councils and administrative boards. Athenian thinkers, including Aristotle, argued that sortition was more genuinely democratic than elections, because elections systematically favor the wealthy and well-connected while the lot gives every citizen an equal chance. Modern advocates of citizens' assemblies have revived this argument.

The most analyzed modern random draw is the 1969 US Vietnam War draft lottery. Capsules containing birth dates were placed in a drum and drawn to determine the order in which young men would be called for military service. A statistical analysis published shortly afterwards found that December birthdays were dramatically overrepresented in the early draws — men born in December were called first far more often than chance would predict. The reason: the capsules had been added to the drum month by month, and insufficient mixing meant later-added months stayed near the top. The 1970 lottery used a second drum to randomize the order of months before drawing, producing a statistically uniform distribution. This episode is now a standard teaching example of how inadequate randomization — even in a high-stakes, well-intentioned process — produces measurably unfair results, and why algorithmic random selection with a verified generator matters.