wag.dk

FIELD NOTES
ENTRY No. 010
STARDATE 2026.264
Data & Code / Simulations — 2026-09-21

Best way to shuffle cards: 9 methods tested over 10,000 simulated trials

The Center Load Shuffle gives the best result per unit of effort — tested on a standard deck and a 60-card Skip-Bo deck.

The finding

The best way to shuffle cards — when you weigh effort against result — is the Center Load Shuffle. The move is straightforward: pull the middle third of the deck out as a packet and place it on top of the remaining two-thirds, then do a normal riffle. At seven shuffles it reaches 86.2% of a fully random deck on the standard 52-card deck. At ten shuffles it reaches 94.0%. That is the highest score of any single-action method at every round count tested.

If you are willing to spend two physical actions per round, Center Load + Strip Combo goes further still — 93.4% at seven rounds and 98.0% at ten rounds on a standard deck, and it tops the Skip-Bo rankings too.


Background

A new deck of cards comes ace-to-king, every suit in order — about as far from random as a deck can get. The classic result is the Bayer-Diaconis riffle shuffle theorem: seven riffle shuffles is the mathematical threshold where a deck goes from fully ordered to statistically indistinguishable from random. Fewer than seven and detectable order remains; more than seven barely helps.

That raised an obvious question: does how you riffle matter, beyond just the count? To find the best way to shuffle cards, I built nine shuffle variants in Python and ran each one 10,000 times against two decks — a standard 52-card deck, and a 60-card Skip-Bo deck (values 1–12, five copies each, since repeated values stress-test the randomness metric differently). Randomness was measured using rising sequences — counting runs of cards still in ascending original order, the same metric the original proof is built on. A fresh deck has 1 rising sequence; a truly random deck averages (n+1)/2.

The nine methods

Standard Riffle

The baseline. Deck split roughly in half (imperfect cut, not exactly 26/26), then interleaved with a randomised number of alternations (10–20) and variable-sized clumps from each side. This mirrors the actual Gilbert-Shannon-Reeds model behind the Bayer-Diaconis proof.

Heart Cut Shuffle

Pull the middle ~half of the deck out as one packet (a real cardistry move called a "heart cut"), join the leftover top and bottom into the other packet, then riffle the two together.

Center Load Shuffle

Pull the middle ~third out and place it on top of the remaining two-thirds, then do a standard riffle on the restacked deck. This is the best-performing single-action method in the test.

Carousel Shuffle

A multi-round rotating scheme: round 1 pulls a third aside and riffles the rest; each following round splits the current shuffled pile in half, sets one half aside (replacing the previous aside pile), and riffles the other half together with that previous aside pile.

Tilt Shuffle

A deliberately uneven split (roughly 2/3 vs 1/3, which side is bigger randomised) instead of a near-half cut, then a standard riffle.

Undercut Shuffle

Cut roughly a third off the bottom and move it to the top before each riffle.

Strip Shuffle

No interleaving at all. The deck is broken into 4–8 packets pulled off the top one at a time, each dropped on top of the last — which reverses packet order but leaves the cards within each packet untouched. Included as a baseline for "what happens if you never interleave."

Strip + Riffle Combo

One riffle followed by one strip shuffle, repeated per round. Note: each "round" is actually two physical shuffles, not one.

Center Load + Strip Combo

Same idea, but a Center Load Shuffle followed by a strip shuffle each round. Again, two physical shuffles per counted round.

Results — standard 52-card deck

Values are percentage of a truly random deck's rising-sequence count. 100% = fully random.

Method                    1      2      3      4      5      6      7      8      9     10
Center Load + Strip    38.1%  56.7%  70.4%  79.8%  86.1%  90.5%  93.4%  95.5%  96.9%  98.0%
Strip + Riffle Combo   35.5%  53.0%  67.0%  76.3%  83.2%  88.0%  91.4%  93.8%  95.5%  96.9%
Center Load Shuffle    28.2%  45.9%  59.2%  68.9%  76.1%  82.0%  86.2%  89.5%  92.0%  94.0%
Heart Cut Shuffle      25.2%  41.8%  54.8%  64.7%  72.6%  78.8%  83.5%  87.2%  90.0%  92.2%
Undercut Shuffle       26.1%  41.4%  53.6%  63.5%  71.0%  77.2%  82.0%  85.8%  88.9%  91.1%
Standard Riffle        24.1%  40.1%  52.9%  62.9%  70.7%  76.9%  81.8%  85.5%  88.5%  91.0%
Tilt Shuffle           23.6%  39.3%  51.7%  61.6%  69.6%  75.7%  80.6%  84.5%  87.7%  90.3%
Carousel Shuffle       24.7%  39.5%  51.4%  61.1%  68.8%  74.9%  80.0%  83.9%  86.9%  89.7%
Strip Shuffle          21.5%  24.4%  34.6%  38.4%  45.9%  49.4%  55.3%  58.7%  63.1%  65.8%
Shuffle randomness vs number of shuffles — standard 52-card deck

Results — Skip-Bo 60-card deck

Method                    1      2      3      4      5      6      7      8      9     10
Center Load + Strip    33.3%  50.3%  63.0%  71.8%  78.1%  82.6%  85.8%  87.9%  89.4%  90.7%
Strip + Riffle Combo   31.0%  47.1%  59.9%  68.7%  75.2%  79.9%  83.5%  86.1%  88.0%  89.5%
Center Load Shuffle    25.0%  41.1%  53.0%  62.1%  68.9%  74.5%  78.6%  81.9%  84.6%  86.5%
Heart Cut Shuffle      22.6%  37.4%  49.2%  58.2%  65.5%  71.2%  75.6%  79.2%  82.2%  84.4%
Undercut Shuffle       23.1%  37.3%  48.8%  57.7%  65.0%  70.8%  75.2%  79.0%  81.8%  84.0%
Standard Riffle        21.6%  36.2%  48.1%  57.3%  64.7%  70.3%  75.0%  78.6%  81.5%  84.0%
Tilt Shuffle           21.1%  35.5%  47.0%  56.2%  63.6%  69.3%  74.0%  77.8%  80.9%  83.3%
Carousel Shuffle       22.1%  35.7%  47.0%  56.1%  63.2%  69.1%  73.8%  77.7%  80.7%  83.2%
Strip Shuffle          18.3%  20.6%  29.4%  32.8%  39.4%  42.6%  47.7%  50.7%  54.7%  57.5%
Shuffle randomness vs number of shuffles — Skip-Bo 60-card deck

What it means

All the single-action riffle-based methods — Standard, Tilt, Undercut, Heart Cut, Carousel, Center Load — cluster within a few percentage points of each other on both decks. This confirms that how you cut the deck before riffling barely matters. What actually drives randomness is the messiness of the interleave itself: irregular clump sizes falling from each hand, not which packet ends up where.

Center Load Shuffle is the best single-action method. The restack takes one extra step before the riffle, and it consistently scores a few points higher than every other single-action method across every round count on both decks. At seven shuffles on a standard deck it sits at 86.2% — about four points ahead of a plain riffle. If you are sitting at a table and want to shuffle well without thinking about it, this is the move.

The combo methods — Center Load + Strip Combo and Strip + Riffle Combo — clearly outperform every single-action method, but that is partly explained by each "round" actually being two physical shuffles, not one. Center Load + Strip Combo reaches 98.0% of fully random on a standard deck by round 10 and tops the Skip-Bo rankings too. If you are willing to spend the time, it is the ceiling.

Strip Shuffle alone is the clear loser on both decks. It never interleaves cards, so it plateaus far below the others and tops out at only 65.8% after ten rounds on a standard deck. It is only useful as a supplement between riffles, not a replacement.

Reproducing this

All nine shuffle scripts are attached below, plus CompareShuffleResults.py, which scans a folder for the resulting *_shuffle_results.json files, prints the comparison tables above, and generates the charts shown in this post. Each script is self-contained — run it, then run the comparison script in the same folder.

The randomness metric used throughout is rising sequences: a count of how many consecutive card pairs are still in ascending original order. A fresh ordered deck scores 1; a fully random deck averages (n+1)/2. The percentage figures in the tables are each method's average rising-sequence count divided by that target.

Files

FileDescriptionSize
CarouselShuffle.py This script simulates a "carousel shuffle" technique that repeatedly divides a deck into halves and riffles them together while rotating a set-aside pile, measuring how many rounds are needed to randomize the deck by counting rising sequences. It tests the shuffle method on multiple deck types (Standard 52-card and Skibbo 60-card) and outputs statistical results to JSON files. 6.4 KB
CenterLoadShuffle.py This script simulates a "center load shuffle" mechanic—extracting the middle portion of a deck and placing it on top before performing an imperfect riffle—and measures how many randomization shuffles are needed to eliminate ordered card sequences. It runs trials across different deck types and outputs statistical results to JSON. 5.7 KB
CenterLoadStripComboShuffle.py This script simulates the "center load + strip" shuffling technique on physical card decks and measures how many shuffles it takes to randomize the deck by tracking rising sequences. It runs thousands of trials for different shuffle counts and outputs statistical results to JSON files, supporting multiple deck types like standard 52-card or Skibbo 60-card decks. 6.8 KB
CompareShuffleResults.py This script aggregates and visualizes shuffle randomness results across multiple JSON result files, comparing different shuffling methods by their effect on card deck randomness relative to a theoretical optimum. 4.5 KB
HeartCutShuffle.py This file simulates and analyzes the "heart cut shuffle," a card-shuffling technique that pulls the middle portion of a deck and riffles it with the remaining outer portions, measuring how many shuffles it takes to randomize the deck by counting rising sequences. It runs thousands of trials across multiple deck types to determine when rising sequences converge to random expectations. 5.7 KB
Standard-Shuffle.py This script simulates riffle shuffling with customizable hand alternations and measures how many shuffles are needed to randomize a deck by counting rising sequences. It tests multiple deck types and generates JSON results comparing actual mixing to a theoretical random baseline. 4.7 KB
stripRiffleShuffle.py Simulates combinations of strip shuffles and riffle shuffles on different deck types to measure randomness by counting rising sequences, comparing results against theoretical random averages. 5.6 KB
StripShuffle.py This script simulates the strip shuffle algorithm on different deck types and measures how many shuffles are needed to randomize cards by tracking rising sequences. It runs thousands of trials per shuffle count and outputs statistical results to JSON files for analysis. 3.8 KB
TiltShuffle.py Simulates a "tilt shuffle" (an uneven riffle shuffle) on different deck types and measures how many rising sequences remain after repeated shuffles to assess randomization quality. Results are saved to JSON with statistics comparing the shuffle's effectiveness against a theoretical random baseline. 5.3 KB
UndercutShuffle.py This file simulates the "undercut shuffle" (moving roughly the bottom third to the top, then doing an imperfect riffle) and measures how many shuffle repetitions are needed to randomize a deck by counting rising sequences in the card order. 5.4 KB

drafted by claude-haiku-4-5 + claude-sonnet-4-6 · 197.8k tokens · ≈$0.770 · corrected 5× · approved by a human