Free Random Name Picker with Wheel

Random Name Pickers — Spin Wheels, Fair Draws, and Why Verifiability Matters

"Pick a random name from a list" is the kind of task that sounds trivially simple — and the underlying maths really is — but the moment you start doing it for something that matters (a public giveaway, a classroom selection that affects student grades, an audited prize draw), the gap between "it picks a name" and "people trust the pick" gets very wide very quickly. This guide walks through how the LazyTools random name picker works under the hood, why the spin wheel animation is purely cosmetic, what makes a draw verifiably fair, and how to use the picker for the most common real-world tasks. If you've ever needed to convince a sceptical participant that your raffle wasn't rigged, the second half of this article is for you.

How the random name picker works

The mechanism is simpler than it looks. You paste a list of names. The picker counts them. When you click Spin or Pick, the underlying algorithm generates a random number between 0 and (list length minus 1) using your browser's Math.random function — or a deterministic Mulberry32 algorithm if you have entered a seed value. That number is the index of the winner. In Spin Wheel mode, the picker then calculates how many degrees the wheel needs to rotate so that the winner's segment lands under the pointer, applies a long CSS transform animation, and reveals the result when the spin completes. In Instant Pick mode, the wheel step is skipped and the winner is shown immediately. Either way, the winner is decided before the wheel moves — the spinning is purely visual.

This matters for two reasons. First, it means the wheel cannot be biased by spinning harder, longer, or with a different starting position. The result is locked in the moment you click. Second, it means the random pick is as fair as the random algorithm itself, and Math.random is more than fair enough for any non-cryptographic use. (For cryptographic randomness — security tokens, key generation — you would need a hardware random source. For picking a raffle winner, the browser's PRNG is fine.)

Why "the wheel is just for show" is good news

People sometimes object that knowing the wheel is cosmetic feels like a cheat. It's actually the opposite — it's the only way to make the draw verifiably fair. If the wheel were a true physical simulation (where the strength of the spin determined the result), then anyone watching could not tell whether you tweaked the spin force to land on a friend's name. By computing the winner first and then animating the wheel to land on it, the result is deterministic given the random number generator's output. And if you use a published seed, the random number generator's output is itself reproducible — so anyone can verify the result independently. The cosmetic wheel is what makes audited fairness possible. Pure entertainment-style wheel widgets that simulate physics cannot offer this.

Multi-winner draws — the maths behind drawing without replacement

When you set "Winners per draw" to more than 1, the picker uses what statisticians call sampling without replacement — once a name is picked, it cannot be picked again in the same draw. This is mathematically equivalent to picking the first winner, removing them from the list, picking the second from what remains, removing them, and so on, but the picker does it in one operation using the Fisher-Yates shuffle algorithm under the hood. The result is that every winner has been chosen with equal probability from the original list and no name appears twice. This is the right behaviour for prize tiers (1st, 2nd, 3rd cannot be the same person), team selection, secret santa pairings, and any draw where each winner is a distinct person.

If you want sampling with replacement instead — where the same name could in theory be picked twice — turn off "Remove winner after pick" and run the spin multiple times. This is rarely what you want for name picks, but it's the right setting for things like "pick the random catchphrase to start each meeting" where the same option being picked twice in a row is fine.

Seeded random — the secret to audited fairness

Here's the part that competitors don't have. A seeded random number generator is a deterministic algorithm that produces the same sequence of "random" numbers every time it's given the same starting seed. The LazyTools picker uses the Mulberry32 PRNG, which produces statistically high-quality random sequences from a 32-bit seed. When you tick the seed box and enter a value, the picker hashes your seed string into a 32-bit integer using the FNV-1a algorithm and uses that as the starting state for Mulberry32. The same seed always produces the same winner.

The reason this is the gold standard for audited fairness: you can publish the seed before the draw. Imagine you're running a giveaway. You announce the entry deadline, and at the same time you announce the seed you'll use ("the closing price of Brent crude on draw day, rounded to the nearest dollar," for example). Participants can verify that the seed could not have been chosen after seeing the entry list, because it was committed to before. After the draw, anyone can re-run it with the same seed and the same list and verify the winner independently. This is mathematically as good as a third-party adjudicator and costs nothing. Published-seed audited draws are how cryptocurrencies, blockchain raffles and academic Monte Carlo studies all establish trust — and the LazyTools picker brings the same technique to a free name picker.

Random name picker for the classroom

Teachers are one of the biggest user groups for name pickers, and the workflow is slightly different from a one-off raffle. The recurring pattern is: paste the class roster once at the start of term, use the picker for student selection during lessons, and let it remember the list across sessions. The LazyTools picker handles this with auto-save to local storage — the moment you stop typing in the textarea, your list is saved to your browser. Next time you open the page, the list is back. No accounts, no logins, no cloud storage.

For classroom cold-calls — where you want to randomly pick a student to answer a question — Instant Pick mode is the right choice because it skips the animation delay. Combine it with remove-winner-after-pick so the same student isn't called twice in one lesson, and you get a fair distribution of attention across the class. At the end of the lesson, click the hub to reset the list to the original roster. The picker also works on classroom interactive whiteboards and projectors because the wheel is built from pure SVG — it scales to any screen size and looks crisp at every resolution. There are no canvas elements, no WebGL, and no heavy graphics libraries to slow things down on older school hardware.

Random name picker for Instagram and TikTok giveaways

Social media giveaways are the second biggest use case. The pattern there is: collect comments under your giveaway post, export them to a list, paste them into the picker, draw a winner, and prove to your audience the draw was fair. Three things make this draw trustworthy: screen-record the spin (so followers can see the actual draw, not just the result), use seed mode and publish the seed (so anyone can re-run the draw and verify), and share the entry list URL before the draw (so followers can confirm their name is in the list). The LazyTools picker is the only free tool that supports all three.

For legally regulated giveaways — promotions over your country's certified-randomness threshold (varies by jurisdiction; in the UK it's typically the threshold for "complex prize draws," in the US it varies by state, in Australia it's the threshold for permit-required trade promotions) — you should still use a certified RNG service or third-party adjudicator. The LazyTools picker is suitable for informal social media giveaways, charity raffles, office sweepstakes, and any draw where "fair and transparently verifiable" is enough. It's not certified for regulated gambling.

Random name picker for raffles and prize draws

Office sweepstakes, charity raffles, conference giveaways, fundraising events — the pattern is the same. List your entries (one per ticket, so people who bought multiple tickets appear multiple times to give them proportional probability), set "Winners per draw" to the number of prize tiers, turn on remove-after-pick, and spin once. All winners are drawn in a single fair operation. The history strip at the bottom of the tool keeps the recent winners visible while you announce them. For added trust at a public event, project the picker onto a screen and run it live — the SVG wheel scales to any size.

Team picker / random group generator

"Pick two captains" or "split this group of 24 into 4 teams of 6" is the third major use case. For two captains, set winners to 2 and click once — done. For team splits, the workflow is slightly more involved: pick the captains first, then for each remaining round pick 1 person at a time with remove-after-pick on, alternating which captain gets the pick. The LazyTools picker handles each individual draw fairly; the team-balancing logic is up to you. Future versions of the picker may add a dedicated "split into N groups" mode — let us know if you'd find that useful.

Secret santa pairings

The simplest way to run secret santa with this picker: list everyone in the group, pick winners equal to the group size with remove-after-pick on, and treat the order of draws as the gift-giving chain. Person 1 gives to person 2, person 2 gives to person 3, and the last person gives to person 1. This guarantees no one draws themselves, which is the constraint that makes secret santa generators harder than they look. For more complex constraints (like "couples should not draw each other"), you'll need to re-spin if the draw violates the constraint, or use a dedicated secret santa generator. For the basic version, the LazyTools picker is enough.

What "fair" actually means in a random pick

People often ask "is your picker really fair?" and the honest answer is: it depends what you mean by fair. There are three different fairness definitions that get mixed up:

• Statistical fairness: every name has the same probability of being picked. The LazyTools picker satisfies this by default — Math.random is statistically uniform, and the index calculation gives every list position equal probability.
• Verifiable fairness: participants can independently confirm the result was not tampered with. This requires seeded mode plus a published seed, which the LazyTools picker supports and most competitors don't.
• Certified fairness: an external authority has audited the algorithm and certified it for regulated use. This requires a paid certified RNG service and a third-party adjudicator. The LazyTools picker is not certified — for that level of fairness, use a regulated provider.

Most real-world use cases need statistical fairness (always) plus verifiable fairness (for public draws). Certified fairness is only required for legally regulated gambling and high-value prize promotions. The LazyTools picker covers the first two for free.

Pair this with the Random Generator Suite

If your task is "pick a random number, dice roll, coin flip, date or username" rather than "pick a winner from a list of names," the right tool is the LazyTools Random Generator Suite. It uses the same seeded-random infrastructure as this picker, so all of the audited-fairness arguments above apply equally to it. Six random tools in one page — random numbers, dice, coin, dates, fake phone numbers and usernames.

Frequently asked questions