Per-Card Encryption for Multiplayer Poker on a Shared Sync Layer
A multiplayer poker game built on Multisynq/Croquet where each card is individually encrypted so shared game state never leaks a player's private hand.
Multiplayer poker has a problem that most networked games do not: the shared state is supposed to be partly secret. Every player needs a consistent view of the table, the pot, whose turn it is, but no player is allowed to see another player's hole cards. This project is a secure poker game built on Multisynq/Croquet that solves that with per-card encryption.
Why a Synchronized State Model Fights You Here
Croquet, and Multisynq built on it, gives every client a deterministic, perfectly synchronized copy of the shared model. That property is wonderful for most multiplayer games and awkward for poker. If the cards live in the shared model in the clear, then by construction every client has them, and "every client has the state" is exactly what you do not want for a hidden hand. The synchronization guarantee that makes the game consistent is the same guarantee that would leak the cards.
The resolution is per-card encryption. Rather than trying to keep some state out of the synchronized model, which fights the whole architecture, the cards go into the shared model encrypted. Everyone holds the same synchronized bytes, and consistency is preserved, but only the player who should be able to read a given card holds what is needed to decrypt it. Secrecy becomes a property of who can decrypt, not of who has the data.
Encrypting at the Card Level
Doing this at the granularity of individual cards, rather than encrypting a whole hand or the whole game blob, is the right unit for the game's rules. Poker reveals information incrementally: hole cards stay private, community cards flip face-up on the flop, turn, and river, and hands get shown at a showdown. Per-card encryption matches that structure. A card can be dealt encrypted and later revealed by disclosing what unlocks that specific card, without touching anything else in the synchronized state.
The Takeaway
The design lesson worth keeping is to encrypt the secret and share the ciphertext, rather than trying to withhold state from a system whose entire job is to replicate state everywhere. Building on Multisynq/Croquet means fighting the sync model is a losing move, so the winning move is to let it replicate freely and put the secrecy in the encryption layer instead. The README for this one did not come through in a readable form, so I am keeping the write-up to what the design plainly is: a synchronized-state poker game where per-card encryption is what makes a shared model safe for a hidden-information game.
Have something that needs building, or stabilizing?
These notes are the work log. The paid work runs through Moonshine Labs, my product and engineering studio. Tell us what you're building, or grab a call.
Work with us →