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.
Every row below is a real deployment on the same VPS, behind the same reverse proxy. Click through β no login required, virtual credits only.
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.
A research bathyscaphe dives into the deep. Trigger Emergency Eject before it doesn't come back up.
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.
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.
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.
An atom destabilizes as the multiplier climbs. Collect before OVERLOAD β or ride it to the cap.
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.
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.
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.
A beach performer dances the viral "six-seven" moment. Land the multiplier on 6.70x for the built-in brand moment.
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 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).
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.
A lovestruck ram charges through fences to reach his ewe. Break, double, "Catch Her" β or crash.
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.
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.
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.
"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.
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.
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.
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.
Measured on Abyss's own game engine on a 6-core / 12GB VPS β the same class of hardware this demo runs on today.
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.
Fairness that can be checked, not just claimed. Here's exactly how the commit/reveal pattern works.
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.
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.
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.
Balances and payouts are handled in integer minor-units β never floats β the kind of detail that closes off rounding-error exploits before they start.
The Abyss backend ships a full admin console β this is what a finance and risk team would actually use:
Signs you in with a read-only viewer account β dashboards and audit trails only, no config or reconciliation access.