We build fast betting-style games with combined mechanics: casino-length rounds priced like a sportsbook. Cards, cricket, football physics and crash ladders — every outcome gets real odds, every round settles in about a minute, and every result is provably fair.
Every title runs on the same formula: a fully automatic round decided by a provably fair seed, priced with sportsbook math — odds = (1 − margin) / p — and settled the moment an outcome is known. The player never plays. The player bets.
The Indian classic at three speeds: Classic with a second betting window mid-deal, CraZZy with a multiplier that grows card by card, and a pure Crash mode where you cash out before the matching card lands.
Auto-dealt Texas hold’em on three synced tables. Nobody plays the hand — everybody bets on it: winner, winning combination, board totals and street-by-street props across four betting windows per deal.
A full cricket match compressed to one over per innings, ball-by-ball animation and commentary included. Sportsbook coverage — 1X2 with draw, totals, handicaps, wickets, boundaries, next-3-balls — in about two minutes.
A real 2D physics engine decides every match from a provably fair seed — no canned video. Sportsbook classics on a 78-second fixture: 1X2, totals, team totals, handicaps, both-to-score and half markets.
The trump-trick classic dealt face-up and played by a deterministic policy you can verify in the browser. Bet the winner, the AZI tie, the trump suit or any single trick — every round exactly 60 seconds.
Latin America’s table legend as a bet-on-the-deal: Argentino, Paulista and Mineiro rule sets, envido and manilha side-bets, and a ×646 EMPATE lottery ticket hiding in every round.
Classic games are slow because players make decisions. We remove the decisions, keep the drama, and hand the player something better: odds on everything they are watching.
Hands, matches and tricks resolve automatically under deterministic rules. No skill gap, no waiting for opponents — a spectator sport with a bet slip.
Every price is (1 − margin) / p: exact distributions, Monte-Carlo where needed, 10-million-deal simulation tables for card games. Margins are tuned per market from the back office.
Rounds run 60–100 seconds with multiple betting windows inside each round — poker streets, cricket innings breaks, football half-time, even a mid-deal pause in Andar Bahar. Soccer takes bets on the next match while the current one plays.
Every round is decided by a server seed that was fixed — and published as a hash — before that round existed. When it settles the seed is revealed, and the player’s own browser rebuilds the deal card by card and compares it with what they just watched. Not a promise on a page: four checks anyone can run.
← Hashing runs backwards. Every revealed seed hashes to the link before it, down a chain of 100,000 that ends at a head published before the first bet. The operator cannot rewrite the sequence once bets are on the table.
→ Play runs forwards. Round k uses seed k and reveals it at settlement. Cards already on the table leak nothing about the seeds still to come — the generator is keyed by the whole seed, not a 32-bit shortcut.
A chain of 100,000 seeds is built backwards from one random terminal seed. Only its head goes public.
headCommitThe round publishes its commitment and its position in the chain, plus the client seed mixed into the shuffle.
serverSeedHash clientSeed chainIndexRandomness is an HMAC-SHA256 byte stream keyed by the server seed, driving a Fisher–Yates shuffle. The outcome is computed once, up front, then replayed on a timer.
HMAC-SHA256 → Fisher–YatesThe seed is revealed with a hash of the full deck order — including the cards that never got dealt.
serverSeed deckHash# 1 · the seed really is this round’s
SHA256(serverSeed) == serverSeedHash
# 2 · and it was fixed before the chain began
SHA256 applied chainIndex times == headCommit
# 3 · rebuild the deal from scratch
HMAC-SHA256(key=serverSeed,
msg="clientSeed:roundId:n")
→ byte stream → Fisher–Yates → deck
# 4 · same cards, same order
SHA256(deck) == deckHash
Seed chain, published commitments and one-tap replay from the round history — the check runs in the player’s own browser with WebCrypto, against the result our server already published.
The replay re-plays every trick under the published policy, including cards never dealt because the hand ended early. A core hash gate stops the server from starting if rules and odds tables ever drift apart.
A timeline hash commits to every keyframe of the simulated match — so the broadcast itself is auditable, not just the final score.
A hash-signed GET returns a session URL; the game runs in an iframe inside your site or app. Demo mode is one extra parameter.
Bet and result callbacks hit your wallet API in real time, idempotent by transaction reference — safe under retries and restarts.
Provider-level freebets flow through the same pipeline, with void-aware refunds that don’t burn wagering progress.
Per-market margins and visibility, tenant management and a full game catalog — changes reach live games within a minute, no redeploys.
Every round reports to the provider with seeds, hashes and settlement records; interrupted bets are automatically refunded.
GET /IntegrationService/v3/http/GameURL
?secureLogin=your-casino
&playerId=player-42
&gameId=cricket
¤cy=USD
&hash=md5(sorted-params + securePassword)
HTTP/1.1 200 OK
{
"error": "0",
"description": "OK",
"gameUrl": "https://cricket.texx.games/game?token=…",
"sessionId": "…"
}
// embed and you're live
<iframe src="{gameUrl}" allow="fullscreen"></iframe>
Every game above has its own demo. Each launch creates a fresh player with a virtual balance of 1,000 — pick a title, place a bet, watch it settle.