About

A standard deck contains 52 cards across 4 suits, yielding 52! possible shuffle permutations - a number exceeding 8 × 10⁶⁷. Most software card generators rely on Math.random(), a pseudo-random number generator with a period too short for cryptographic or statistical sampling work. This tool uses the crypto.getRandomValues() API, sourcing entropy from the operating system's CSPRNG. The Fisher-Yates shuffle algorithm ensures uniform distribution: every permutation has exactly equal probability 152!. If you need unbiased card draws for probability experiments, game prototyping, or dispute resolution, weak randomness introduces measurable bias.

The tool supports drawing with or without replacement, Joker inclusion, multi-card draws up to the full deck, and maintains a scrollable history log. Note: "without replacement" mode simulates a physical deck - once all cards are drawn, the deck must be reshuffled. Pro Tip: for Monte Carlo simulations of poker hands, use "Draw 5" in without-replacement mode and track results in the history panel.

Formulas

The Fisher-Yates (Knuth) shuffle operates in O(n) time, iterating from the last element to the first and swapping each with a uniformly random predecessor:

for i = n − 1 down to 1 :
j ← random(0, i)
swap deck[i] ↔ deck[j]

where j is generated via crypto.getRandomValues() with rejection sampling to eliminate modulo bias. The probability of drawing any specific card from a full deck:

P(card) = 1n

where n = number of remaining cards in the deck. For without-replacement draws, after drawing k cards, the probability of a specific remaining card becomes:

P(card_k+1) = 1n − k

The total number of ways to draw k cards from n is given by the binomial coefficient:

n!k! ⋅ (n − k)!

where n = 52 (or 54 with Jokers), and k = number of cards drawn.

Reference Data

Rank	Symbol	Blackjack Value	Poker Hierarchy	Count per Deck
Ace	A	1 or 11	14 (high) / 1 (low)	4
Two	2	2	2	4
Three	3	3	3	4
Four	4	4	4	4
Five	5	5	5	4
Six	6	6	6	4
Seven	7	7	7	4
Eight	8	8	8	4
Nine	9	9	9	4
Ten	10	10	10	4
Jack	J	10	11	4
Queen	Q	10	12	4
King	K	10	13	4
Joker	★	N/A (wild)	N/A (wild)	2 (optional)
Suit Reference
Suit	Symbol	Color	Unicode	Cards per Suit
Spades	♠	Black	U+2660	13
Hearts	♥	Red	U+2665	13
Diamonds	♦	Red	U+2666	13
Clubs	♣	Black	U+2663	13
Probability Reference
Event (5-card draw)	Combinations	Probability	Odds Against	Expected per 1000 Hands
Royal Flush	4	0.000154%	649,739 : 1	0.0015
Straight Flush	36	0.00139%	72,192 : 1	0.014
Four of a Kind	624	0.0240%	4,164 : 1	0.24
Full House	3,744	0.1441%	693 : 1	1.44
Flush	5,108	0.1965%	508 : 1	1.97
Straight	10,200	0.3925%	254 : 1	3.93
Three of a Kind	54,912	2.1128%	46.3 : 1	21.13
Two Pair	123,552	4.7539%	20.0 : 1	47.54
One Pair	1,098,240	42.2569%	1.37 : 1	422.57
High Card	1,302,540	50.1177%	0.995 : 1	501.18

Frequently Asked Questions

The generator uses crypto.getRandomValues(), which sources entropy from the operating system's cryptographically secure pseudorandom number generator (CSPRNG). Math.random() uses algorithms like xorshift128+ with predictable seeds and a limited state space. Additionally, this tool applies rejection sampling when mapping random bytes to indices, eliminating modulo bias that occurs when the range doesn't evenly divide 2^32.

Without replacement simulates a physical deck: each drawn card is removed, reducing the pool. Drawing all 52 cards produces a complete permutation. The probability of drawing any specific card increases as the deck shrinks (from 1/52 to 1/1). With replacement resets the deck after each draw, meaning duplicates are possible and each draw is independent with constant probability 1/52. Use without-replacement for realistic game simulation; use with-replacement for independent probability experiments.

Yes. Set the draw count to 5, enable without-replacement mode, and use the history log to track outcomes. The CSPRNG-backed shuffle produces statistically valid samples. For large-scale simulations (10,000+ hands), note that this tool runs in the main thread - each draw is instantaneous but manual. For automated batch simulation, export the algorithm from the source.

A standard deck contains 52 ranked cards (13 ranks × 4 suits). Most physical decks include 2 Jokers (often one red, one black) used as wild cards in games like Canasta, Euchre, and some Poker variants. Enabling Jokers adds these 2 cards, totaling 54. The probability of drawing a Joker from a full 54-card deck is 2/54 ≈ 3.70%.

The algorithm iterates from index n−1 down to 1. At each step i, it selects a random index j from [0, i] and swaps elements at positions i and j. This produces exactly n! possible execution paths, each corresponding to a unique permutation. Since the random selection at each step is uniform and independent, all n! permutations have equal probability 1/n!. For a 52-card deck, this means each of the 8.07 × 10^67 possible orderings is equally probable.

The tool enforces a hard cap: the draw count input is clamped to the number of remaining cards. If 3 cards remain and you request 5, only 3 are drawn. A toast notification informs you the deck is exhausted. Use the "Reshuffle" button to reset the deck to its full size (52 or 54) with a fresh random ordering.