Piss Poker

Chips on your phone. Cards on the table. A realtime chip tracker for live home poker: deal real cards, and everyone bets, raises and scoops pots from their own phone.

poker home-game chip-tracker texas-holdem realtime websockets durable-objects cloudflare-pages react pwa

Play it: piss-poker.pages.dev

---

Why this exists

Somebody always forgets the chips. Somebody else "borrows" a stack. Side pots turn into a group negotiation. So the cards stay physical (shuffling is half the fun) and the chips moved into everyone's pocket.

Before writing a line, we read the code of 22 open source chip trackers and put 9 betting engines through scripted side pot and all-in scenarios. Every tracker had real rule bugs (short all-ins reopening betting, the big blind posted twice when the table shrinks, kicks deleting chips, clients trusted to say who they are), and none of the engines passed every scenario. So this one was built from scratch around a small, heavily tested rules engine and a server that owns the truth.

What it does

• One phone per player, zero accounts. Start a table, share a four-letter code, QR code or link. Names are the only sign up.
• Real no-limit hold'em rules. Blinds post themselves, turn order is enforced, and the big blind keeps its option. Minimum raises follow the last full raise, and short all-ins only reopen betting when they add up to a full raise (TDA rule 47).
• Side pots without arguments. Pots are built in layers from what each player put in, uncalled chips go back automatically, and folded chips stay in as dead money.
• Chops take one tap per winner. Same hand as somebody else? Tap both names. Every pot lists its players with a checkbox, each share appears the moment you pick, and the odd chip goes clockwise from the dealer with a line saying so.
• Your turn is impossible to miss. The action bar floods yellow, a soft two-note chime plays, and Android phones buzz. The screen stays awake while a table is open.
• Deal prompts for the dealer. "Deal the flop", "Run out the board", "Who won?". The app tells the table what the cards should be doing.
• Built for real tables. Anyone can undo, seats can be added for players without a phone, and anyone can act for someone who is away. A phone can hand its seat to a new device (with the table's approval), and dropped connections reconnect by themselves.
• Settle up. Buy-ins, rebuys and net results, plus the fewest payments needed to square up in chips or cash.
• Table display mode. Prop an iPad or laptop in the middle for a big-type view of the pot, whose turn it is and every stack, with a QR code to join.
• Phone first, fine everywhere. Thumb-zone controls on phones, a two-column layout with keyboard shortcuts (F fold, C check or call, R raise, arrows to size, Enter to confirm, N next hand) on iPad and desktop. Light and dark follow the device setting.

Architecture

 phones, iPads, laptops                    Cloudflare
┌──────────────────────┐   HTTPS   ┌─────────────────────────────────────────────┐
│ React 19 SPA (Vite)  │──────────▶│ Pages: static app + /api/* Pages Function    │
│  shared/engine.ts    │           │                 │ service binding            │
│  (legal moves, UI)   │   WSS     │                 ▼                            │
│                      │◀─────────▶│ Worker "piss-poker-api"                      │
└──────────────────────┘           │  POST /api/rooms         create a table      │
                                   │  GET  /api/rooms/:code   peek at a table     │
                                   │  GET  /api/rooms/:code/ws  WebSocket upgrade │
                                   │                 │ idFromName(code)           │
                                   │                 ▼                            │
                                   │ Durable Object "Room" (one per table)        │
                                   │  shared/engine.ts  (authoritative rules)     │
                                   │  hibernating WebSockets, SQLite storage      │
                                   │  undo history, presence, claims, alarms      │
                                   └─────────────────────────────────────────────┘

The server owns the truth. Phones send intentions (act, award, undo); the room's Durable Object validates them against the rules engine and broadcasts the new state to everyone. A client cannot move chips, act out of turn or pretend to be someone else.

Every change is versioned. Each state carries a version v, and every action names the version it was decided on. Double taps, two people pressing "Deal next hand" at once, and actions taken from a stale screen are rejected with STALE. The sender gets the fresh state back.

Identity is a device secret. Each device generates a random 256-bit token. The room stores only a SHA-256 hash of it (salted with the table code) and never broadcasts it. Taking over a seat from a new device needs approval from someone at the table, unless nobody else is around.

Undo rewinds the game, not the guest list. The last 30 game states are kept. Membership lives outside that history, so undoing never removes someone who just sat down or brings back someone who was removed.

This is the beginning of the README. Read the rest at the original. Read the full README ↗