⚡ PRE-LAUNCH · CLOSED BETA

Poker without the paperwork.

Browser-based Texas Hold'em with friends. Free play, or real stakes in USDC on Base. Closed beta opening soon — claim your seat.

NO SIGNUP

NO KYC

BUILT ON BASE

or get dealt in

Get first access + invites to free-entry tournaments with USDC prizes.

Follow the action

Learn More

Poker Night is Back 🤑

We brought the Friday night home game to your browser. Talk trash in the chat, throw emojis at your friends, and settle the score without leaving your couch.

Poker lobby
ZERO BRAINPOWER NEEDED

Play in seconds.
Just send the link.

You didn't come here to fill out forms. You came to play. Test our game engine, check the vibes, and bluff your friends using a completely anonymous guest account. No strings attached.

  • No SignupNo email, no account
  • No KYCNo ID, no verification
  • Free to PlayPractice with free chips
POWERED BY THIRDWEB

Real stakes. No custody risk.

Sign in with Google, Discord, X, or your wallet. Buy in with USDC on Base. Your stack lives in a smart contract — not our bank account. We can't freeze it. We can't touch it.

How it works:

Sign in with your social account or connect your Web3 wallet. Buy in with USDC. Funds move directly on-chain — no intermediary holds your bankroll.

Base

Base

Google

X

Discord

Apple

Thirdweb Login

Members Only

A Seat is Waiting For You

Free-entry tournaments. Real USDC prizes. Closed-beta invites before anyone else.

Admit One

No spam. Unsubscribe anytime.

3 Steps to the Flop.

We handled the tech so you can handle the cards. No downloads, no updates, just pure poker action.

Step 01

Jump In Instantly

Use what you have—Google, Discord, or your Wallet. Or play free as a Guest — no signup, no email, no nothing.

Step 02

Host Your Table

Spin up a private room. Set the blinds, choose the game speed, and control exactly who sits down. It's your rules.

Step 03

Share & Play

Drop the link in your group chat. Friends join instantly on any browser or device. No app store downloads, ever.

iPhone mockup frame
CHIP VALUE SYSTEM

1 Chip = 0.01 USDC. Always.

No volatility. No conversion games. No surprise haircuts. A 100-chip stack is $1.00 — at buy-in, at showdown, at withdrawal. Smart contracts hold the math.

A 10/20 chip game means blinds of 10/20 chips (0.10/0.20 USDC). Players buy in with USDC and receive the exact chip amount for your table's structure.

FIXED EXCHANGE RATE

USDC

0.01 USDC

1

Chip

EXAMPLE GAMES

5/10 GAME

5/10 chips
0.05/0.10 USDC

25/50 GAME

25/50 chips
0.25/0.50 USDC

Why Onchain?Vault Mode

Your Table is Your Vault.

Speed where it matters. Trust where it counts. The game runs in real time on our engine. Every dollar lives in a smart contract on Base. We deal the cards. The contract holds the cash.

Engine ↔ Banker

Game Engine (Go)

  • Whitelist Handling
  • Shuffling
  • Pot Calculation
State Updates

The Banker (Contract)

  • Custody
  • Payouts
  • Settlement
D
Proof 01

Cryptographic Shuffling

No predictable seeds. Every shuffle uses OS entropy via Go's crypto/rand and a Fisher-Yates pass — the same primitives behind TLS keys. Server-side, but cryptographically unpredictable.

Proof 02

The Smart Contract Banker

Every table deploys its own dedicated Smart Contract (1-to-1). It acts as an automated escrow vault. We update the score, but the contract holds the cash.

Fair Play
ODDS & RANDOMNESS

Random shuffle. Real math.

52! is roughly 8 × 10⁶⁷ unique decks — more than atoms in the observable universe. Every Stacked shuffle picks one, with cryptographic-grade randomness from the operating system itself. No predictable seeds. No insider math.

Odds Engine

Uses standard hand evaluation and repeated runouts to give fast, intuitive win/tie odds as the board develops.

Secure Shuffle

No predictable seeds. We use OS entropy via crypto/rand with Fisher-Yates so each of the 52! decks is equally likely.

Shuffle Seal
52! Decks

Secure Shuffle (Go)

import (
    "crypto/rand"
    "encoding/binary"
)

func SecureShuffleDeck(d *Deck) error {
    *d = append([]Card{}, DefaultDeck...)
    n := len(*d)

    randomBytes := make([]byte, n*8)
    // crypto/rand pulls entropy from the OS CSPRNG, making shuffles unpredictable.
    _, err := rand.Read(randomBytes)
    if err != nil { return err }

    for i := n - 1; i > 0; i-- {
        offset := (n - 1 - i) * 8
        randVal := binary.BigEndian.Uint64(randomBytes[offset : offset+8])
        // Fisher–Yates: each swap index is chosen uniformly from the remaining range.
        j := int(randVal % uint64(i+1))
        (*d)[i], (*d)[j] = (*d)[j], (*d)[i]
    }
    return nil
}

Fisher-Yates shuffle powered by OS entropy via Go's crypto/rand. Read the docs

OS CSPRNGFisher-YatesIndependent shufflesAuditable logic

Frequently Asked Questions?

The old way vs. the Stacked way

The old way

Stacked

Submit your ID. Wait for review.

Connect a wallet. You’re in.

Wait days for withdrawals.

Settle to your wallet, on-chain.

Trust the operator with your bankroll.

Smart contract holds the chips.

Volatile token of the week.

USDC. Always $1.

Download an app from 2018.

Open a link. Any device.

Stacked Logo

STACKED

The easiest way to play poker with friends, onchain. No downloads, no hassle — just pure poker action.

Product

Play NowCreate Table

© 2026 Stacked Poker. All rights reserved.

Built with Thirdweb

Made for Onchain Friends