9 High Studios | Poker Software Development

Why Choose Us

Built by poker players, for poker players

⚡

Lightning Fast

Optimized networking stack delivers real-time gameplay with minimal latency, even on mobile connections.

🔒

Provably Fair

Cryptographic verification ensures every shuffle and deal can be independently audited for fairness.

📊

Deep Analytics

Comprehensive hand histories, statistics tracking, and performance insights for serious players.

🎯

Tournament Ready

Full tournament management with customizable structures, late registration, and prize distribution.

🌐

Cross Platform

Native experiences across web, iOS, Android, and desktop with synchronized player accounts.

🛠️

White Label Ready

Fully customizable branding and configuration for operators looking to launch their own poker room.

Player First

Built at the felt, not in a boardroom

Every feature we ship gets tested at our own home games first. If it doesn't feel right at 2am with real money on the line, it doesn't ship.

We're not a team of developers who read about poker. We're players who learned to code. That difference shows in every decision we make - from the snap-responsive fold button to the shuffle algorithm we spent months perfecting.

When you're deep in a tournament and the software disappears, letting you focus purely on the game - that's what we're building toward. Because we've been in that seat, and we know what matters.

♠

We play what we build

Weekly home games are our first QA environment

♥

Details matter

Milliseconds, animations, chip sounds - we sweat it all

♦

Trust is everything

Provably fair isn't a feature, it's a requirement

♣

No shortcuts

We'd rather delay than ship something we wouldn't play

Give Back

Open source tools for the community

We believe in building in public. These packages power our products and are free for everyone to use.

📦

@block52/deck

TypeScript / NPM

GitHub →

A 52-card deck implementation with cryptographic shuffling. Fisher-Yates algorithm, deterministic seeding, SHA256 verification.

import { Deck } from "@block52/deck";

// Create and shuffle
const deck = new Deck();
deck.shuffle();

// Deal a hand
const hand = deck.deal(2);
console.log(hand[0].mnemonic); // "AS"

// Deterministic shuffle with seed
deck.shuffle(seed);
const hash = deck.hash(); // SHA256

npm install @block52/deck

🎯

equity

Go / Pokerchain

GitHub →

Monte Carlo equity calculator for Texas Hold'em. Parallel simulation, configurable iterations, stage-aware calculations.

package main

import "github.com/block52/pokerchain/x/poker/equity"

func main() {
    calc := equity.NewCalculator(
        equity.WithSimulations(10000),
        equity.WithWorkers(8),
    )

    // Calculate preflop equity
    hands := [][]string{
        {"AS", "KS"},  // Player 1
        {"QH", "QD"},  // Player 2
    }
    result := calc.Calculate(hands, nil)
    // result.Results[0].Equity = 0.434
}

go get github.com/block52/pokerchain

Open Research

CardLang: Formally Specified Card Games

We develop open-source tools and research for provably fair gaming systems.

Fisher-Yates Shuffle Algorithm

Our deterministic shuffle implementation uses the Fisher-Yates algorithm with a 256-bit cryptographic seed, ensuring every shuffle can be independently verified.

// Input: Deck D, seed s ∈ {0,1}²⁵⁶
function shuffle(deck, seed) {
    rng = initRng(seed)
    for i = n-1 downto 1:
        j = rng.random(0, i)
        swap(deck[i], deck[j])
    return deck
}

🔐

Commitment Scheme

Multi-party seed generation prevents manipulation

✓

Verifiable

Any player can audit shuffle outcomes

∞

Deterministic

Same seed always produces same result

What is CardLang?

A domain-specific language treating Card, Rank, Suit, and Deck as language primitives. Game definitions are both human-readable and mathematically precise.

Functional approach inspired by Haskell
Composable deck expressions
Verified compilation to multiple backends
Integration with commitment schemes for trustless execution

Zero-Knowledge Proofs for Card Games

We use zero-knowledge proofs to enable players to prove properties about their hands without revealing the cards themselves - essential for trustless poker.

Commitment Scheme

Each card is committed using a Pedersen commitment:

C = g m \cdot h r mod p

Where m is the card value, r is a random blinding factor, and g, h are generator points.

Range Proofs

Prove a committed card is valid without revealing it:

\exists m : C = Commit(m) \land m \in [0, 51]

The prover demonstrates knowledge of a valid card index without disclosure.

Hand Evaluation

Prove hand ranking without revealing hole cards:

π = ZK.Prove{ (h₁, h₂, b) : Eval(h₁, h₂, b) = R }

Players prove their hand evaluates to rank R given community cards b.

Shuffle Verification

Prove shuffle correctness via permutation network:

\foralli : C' π(i) = ReRand(C i, r i)

Each output is a re-randomization of some input, proving no cards added or removed.

Mental Poker Protocol

Setup

Players jointly generate encryption keys: $pk = \prod pk i$

Encrypt Deck

Each card encrypted: $E(m) = (g r, pk r \cdot g m)$

Joint Shuffle

Players sequentially shuffle and re-encrypt with ZK proof of correctness

Threshold Decrypt

Card revealed only when all players provide decryption shares: $m = D sk₁ (D sk₂ (...(c)))$

The Table

Meet the players behind the code

Lucas Cullen

Founder

Full-stack developer with 12+ years in Bitcoin and blockchain. Ex ConsenSys, former board member of Blockchain Australia, Deloitte/Consensus hackathon winner. Writes provable code using discrete mathematics and builds chains in Go and Haskell.

Favorite hand: 2-3 suited

Dr Thomas Miller

Cryptography Research

Ex ConsenSys. PhD researcher at QUT specializing in applied cryptography, blockchain security, and zero-knowledge proofs. His work on information symmetry and common knowledge theory directly informs the provably fair systems at the heart of Block 52.

Favorite hand: 7-2 offsuit

Who We Work With

Built for the poker industry

Whether you're running a home game or a full-scale operation, we build the platform to match.

♣

Poker Club Operators

Your own branded poker room — tournaments, cash games, player management.

♦

Casino & Gaming Companies

Enterprise-grade platforms with compliance-ready architecture and audit trails.

♠

Crypto Poker Platforms

Blockchain-native poker with provably fair mechanics and on-chain settlement.

♥

Private Game Organisers

Custom apps for your regular game — invite-only, branded, no middleman.

How It Works

From idea to live tables

Simple, transparent process. No surprises.

Get in Touch

Reach out via Telegram, Email, or WhatsApp. Tell us what you're building.

We Scope It

We map out your requirements, features, and timeline together.

Proposal & Quote

You get a clear proposal with pricing, milestones, and deliverables.

Build & Launch

We build your platform, test it, and get you live. Ongoing support included.

Start a Conversation

We build poker software

Introducing Block 52