In-house crash-game studio Β· live production infrastructure

Five crash games.
Already running.
Already measured.

Every game on this page is deployed right now, with real HMAC-verifiable fairness and real load-test evidence behind it. This page links to the actual running builds β€” not renders, not concepts.

0
Playable games live now
0
Peak concurrent players load-tested
0
Cashout p95 latency at 5,000 concurrent
0
Unit + end-to-end tests on Six Seven alone

Live right now

Every row below is a real deployment on the same VPS, behind the same reverse proxy. Click through β€” no login required, virtual credits only.

Portfolio

Five games. Five different hooks.

Each card is built from that game's actual codebase β€” its mechanics and what keeps players coming back. Click a card to expand full detail, or launch the live build directly.

Multiplayer Β· Deep-sea theme Live demo
Abyss gameplay screenshot β€” submarine diving with live multiplier

Abyss

A research bathyscaphe dives into the deep. Trigger Emergency Eject before it doesn't come back up.

2 bet slotsHMAC fairness10M-round RTP simulated5,000 concurrent tested
Full detail β–Ύ

Core loop & unique mechanics

Round phases: WAITING (~5s bet window) β†’ LOCKED β†’ DIVING (multiplier climbs) β†’ CRASHED β†’ SETTLING. Up to two simultaneous bet slots per round, manual and server-enforced Auto Cash Out (min 1.01x). Cap at 10,000.00x settles remaining bets at the cap β€” a capped payout, not a forced crash.

  • Chest bonuses β€” server-authoritative additive multiplier (+0.01x to +0.08x), spawn only past 3.00x, 2% probability per spawn, RTP impact capped ≀29bp even in extreme simulation.
  • Micro-pickups β€” tap drifting jellyfish/plankton for 1–6bps of stake; ~72% are empty decoys by design, capped at 5 paid claims / $0.30 per bet.
  • Daily Dive Records β€” leaderboard of best cashout depth per day.
  • Fairness Verify panel β€” "Model A": the round's client seed is built by hashing together every bettor's own launch seed (sorted, de-duplicated) β€” every player in the round provably shapes the shared outcome.

Why players keep betting

The depth gauge isn't decorative β€” it's calibrated to real geography: the 10,000x multiplier cap maps to exactly 10,994 meters, the actual depth of the Mariana Trench's Challenger Deep. The implicit goal stops being just "cash out in time" and becomes "how close to the ocean's real deepest point did you dare go" β€” a bragging point the live public bet feed and daily leaderboard put on display for everyone else in the round. Fast ~5s cadence keeps sessions dense; dual bet slots let cautious and aggressive strategies run side by side; decoy-heavy pickups reward attention without inflating risk; and mystery-value bonus reveals plus a chest "magnet" animation build anticipation between dives.

Under the hood

A server-authoritative game loop with Redis-backed horizontal scaling, HMAC-signed fairness end to end, and integer-cents accounting throughout β€” verified against a 10-million-round RTP simulation.

Multiplayer Β· Live bet feed Live demo
AtomicOverload gameplay screenshot β€” orbiting atom with live multiplier

AtomicOverload

An atom destabilizes as the multiplier climbs. Collect before OVERLOAD β€” or ride it to the cap.

2 bet slotsDistinct cap outcomeLive bet feedZero-finding QA reviews
Full detail β–Ύ

Core loop & unique mechanics

A live multiplier climbs through four distinct states β€” STABLE (betting) β†’ Charging β†’ EXCITED/UNSTABLE (multiplier rises) β†’ OVERLOAD (crash). A dedicated MAX_MULTIPLIER_REACHED "cap" outcome gets its own gold/amber visual burst and audio, clearly distinct from a standard crash.

  • Atom-field canvas β€” nucleus glow, orbiting electron rings on fixed tetrahedral planes, lightning-arc "current" whose intensity and speed scale directly with the live multiplier.
  • Dual bet slots with independent auto-collect targets per slot.
  • Live public bets feed plus an on-demand full Players modal for social visibility.
  • Real HMAC commit/reveal fairness with a copy-to-clipboard verification drawer (not cosmetic).

Why players keep betting

The phase labels alone carry the tension β€” Charging, then EXCITED, then UNSTABLE, before OVERLOAD detonates it β€” and the escalating instability is the actual hook: players wait to see how much charge they dare to sit through, and the atom-field animation intensifying in real time is designed to hold the eye even between decisions. Fast rounds keep sessions dense; crash-history chips blink the instant a new result lands; the Collect-button pulse is gated precisely to legal cash-out windows to avoid mis-taps; and a live public bets feed turns "who held on longest" into a visible comparison, not just a private bet.

Under the hood

Reconnect and resilience handling, fail-closed integer validation, and full accessibility support (reduced motion, 44px touch targets) are built in. Real-time multiplayer runs server-authoritative with HMAC commit/reveal fairness. Built with React 19, TypeScript and Vite, rendered on Canvas 2D.

Single-player Β· Meme-native Live demo
Six Seven gameplay screenshot β€” beach performer with live multiplier

Six Seven: The Riff

A beach performer dances the viral "six-seven" moment. Land the multiplier on 6.70x for the built-in brand moment.

108 unit + 63 e2e testsShareable win cardEN/UK localized
Full detail β–Ύ

Core loop & unique mechanics

5s betting window β†’ 1.2s lock β†’ multiplier climbs from 1.00x in 100ms compounding ticks (+0.6%/tick) β†’ cash out or crash β†’ SHA-256/HMAC reveal β†’ next round arms. RTP target 97%, cap 10,000x.

  • The "SIXΒ·SEVEN moment" β€” landing a crash or cashout in the 6.70x Β± 0.1 zone triggers a dedicated banner, confetti and voice fanfare: a brandable, memeable, screenshot-worthy payout event built into the math, not bolted on.
  • Heat Rise β€” flaming digit launches on every dance peak plus a right-edge thermometer gauge scaling to 1000x, pure visual tension with zero RTP impact.
  • 67 Beats + Cheer Crew β€” a callout on every "n.67" crossing, with six escalating cheer-dancer phases at 1.67x/2.67x/6.67x/16.67x/36.67x/66.67x (the top phase survives roughly 1.5% of rounds).
  • Four narrative crash cinematics (instant-crash shark, low/mid wave-fall, high-multiplier chase-off-stage) instead of one generic "you lost" state.

Why players keep betting

The Heat Rise thermometer isn't the only thing escalating β€” the Cheer Crew's outfits advance through six phases at set multiplier thresholds, each phase revealing a bit more than the last. That gives players a second reason to push past a safe cash-out: not just the multiplier, but curiosity about what the next phase looks like. Win celebrations escalate too β€” confetti bursts scale from 12 to 24 to 44 pieces at the 2x/5x/10x tiers, with an added chime at 5x and a layered triumphant chord plus a noise swell at 10x. A shareable branded result card goes out after every round via the Web Share API, a live player feed shows a simulated crowd of bets and cashouts, and dual bet slots come with server-enforced auto-cashout and instant presets (Β½ / Γ—2 / min / max).

Engineering

171 automated tests stand behind this build β€” 108 Vitest unit tests across 10 files plus 63 Playwright end-to-end tests on desktop and mobile β€” alongside a full accessibility pass. Built with Vite, TypeScript and vanilla DOM, with no rendering-framework overhead.

Single-player Β· 3 difficulty worlds Live demo
RamRun gameplay screenshot β€” ram facing a fence with live multiplier

RamRun

A lovestruck ram charges through fences to reach his ewe. Break, double, "Catch Her" β€” or crash.

Math-audited RNG model3 themed worldsOffline-first
Full detail β–Ύ

Core loop & unique mechanics

A finite ladder of exactly 5 fences: bet, pick a difficulty, Dash, and either cash out ("Catch Her") after any break or push on. Clearing all 5 auto-cashes out. Three difficulty tiers double as full narrative settings, not just volatility sliders β€” Easy "Lamb" (Γ—1.5/step, home farm, picnic finale), Normal (Γ—2.0, forest, jacuzzi finale), Hard "Full Ram" (Γ—3.0, city street, cabrio finale) β€” all built on the same house edge (EDGE = 0.96). Realized RTP is 95.4–96.0% depending on cashout step and difficulty, converging toward 96% as the multiplier grows; the gap between difficulties at a given step (~0.32pp at step 1, narrowing to ~0.12pp by step 5) is a rounding artifact of the discrete formula, not a designed difference in odds β€” difficulty is primarily a variance and spectacle choice.

  • Full biome-warp transition (sky/ground/scenery swap) plays when switching difficulty mid-session.
  • Tension meter, near-miss fence-shudder telegraph, "Same bet" instant replay, knockdown/stun animation with stars on crash.

Why players keep betting

The whole premise fits in one sentence β€” break fences, cash out before the crash β€” and a finite 5-step ladder means a first-time player understands the entire game within one round. That low barrier to entry is deliberate: broad appeal here comes from how little a player has to learn before their first bet feels informed, not from added complexity. On top of that: achievements, daily bonus, leaderboards by multiplier and biggest win, full round-history modal, dynamic music ducking on payoffs, and per-material impact SFX. Offline-first design means the exact same math runs client-side for instant play and server-side for authoritative settlement β€” two deployment modes, one game.

Engineering

Iterative QA has refined animation timing, contrast ratios and touch-target sizing down to the pixel, round after round. Every font, asset and dependency is covered by a full license inventory. Runs as a single-player, guest-session game with an optional authoritative backend.

Single-player Β· Zero-dependency deploy Live demo
Alco Crash gameplay screenshot β€” bar scene with drink selection

Alco Crash

"Pour and Don't Miss." A bartender climbs a drink ladder one shot at a time β€” cash out, or Mihalych doesn't make it home.

222 generated assets10 outcome cutscenesPure static option
Full detail β–Ύ

Core loop & unique mechanics

A single-player, turn-based push-your-luck game: each "shot" climbs a multiplier ladder until the player cashes out or the round crashes. Three selectable drinks (beer / wine / vodka) act as risk ladders of different steepness at an identical house edge (96%) β€” a real variance choice, not a dressed-up difficulty toggle.

  • 10 distinct full-frame video cutscenes, escalating by outcome tier β€” from a solo bar jig on a small win to a full storm-out on a big crash, all commissioned, produced assets rather than stock loops.
  • A cosmetic near-miss stagger animation plays when a result lands close to (but not on) a crash.
  • Auto-cashout was deliberately not built β€” an explicit design call because "it doesn't fit the push-your-luck genre; the player should feel every sip decision."
  • HMAC-SHA256 provably-fair RNG with client-side verification when the backend is enabled.

Why players keep betting

The premise borrows a real pub dynamic on purpose: the appeal isn't just the multiplier, it's the same competitive pull as a drinking round with friends β€” who can go one more shot without tipping over. Six achievement badges with progress bars, daily leaderboards, a daily "broke" bonus, in-round micro-events (free extra sip, cosmetic multiplier-boost toast), and a live tension bar tracking depth into the current drink keep that rivalry visible round after round. The ten outcome cutscenes are built to be the moment worth a screenshot or a replay β€” the same instinct that makes a good bar story get retold.

Engineering

222 production assets β€” four full 36-frame drunkenness-tier spritesheets, per-drink SFX, and one theme melody re-scored into three emotional variants β€” came out of an iterative generation pipeline with full prompt and provenance records kept for every asset. React and all fonts are fully vendored and self-hosted, with no runtime dependency on a third-party CDN. An optional Go backend enforces integer-cents accounting end to end and has passed audited fixes for idempotency and fail-closed server authority, closing off client-side settlement leaks.

Performance evidence Β· Abyss

Real load tests, not projected capacity

Measured on Abyss's own game engine on a 6-core / 12GB VPS β€” the same class of hardware this demo runs on today.

5,000
concurrent simulated players
Cashout HTTP p5032ms
Cashout HTTP p9546ms (target ≀75ms)
Cashout HTTP p9953ms (target ≀150ms)
Cashout errors0
10,000
concurrent, spread-bet scenario
Bet HTTP p950ms
Bet HTTP p9924ms
Errors0
10,000,000
round RTP simulation on file
Configured RTP97%
Deterministic test vectorsinstant-crash, cap, normal
517ms
WebSocket round-tick p99 at 5k on this demo VPS (design target: 250ms)

This is a demo-server ceiling, not a design flaw. Our own scaling notes are explicit that clearing the 250ms target just needs more CPU cores per node β€” 16+, versus the 6 this public demo happens to run on. The backend itself is already built for that scale-up: the Redis leader-lock architecture behind it (see below) is designed to add capacity as concurrent players grow, whether that means more cores on this node or more nodes in the fanout. Upgrading the server, not redesigning it, is what closes this gap.

Documented horizontal scaling path: single node handles ~10,000 concurrent WebSocket connections today. Redis leader-lock architecture (one authoritative game-loop leader, N standby fanout nodes) projects to ~30,000 concurrent on 3 nodes and ~50,000 on 5 β€” a scaling model, not a hope.
Technology

Fairness players can verify, not just trust

Fairness that can be checked, not just claimed. Here's exactly how the commit/reveal pattern works.

01

Before the round

The server generates a random seed and publishes only its SHA-256 hash. The outcome is already fixed β€” the server cannot change it after bets are placed.

02

During the round

Abyss extends this further: the client seed is derived by combining the launch seeds of every player who bet in that round (sorted, de-duplicated, hashed) β€” so every bettor provably influenced the shared result, not just the house.

03

After the round

The server reveals the seed. Players get the server seed, the hash, the client seed, the nonce, the round ID and the resulting HMAC β€” and can recompute the crash point themselves in a Verify panel.

04

Money handling

Balances and payouts are handled in integer minor-units β€” never floats β€” the kind of detail that closes off rounding-error exploits before they start.

Admin console

The Abyss backend ships a full admin console β€” this is what a finance and risk team would actually use:

  • GGR / RTP dashboards, filterable by currency and session type
  • Full round drill-down with complete bet and audit trail
  • Reconciliation workflow: draft β†’ submit β†’ approve/reject, CSV export
  • Incident timeline distinguishing RNG outcomes from operational interruptions
  • Machine API keys with scoped permissions
  • MFA/TOTP step-up auth, 6 role bundles (viewer, support, finance, admin, platform admin, auditor)
Open the live admin demo β†’

Signs you in with a read-only viewer account β€” dashboards and audit trails only, no config or reconciliation access.