What is a list randomizer?
A list randomizer takes a list of items and shuffles them into random order. Same job as shuffling a deck of cards, except your "deck" can be anything — names, tasks, exam questions, the order presentations get given at a meeting, the songs in a playlist. You hand it an ordered list; it hands you back the same items in a random sequence.
This sounds simple, and the use case is simple, but the math underneath has been wrong in software more often than you'd expect. The naive way to shuffle a list — sorting it with a random comparison function — is biased. Some orderings come out more often than others. The List Randomizer uses the Fisher-Yates shuffle, which is provably unbiased, paired with crypto.getRandomValues() for the random numbers themselves. Every possible ordering is exactly equally likely.
That guarantee matters when the order has consequences. If you're using a shuffle to decide who presents first in a meeting, or which student answers the next question, or whose name goes at the top of the list, a biased shuffle puts certain people in those positions more often than others. Even small biases compound over hundreds of uses.
How to use the List Randomizer
Open the List Randomizer, paste your list, press shuffle.
- Paste your items into the input box, one per line
- Press shuffle
- Read the shuffled output — same items, new order
- Shuffle again for a different random order, or copy the result to use it
The list can be any length. Each item should be on its own line; the randomizer treats each line as one element. Empty lines and trailing whitespace are ignored. No login, no sign-up, no character limit you'll bump into during normal use.
A worked example
Say you have a 10-person team meeting and you want to randomize the order in which everyone gives their weekly update. Input list:
Alice
Ben
Carmen
David
Eshe
Farouk
Greta
Hiro
Inez
Jin
Press shuffle. Here's an actual output from the List Randomizer:
Output
Eshe
Hiro
Alice
Jin
Carmen
Greta
David
Inez
Ben
Farouk
That's the order. Eshe goes first, Farouk goes last. Run it again and you'll get a completely different order. The list has 10! = 3,628,800 possible orderings, and each one is exactly equally likely. The randomizer doesn't favor people whose names start with A, doesn't push the same person to the front twice in a row, doesn't have a "fair rotation" memory. It just shuffles, every time, from scratch.
The Fisher-Yates shuffle (why this matters)
Here's the wrong way to shuffle a list, and the one most people would write if they hadn't thought about it: take your list and sort it, using a random number (-1, 0, or +1) as the comparison function. JavaScript code that looks like list.sort(() => Math.random() - 0.5) shows up in tutorials all the time. It's wrong.
The reason it's wrong is subtle. Sort algorithms make assumptions about the comparison function — specifically, that if A < B and B < C, then A < C. A random comparator breaks that. The output is shuffled, but it's not uniformly random. Some orderings come out more often than others. For a list of 5 items, certain permutations are about 1.5x more likely than others. Run it enough times and the bias becomes obvious.
The Fisher-Yates shuffle is the correct algorithm. It works by walking the list from the end to the start; at each position, it swaps the current element with a random earlier element (including possibly itself). Done in O(n) time, produces a perfectly uniform distribution over all possible permutations, and has been proven correct since 1938.
The List Randomizer uses Fisher-Yates internally. The random numbers it consumes come from crypto.getRandomValues() — same cryptographically-secure source the browser uses for TLS keys. No seed, no pattern, no way to predict the next shuffle from the previous one.
What people use the List Randomizer for
The same shuffle covers a lot of distinct cases. Here are the common ones:
| Use case | Why a shuffle helps |
|---|---|
| Presentation order in a meeting | No one's stuck always going first (anxious) or always going last (rushed) |
| Picking from a queue fairly | Removes "I asked first" politics; everyone gets the same shot at any position |
| Randomizing exam questions per student | Reduces copying; harder to share answers when the question order varies |
| Naming convention for a tournament bracket | Random seed assignment instead of biased manual placement |
| Selecting test subjects for A/B groups | Shuffle a list of users, take the first half for group A, second half for group B |
| Shuffling a music playlist | If your music app's "shuffle" plays the same songs first every time, paste the tracklist here |
| Reading order for student book reports | No one always reads first (best slot) or last (worst slot) |
| Choosing an order for code review queues | Reviewers don't always see the same PRs first; reduces "reviewer fatigue" bias on later items |
| Decision-making for groups | "Whose turn is it to pick the restaurant?" — shuffle the names, work through the list in order over weeks |
| Sampling for content moderation | Random subset of submissions to spot-check rather than reviewing in arrival order |
The shuffle is the same operation every time. What changes is what you do with the output.
Random order vs. random selection: pick the right tool
Two related problems often get conflated, and they deserve different tools.
- Random ordering — you want all items, in a random sequence. Every item appears once. The List Randomizer is the right call. Example: deciding the speaking order for 10 panelists.
- Random selection — you want one (or a few) items from a larger list. Most items don't appear in the output. The Random Name Picker is the right call. Example: drawing a single winner from a list of 500 raffle entrants.
You can technically use the List Randomizer for selection — shuffle the list, take the first N items — and it'll give a fair result. But it's wasted effort if you only need one item. The Random Name Picker is built specifically for that case.
Similarly, if you want to split a list into balanced teams (not just shuffled order but actual groups), the Team Generator handles that. You don't have to do the math yourself.
How "random" is random enough?
For a 10-item list, there are 3,628,800 possible orderings. For 20 items, 2.4 quintillion. For 50 items, the number of orderings exceeds the number of atoms in the observable universe. The List Randomizer samples uniformly from that space, which means every ordering is equally likely — but you'll never see the same ordering twice in practice, because the space is unfathomably large.
This has a useful corollary: you don't need to re-shuffle "for a better random order." The first shuffle is already maximally random. Pressing shuffle 10 times in a row gives you 10 unrelated random orderings; it doesn't give you a "more random" final result. Random is binary — either the algorithm is uniform (this one is) or it isn't.
If a shuffle result looks "not random enough" to you — the same person ended up in the top 3 two shuffles in a row, or a clump of similar names landed at the end — that's the law of small numbers. Random outputs look "patterned" to humans much more often than humans expect. The shuffle is fine.
What about weighted shuffles?
Some shuffle problems want certain items to land near the top more often. If you're picking a song to play next from a playlist, you might want recently-played songs to be less likely than ones you haven't heard in a month.
The List Randomizer doesn't do weighted shuffles. It treats every input item as equally weighted, and there's no way to set a "weight" on individual lines. This is deliberate — one job per tool, and a flat shuffle is the most common case by a wide margin. For weighted random selection, the workaround is to add duplicate entries: if you want item X to be twice as likely as item Y to land near the top, put X in the list twice. After shuffling, take the first instance of each unique item as your final order.
Related randomness tools
The List Randomizer handles "I have a list, shuffle it." For other random-decision needs:
- Random Name Picker — pick one or a few items from a larger list. The "draw a winner" case.
- Team Generator — split a list of people into random balanced teams. Useful for sports, study groups, or class projects.
- Coin Flip — binary 50/50 random choice when there's no list, just a yes/no.
- Dice Roller — random number in a known range. For board games, tabletop RPGs, or any "pick a number from 1 to N" need.
- Random Name Generator — generate new names rather than picking from an existing list.
- Random Word Generator — random words for creative writing, party games, or warm-up exercises.
Frequently asked questions
Is the List Randomizer really fair?
Yes. The shuffle uses the Fisher-Yates algorithm, which produces a uniform distribution over all possible orderings (every permutation is exactly equally likely). The random numbers come from crypto.getRandomValues(), the browser's cryptographically-secure RNG. No item is favored, no position is favored, no input is favored. Run a million shuffles on the same list and the position frequency for each item will converge to exactly 1/N for every slot.
Can I shuffle a really long list?
Yes. The Fisher-Yates shuffle is O(n) — it scales linearly with the list length. Lists with 10,000+ items shuffle in milliseconds. The List Randomizer doesn't impose an arbitrary limit; the practical limit is your browser's memory and how long you're willing to wait to paste the input.
Why does the same item sometimes end up first two shuffles in a row?
Because shuffles are independent. The probability of any specific item landing first in a 10-item list is 1/10. After it lands first once, the probability it lands first again on the next shuffle is still 1/10. Two-in-a-row events happen about 10% of the time on any individual item — not glitches, just probability.
Can I shuffle just part of a list?
The List Randomizer shuffles the entire input. If you want to fix the position of certain items and shuffle the rest, the workaround is to remove the fixed items, shuffle what's left, then re-insert the fixed items at the positions you want. Building partial-shuffle into the tool would add UI complexity for a use case that affects a small fraction of users.
Does the shuffle work offline?
Yes, once the page is loaded. The shuffle runs entirely in your browser; no network call, no server, nothing leaves your device. Your list is yours. Useful if you're randomizing something sensitive (e.g. a list of employees, a beta tester roster, or an exam answer key) — paste it into a tool that won't send it anywhere.
What's the difference between shuffling and sorting randomly?
Sorting "randomly" (e.g. list.sort(() => Math.random() - 0.5)) produces a biased result because sort algorithms assume their comparison function is consistent. Some orderings come out more often than others. Fisher-Yates shuffling produces a uniform random ordering. The output may look similar at a glance, but the underlying distribution is different — and at scale, the bias of the wrong method is provable and significant.
Can I save the shuffled output?
The List Randomizer doesn't save anything server-side (your list never leaves the browser), but you can copy the output and paste it wherever you want — a spreadsheet, a doc, an email. There's a copy button next to the output for one-click capture. If you want a permanent record of the shuffle order, copy the result immediately; the next shuffle will replace it on screen.
Is there a way to get a different shuffle every time, even with the same list?
That's the default. Every time you press shuffle, a fresh random ordering is generated. There's no seed exposed, and there's no way to reproduce a previous shuffle — which is the right tradeoff for an unbiased random tool. If you want reproducible shuffles (e.g. for testing), you'd need a tool with explicit seed input; the List Randomizer is built for fairness, not reproducibility.