Create a randomized list

Create a randomized list with four shuffle methods: full Fisher-Yates random (every permutation equally likely), reverse consecutive pairs, interleave two halves, or shuffle within 3-item blocks. Same op as Shuffle a list - different URL framing for the same tool. Uses `Math.random` - fine for raffles or test data, not cryptographically secure.

Input
Ready
Output
Live

Four randomization methods

Random (default) is a full Fisher-Yates shuffle using `Math.random`. Every permutation of the list is reachable with equal probability. Each run produces a fresh order - no seed input.

Reverse pairs swaps positions (1↔2), (3↔4), (5↔6), and so on - deterministic. Interleave halves splits the list at its midpoint and zips the halves together (`[a1, b1, a2, b2, ...]`). Block shuffle (groups of 3) Fisher-Yates shuffles within each consecutive three-item window - local chaos, rough overall order preservation.

Same op as Shuffle a list. Two URLs, same engine. Pick this framing when the intent is "generate a random order"; pick the other when it is "shuffle an existing list".

How to use create a randomized list

  1. 1Paste your list into the input panel
  2. 2Pick Method: Random (default, Fisher-Yates), Reverse pairs, Interleave halves, or Block shuffle
  3. 3Output is the randomized list; Random and Block change every run
  4. 4Copy or download the result
  5. 5For picking one random item instead of shuffling, use Pick random item

Keyboard shortcuts

Drive ListShift without touching the mouse.

Shortcut Action
Ctrl ZUndo last input change
Ctrl Shift ZRedo
Ctrl Shift EnterToggle fullscreen focus on the editor
EscExit fullscreen
Ctrl KOpen the command palette to jump to any tool
Ctrl SSave current pipeline draft Plus
Ctrl PRun a saved pipeline Plus

What this tool actually does

Four method modes, each with a distinct algorithm.

Random mode: full Fisher-Yates

Uniform random permutation via `Math.random`. Every order equally likely. Not cryptographically secure - fine for raffles, playlists, test data; not for anything where prediction resistance matters.

Reverse pairs: deterministic swap

Swaps items (1↔2), (3↔4), (5↔6). Odd-length tail stays put. Same input always gives the same output - good for predictable light rearrangement.

Interleave halves: zip two halves

Splits at the midpoint and zips the halves together. `[A B C D E F]` becomes `[A D B E C F]`. Useful for mixing an ordered list without full randomization.

Block shuffle: local scrambling

Divides into 3-item windows and Fisher-Yates shuffles within each. The list stays roughly in original order; adjacent neighborhoods get mixed up.

No seed input

`Math.random` is non-reproducible. Each click of Random / Block gives a different order. For reproducible shuffles, take one run's output and work with it.

Worked example

Random method (default). Output varies on every click - one possible result shown.

Input
Apple
Banana
Cherry
Date
Output
Cherry
Banana
Apple
Date

Settings reference

How each method shapes the output (using `A B C D E F` for illustration where the 4-item sample is too small to show the pattern).

Setting What it does Effect on the sample
Method: Random (default) Full Fisher-Yates shuffle Different order every run - non-deterministic
Method: Reverse pairs Swap (1↔2), (3↔4), (5↔6) `Apple, Banana, Cherry, Date` → `Banana, Apple, Date, Cherry`
Method: Interleave halves Split at midpoint, zip halves together `Apple, Banana, Cherry, Date` → `Apple, Cherry, Banana, Date`
Method: Block shuffle (3) Fisher-Yates within each 3-item window First 3 scrambled, last 1 stays - no cross-window movement

FAQ

How is this different from Shuffle a list?
Identical - same op, same methods, same defaults. Shuffle a list and this page point at the same engine; two URLs for two search intents ("shuffle an existing list" vs "create a randomized order").
Is the randomization cryptographically secure?
No. `Math.random` is suitable for entertainment and general-purpose use but not for raffles with legal or monetary stakes. Use `crypto.getRandomValues` directly for security-critical shuffles.
Why does the order change every click?
Random and Block modes call `Math.random` on every run - there is no seed input, so each pass gives a different permutation. Reverse pairs and Interleave are deterministic and always produce the same output for the same input.
What happens with an odd-length list in Reverse pairs?
The last item stays put. `[A B C]` → `[B A C]`. Only complete pairs from the start are swapped.
How do I pick one random item instead of the whole list?
Use Pick random item - pick 1 or more items, with or without repeats.