Shuffle a list.
Share one URL.
Drop any list, hit shuffle, get a uniformly random order. Group-aware blocks for keeping rounds together, optional auto-renumbering, copy as text or CSV.
Items (one per line, blank line = group break)
Settings
About this generator
The list randomizer is the boring sibling of the wheel and the picker. It does one thing: takes a list, returns it in a uniformly random order. Most people who land here are not looking to be entertained — they have a list of names and a meeting starting in three minutes, and they need a fair turn order before everyone joins.
The thing other shuffle tools quietly get wrong: they sort by random. Which sounds clever — call list.sort(() => Math.random() - 0.5) and call it a day — but is provably biased. The comparator is non-transitive, so the resulting distribution is not uniform: in V8 with timsort, certain orderings come up dramatically more often than others. Fine for shuffling jokes. Bad for assigning who has to do the standup demo.
This page uses Fisher-Yates with crypto.getRandomValues and rejection sampling on each index draw, which is the textbook correct way. Every one of the N! possible orderings is exactly equiprobable, the work is O(N), and there is no comparator weirdness. You can verify the math, or just trust that it produces shuffles you would not be able to predict if you tried.
Two features the boring sibling does well: preserve groups (blank lines split the input into blocks; each block is shuffled internally but blocks stay in order) and re-number (strips numeric/letter prefixes like 1. or A) from your input, then re-applies clean sequential markers in the new order). Both are toggleable, both live in the URL, both are off by default. The output is copy-able as plain text or CSV with quoting, and a shareable URL recreates the input — not the shuffled output, because there is no point in preserving randomness across page loads. Hit shuffle again, get a different one. That is the whole job.
What people actually use it for
Mostly mundane fairness, mostly fast.
Presentation order
Five people, one demo day, no one wants to go first. Drop the names, shuffle, ship the URL to the calendar invite. Disagreements go away when no one chose.
Song playlists
Spotify shuffle is famously not random — it is "interesting." When you want truly random, paste your tracklist here, shuffle, paste back into the playlist editor.
Raffle order
Raffle winners use the wheel; raffle order (which prize gets drawn for first, second, third) belongs here. Shuffle the prize list, work down the order.
Classroom turn order
Roster of 28 students, group-shuffle them by row to keep close-friends apart, copy as numbered text into the lesson plan. Faster than calling on people one by one.
A/B test draw order
Researchers shuffle stimulus lists per participant to control for order effects. Shareable URL means you can keep one canonical "today's draw" if you need a reproducible audit log.
Tournament brackets
Group mode shines here — keep round 1, round 2, round 3 separate but randomize matchups within each round. Copy as CSV, paste into a bracket sheet, done.
How it works
Fisher-Yates, explained
The Fisher-Yates shuffle (sometimes called the Knuth shuffle) is the textbook algorithm for producing a uniformly random permutation of a list. The trick is deceptively simple: starting from the end of the array, swap each element with a random earlier element (or itself).
// Modern Fisher-Yates, in-place for (i = a.length - 1; i > 0; i--) { j = randInt(i + 1); // uniform 0..i inclusive [a[i], a[j]] = [a[j], a[i]]; }
The proof of uniformity is one paragraph: at each step, every remaining element has an equal chance of being placed at position i. By induction, every one of the N! permutations is produced with probability 1/N!. No comparator, no sort, no bias.
Why not sort by random?
Tempting one-liner: arr.sort(() => Math.random() - 0.5). It looks like it works. It does not. Array.prototype.sort is a comparator-based sort and assumes the comparator is consistent (transitive, stable). A random comparator is neither, and the resulting distribution is heavily biased — for an array of length N, some orderings come up many times more often than others. Try it on [1,2,3] with 100,000 trials; you will see it.
The randomness
Each index draw uses crypto.getRandomValues to pull a 32-bit unsigned integer, then rejection sampling to map it into the range 0..i without modulo bias. We compute the largest multiple of i+1 below 2³², discard any draw at or above that limit, and re-roll. The expected number of re-rolls is well under 1 even for awkward sizes.
Group-aware mode & renumbering
With preserve groups on, we split the input on blank lines, run Fisher-Yates inside each group, then concatenate. With renumber on, we strip leading patterns like 1., 02 -, A), iii. from the input lines, shuffle, then prefix each output line with a fresh N. in the new order.
State & sharing
Input items and toggle settings live in the URL query string (?items=…&groups=1&renum=1) and mirror to localStorage. The URL preserves your input, not the last shuffled output — re-loading a URL gives a fresh shuffle, which is almost always what you want. The last 10 results are kept locally for reference.
Common questions
Is the shuffle truly random?
Yes. We use Fisher-Yates with crypto.getRandomValues and rejection sampling. Every one of the N! possible orderings is exactly equiprobable, with no modulo bias from naive index sampling.
What does preserve groups do?
Separate sections of your list with a blank line. Toggle preserve groups on and the shuffle happens inside each block separately — block one stays before block two, but the order within each is randomized. Useful for keeping rounds, days, or rounds-within-tournaments together.
What does re-number do?
If your input lines start with a number or letter (1., A), 02 -, etc.), re-number strips them before shuffling and re-applies clean sequential markers in the new order. Off, the original prefix moves with the line — which is usually what you want for names, but not for ordered task lists.
Why Fisher-Yates and not sort by random?
Sorting by Math.random looks clever but biases the result — the comparator is non-transitive, so some orderings come up more often than others. Fisher-Yates is provably uniform: each element ends in each position with exact probability 1/N.
What is the maximum list size?
Practically there is no cap. The randomizer handles tens of thousands of lines instantly. URLs over a few thousand items get long, so for huge lists keep them in the textarea and avoid sharing the URL.
Can I copy the shuffled list as CSV?
Yes. The toolbar has Copy text (newline-separated) and Copy CSV (comma-separated, quoted where needed). The shuffled order is what gets copied, not the original input.
Can I embed this on my site?
Yes. Copy the iframe embed in the section above. Pre-fill the input by setting the items query parameter on the embed URL — handy for classroom turn order, raffle order, or A/B test draw order pages.
Related generators
Same neighborhood — different question.