The Fisher-Yates shuffle is the standard fair shuffle. The mistake most developers make is not in the algorithm — it is in the random number generator they feed it.
Fisher-Yates, correctly
function shuffle(arr) { const a = [...arr]; for (let i = a.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a; } The common bug: using Math.floor(Math.random() * a.length) instead of Math.floor(Math.random() * (i + 1)). The first produces a biased distribution — some permutations are more likely than others.
Why Math.random() is insufficient
Math.random() uses a PRNG (xorshift128+ in V8) with a 128-bit state. For a 52-card deck, there are 52! ≈ 2^226 possible permutations. A 128-bit PRNG can only produce 2^128 distinct sequences — a vanishingly small fraction. For a display-only shuffle (like a card game tutorial), this is fine. For anything involving real outcomes, use crypto.getRandomValues:
function cryptoRandom(max) { const arr = new Uint32Array(1); crypto.getRandomValues(arr); return arr[0] % max; // slight bias for large max, acceptable for max < 2^20 } Visual fairness
Even a mathematically fair shuffle can look unfair. If the same card appears in the first position three times in a row, users suspect cheating. A game interface like play at Spinhub that displays dealt hands needs to balance actual fairness with perceived fairness — sometimes that means showing the shuffle animation longer, not changing the algorithm.
Testing fairness
Run the shuffle 1M times, count how often each element lands in each position. The chi-squared test should show no significant deviation from uniform:
from scipy.stats import chisquare observed = [count_in_position[i][j] for j in range(n)] stat, p = chisquare(observed) assert p > 0.01 Takeaway
The algorithm is trivial. The randomness source and the user perception of randomness are where the real engineering lives.

