iGaming-Systeme · Architektur & interaktives Lab

Von der Spieleraktion zum autoritativen Ergebnis.

Eine visuelle Tour durch Multi-Tenant-Casino-Plattformen, Wallet- und Settlement-Flows, Echtzeit-Events, sichere Game Logic und spielbare Demos, die diese Systemgrenzen greifbar machen.

production.experience

Mehr als Game Logic.

Architekturerfahrung über den gesamten Pfad – von der Betreiberkonfiguration bis zum aktualisierten Spielerkonto.

platform.control

White-Label & Multi-Tenant

Betreiberbezogene Konfiguration, regionale Policies, Provider Catalogs und isolierter Tenant-Kontext.

Tenant-GrenzeRegionale PolicyRGS Adapter
transaction.core

Wallet- & Game-Transaktionen

Explizite Bet-, Debit-, Result-, Payout- und Balance-Übergänge rund um Idempotenz.

Wallet FlowsSettlementDeduplizierung
realtime.fabric

Realtime & Event-Driven

High-Concurrency Services, Durable Messages, gezielte Spielerupdates und skalierbare Consumer.

WebSocketsMessage BusBackpressure
data.scale

High-Volume-Datenpfade

Operative Modelle für Schreibwachstum, begrenzte Queries, Caching und Auditierbarkeit.

10 Mio.+ Datensätze/TagShardingRead Models
transaction.pathKorrektheit an jeder Systemgrenze
Spieler
Gateway
Wallet
Game / RNG
Events
Settlement
Realtime
architecture.live

So durchläuft eine Casino-Transaktion das System.

Folgen Sie Requests, Geldbewegungen, Events, Ergebnissen und Spieler-Updates durch eine produktionsnahe Architektur.

Preparing transaction visualization…
Serverautoritatives Ergebnis
Explizite Zustandsgrenzen
Klares spielbares Feedback
runtime.catalog / 09 + 01

Systemgrenzen spielerisch erleben.

Neun API-gestützte Spiele und ein deterministisches Browser-Experiment – jeweils mit einer kompakten technischen Einordnung in etablierten Engineering-Begriffen.

demo 01Server authoritative
REST · 80-number matrixready
game.service/keno Server-backed game

American Keno

An American Keno prototype with an adaptive 80-number matrix, animated draws, cryptographically secure server outcomes, and explicit payout feedback.

Server-side draw and payout calculation
NestJSCSPRNGCSS MotionPaytable
Technischer Nachweis
ClientREST APIGame sessionCrypto drawPaytableResult
RNG
Node.js crypto.randomInt() drives a Fisher–Yates draw without replacement.
Zustand
A NestJS-owned in-memory session is keyed by a cryptographic UUID.
Game Logic
The service validates 2–10 selections, draws 20 numbers, counts hits, and applies the configured multiplier.
RTP / Tests
Combinatoric probability helpers calculate theoretical RTP for each selection count.

Demo credits and sessions are simplified; there is no production wallet, durable ledger, or certification layer.

demo 02Server authoritative
REST · sealed symbol stateready
game.service/scratch-cards Server-backed game

Scratch Cards

An instant-win scratch game with accessible progressive reveals, secure server-owned symbols, live settlement states, and responsive card controls.

Authoritative game state and reveal validation
NestJSAccessible UICrypto RNGInstant Win
Technischer Nachweis
ClientREST APISealed sessionCrypto symbolsRevealPayout
RNG
Node.js crypto.randomBytes() provides weighted, server-side symbol selection.
Zustand
The server retains the complete card; the client receives only symbols it has revealed.
Game Logic
Nine weighted symbols are sealed when the card is created, then match groups resolve against the paytable.
RTP / Tests
The RTP test runner samples large card volumes and compares observed return with the configured model.

The balance is a portfolio-only credit simulation; sessions are in memory and do not represent financial settlement.

demo 03Server authoritative
REST · session historyready
game.service/rock-paper-scissors Server-backed game

Rock Paper Scissors

A house-bot game with server-generated moves, a balanced paytable, live session statistics, accessible controls, and a responsive settlement arena.

Server-authoritative moves and settlement
NestJSCrypto RNGGame TheoryREST API
Technischer Nachweis
ClientREST APIGame sessionCrypto movePaytableBalance
RNG
Node.js crypto.randomBytes() produces an unbiased house move after the player commits.
Zustand
The service owns virtual balance, current wager, round result, statistics, and session history.
Game Logic
The engine resolves the move pair, applies a win/tie/loss multiplier, and returns the updated balance.
RTP / Tests
The three equally likely house moves and explicit multipliers produce a 95% theoretical return.

Balances are virtual and sessions are ephemeral; authentication, ledgering, and responsible-gaming controls are outside this demo.

demo 04Client simulation
Canvas · deterministic loopready
game.service/maze Interactive client experiment

Mini Maze

A dependency-light, client-only PixiJS demo showing a responsive canvas, deterministic movement, collision checks, and keyboard controls.

Client-side rendering and collision loop
PixiJSCanvasGame Loop
Technischer Nachweis
InputPixiJS loopCollision mapGoal stateUI feedback
RNG
No RNG is used; movement and collision behavior are deterministic.
Zustand
Position, movement count, elapsed time, and completion state live entirely in the browser.
Game Logic
Keyboard, touch, or on-screen input advances the player only when the next bounding box avoids every wall.
RTP / Tests
A fixed maze and deterministic step size make routes repeatable and interaction behavior easy to verify.

This is deliberately a client-side rendering experiment, not a server-backed wagering game.

demo 05Server authoritative
REST · 3×3 reel matrixready
game.service/double-diamond Server-backed slot engine

Double Diamond

A three-reel mechanical slot port demonstrating exact reel-strip sampling, blank stops, wild substitution, and stacked 2×/4× multiplier rules.

Native TypeScript port of the calibrated Go algorithm
NestJSCSPRNGReel StripsWild Rules
Technischer Nachweis
ClientREST APIGame sessionCrypto reel stopsWin scannerResult
RNG
Node.js crypto.randomInt() selects an independent stop on each calibrated reel strip.
Zustand
A NestJS session owns bet configuration and the previous spin while the UI maintains demo-only credits.
Game Logic
The scanner handles blanks, exact triples, mixed bars, cherries, and Double Diamond wild multiplication.
RTP / Tests
Deterministic scanner tests verify one-wild 2× substitution against the original Go payout semantics.

The 95.109723% figure belongs to the imported reel set; demo credits are not a wallet or durable ledger.

Demo starten Integrierte Runtime
demo 06Server authoritative
REST · 3×3 / 5 linesready
game.service/always-hot Server-backed slot engine

Always Hot

A compact three-reel classic using Seven, Star, Bell, Melon, Grapes, Orange, Plum, Lemon, and Cherry across five selectable paylines.

Selectable-line reel and payout engine
NestJSCSPRNG5 Paylines9 Classic Symbols
Technischer Nachweis
ClientREST APILine configCrypto reel stopsLine scannerResult
RNG
Every reel stop is sampled server-side using Node.js crypto.randomInt().
Zustand
The game session owns the bet-per-line, active line count, screen, wins, and last result.
Game Logic
Only selected paylines are evaluated; three matching symbols settle from the imported paytable.
RTP / Tests
A focused test proves inactive lines cannot contribute wins to a spin response.

The calibrated 95.504233% source RTP assumes its exact reel set and play configuration, not a short demo sample.

Demo starten Integrierte Runtime
demo 07Server authoritative
REST · 5×3 / 5 linesready
game.service/cherry-hot Server-backed slot engine

Cherry Hot

A five-reel fruit slot using Strawberry, Blueberry, Plum, Pear, Peach, Cherry, Apple, and a dedicated Scatter with full-column multipliers.

Line, scatter, and fill-multiplier evaluation
NestJS5 ReelsDedicated ScatterFill Multiplier
Technischer Nachweis
ClientREST APIGame sessionReel samplerMulti-rule scannerResult
RNG
Five calibrated strips are sampled independently by the backend CSPRNG.
Zustand
The engine returns a reel-major screen and normalized line/scatter win records with exact coordinates.
Game Logic
Left-aligned line wins, scatter counts, and consecutive filled-column multipliers are evaluated separately.
RTP / Tests
The parity suite verifies a five-column filled screen applies the original 5× multiplier.

This demonstrates game-math separation and result contracts; it does not implement regulated settlement.

Demo starten Integrierte Runtime
demo 08Server authoritative
REST · 5×3 / 9 linesready
game.service/captains-treasure Server-backed slot engine

Captain's Treasure

A nine-line five-reel engine showcasing bidirectional line evaluation, wild multiplication, scatter settlement, and normalized win coordinates.

Bidirectional line and scatter scanner
NestJSBidirectional PaysWilds9 Paylines
Technischer Nachweis
ClientREST APIGame sessionReel samplerL→R / R→L scannerResult
RNG
The service uses cryptographic reel-stop selection against a source-calibrated strip set.
Zustand
One isolated session owns configuration and the previous result; every win includes its line and hit positions.
Game Logic
The scanner evaluates left and right runs without overlap, applies wild multipliers, then settles scatters independently.
RTP / Tests
A deterministic screen proves simultaneous left- and right-paying combinations preserve the Go behavior.

The 95.353086% reel model is presented as technical evidence, not certification or a financial guarantee.

Demo starten Integrierte Runtime
demo 09Server authoritative
REST · 20-of-80 drawready
game.service/fire-keno Server-backed keno engine

Fire Keno

An 80-number keno port with 2–10 selections, secure draws without replacement, an exact imported paytable, and explicit hit-state rendering.

Secure draw and exact paytable evaluation
NestJSCSPRNG80 NumbersPaytable
Technischer Nachweis
ClientREST APISelection validationCrypto drawHit scannerPayout
RNG
A cryptographic Fisher–Yates shuffle draws 20 unique numbers from 80.
Zustand
The server owns validated selections, bet, board state, previous draw, and payout multiplier.
Game Logic
Hit count indexes the exact Fire Keno row for the selected-number count.
RTP / Tests
A deterministic two-hit draw verifies the imported 6× multiplier and final payout.

The 92.028857% source RTP is mathematical metadata; the UI balance is deliberately local and virtual.

Demo starten Integrierte Runtime
demo 10Server authoritative
REST · 20-of-80 drawready
game.service/keno-fast Server-backed keno engine

Keno Fast

A fast 20-of-80 keno runtime supporting 1–10 selections, secure server draws, distinctive low-hit payouts, and accessible keyboard controls.

Secure draw with selection-specific payout rows
NestJSCSPRNG1–10 PicksFast Draw
Technischer Nachweis
ClientREST APISelection validationCrypto drawPaytableResult
RNG
The same reusable crypto sampler draws unique numbers without moving authority into the browser.
Zustand
Selections and the last draw remain isolated inside a short-lived NestJS session.
Game Logic
The game supports one-number play and unusual zero-hit returns for selected higher-count rows.
RTP / Tests
A deterministic one-hit case verifies the original 3.8× single-number payout.

The 95.616967% value is the source game RTP; virtual credits exist only to make result deltas visible.

Demo starten Integrierte Runtime