managarten/NewAppIdeas/Roblox Reimagined/Technische-Architektur.md

Roblox: Technische Architektur & moderner Neuaufbau

Wie Roblox technisch funktioniert -- und wie man es heute besser bauen wuerde

---

Inhaltsverzeichnis

1. Wie Roblox heute technisch funktioniert
2. Wie man es heute mit modernster Technik bauen wuerde
3. Was neue Technik ermoeglicht, das Roblox nicht kann

---

Teil 1: Wie Roblox heute technisch funktioniert

1.1 Die Game Engine

Roblox nutzt eine komplett eigenentwickelte C++-Engine. Kein Unity, kein Unreal -- alles in-house seit 2006, stetig weiterentwickelt.

Rendering

• Windows: Direct3D (DirectX)
• macOS/iOS: Metal
• Roblox Studio: Vulkan-Support seit 2017
• Seit 2014 eigener nativer Renderer (vorher OpenGL), optimiert fuer Low-End-Hardware und Mobile
• "Enhanced Spatial Engine": Naechste Generation mit Real-Time Ray Tracing und KI-gesteuerter Optimierung

Beleuchtungssystem ("Future Is Bright")

Das Lighting-System ist eines der technisch interessantesten Teilsysteme:

• Voxel-basiertes Lighting: Jeder Voxel misst 4 Studs, inkrementell/lazy auf der CPU aktualisiert
• Shadow-Mapping: EVSM (Exponential Variance Shadow Maps) fuer weiche Schatten
• Per-Pixel-Lighting: Fuer lokale Lichtquellen (PointLight, SpotLight, SurfaceLight)
• Forward-Rendering Pipeline: Deferred Shading wurde evaluiert und verworfen -- zu viele transparente Objekte auf der Plattform
• Quality Level 3 und darunter: Fallback auf voxelisierte Beleuchtung fuer Performance

Physik-Engine

• Aktueller Solver: PGS (Projected Gauss-Seidel), laeuft bei 240 Hz
• Eigene Entwicklung -- kein ODE oder Bullet
• Historisch: Spring Physics (bis Maerz 2019), ein Articulated-Physics-Versuch 2013 (zu langsam, abgebrochen)
• Network Ownership: Jedes unverankerte Objekt hat einen "Network Owner" (Client), der die Physik berechnet. Kann manuell gesetzt werden (BasePart:SetNetworkOwner). nil = Server-exklusiv (Anti-Cheat)

1.2 Luau: Die Skriptsprache

Roblox hat aus Lua 5.1 eine eigene Sprache entwickelt: Luau (Open Source: github.com/luau-lang/luau).

Sprach-Features

• Gradual Typing: Optionales Typsystem mit automatischer Typinferenz
• Zwei Modi: Strict Mode (Fehler vor Runtime) und Non-Strict Mode (minimiert False Positives)
• Type Functions: Fortgeschrittenes Typsystem fuer komplexere Patterns
• Vollstaendig rueckwaertskompatibel mit Lua 5.1

Performance

Modus	Relative Performance
Luau Interpreter	~1x (Baseline)
LuaJIT (Interpreter)	~1x (vergleichbar)
LuaJIT (JIT)	~1.6x schneller
Luau Native Code Gen	1.5-2.5x schneller (seit Oktober 2023)

• Native Code Generation: Kompiliert Bytecode zu Maschinencode fuer x64 und ARM64
• Garbage Collector: Inkrementelles Design mit PID-Controller fuer Heap-Pacing (inspiriert vom Go GC), reduziert Pausenzeiten
• Compiler: Multi-Pass ueber AST, Bytecode-Erzeugung, Post-Process-Optimierungen (Function Inlining, Loop Unrolling)

Sandboxing

• VM kann selbst bei boesartigem Code nicht aus der Sandbox entkommen
• luaL_sandbox auf Global State + luaL_sandboxthread pro Script-Thread
• Globale Tabellen sind pro Script isoliert, Built-in-Libraries vor Monkey-Patching geschuetzt

1.3 Server-Infrastruktur

Skalierung

Die Zahlen sind beeindruckend:

Metrik	Wert
Server total	135.000+
Core Data Centers	2
Edge Data Centers	24
Container	170.000+
Peak CCU	30 Mio.+
Concurrent Connections	250 Mio.+
DAU	111,8+ Mio.

Orchestrierung: HashiCorp Stack (nicht Kubernetes!)

Roblox nutzt nicht Kubernetes, sondern den HashiCorp Stack:

• Nomad fuer Workload-Orchestrierung (gewaehlt ueber K8s, DC/OS, Docker Swarm -- Grund: unterstuetzt Windows + Linux Container und VMs)
• Consul fuer Service Discovery, automatisiertes Clustering, Service Mesh
• Vault fuer Secrets Management
• Setup-Zeit: Funktionierender Cluster + Bare-Metal-Deployment in 4 Tagen

Zellulaere Architektur

• Migration aller Services in "Cells" (wie Brandschutztueren -- Blast Radius containen)
• Jede Cell: ~1.400 Server
• Ganze Cells koennen repariert oder komplett neu provisioniert werden
• Cloud Bursting fuer Peak-Demand wird erprobt

Load Balancing

• "Roblox Load Balancer" (RLB): Basiert auf HAProxy Enterprise Docker Container
• HAProxy handhabt 2 Mio.+ RPS mit SSL/TLS auf einer einzigen Instanz
• WAF (Web Application Firewall) mit "ultra-low latency"
• Orchestriert mit Nomad, Service Discovery via Consul Template

Containerisierung

• Evolution: Bare Metal -> Linux-basiert -> Container
• Envoy Proxy Sidecars neben jedem Service
• eBPF-Experimente zur Beobachtung von Connection State zwischen Proxies
• Common Control Plane ueber Core und Edge Data Centers

1.4 Networking & Replikation

Client-Server-Modell

• FilteringEnabled (seit 2014, jetzt permanent): Client-Property-Aenderungen propagieren NICHT zum Server
• Client-zu-Server-Kommunikation ausschliesslich ueber RemoteEvents und RemoteFunctions
• Server repliziert Workspace und ReplicatedStorage automatisch zu Clients

Instance Streaming

• StreamingEnabled: Automatisches Streaming basierend auf Kamera-Position des Spielers
• StreamingTargetRadius kontrolliert Streaming-Reichweite; MinimumRadius als Buffer
• Mesh- und Texturdaten werden immer on-demand gestreamt, unabhaengig von StreamingEnabled
• Mesh Streaming: Engine-Level-System fuer dynamische Detail- und Memory-Verwaltung ueber verschiedene Geraete

1.5 Game Hosting (RCCService)

• RCCService: Server-Komponente seit 2008
• 2020 von Windows auf Ubuntu migriert, 2021 Windows komplett eingestellt
• Max Spieler pro Server: 200 (Standard), 700 (Beta seit Juli 2024), war vor 2019 nur 100
• Architektur: POPs (Points of Presence) mit Game-Servern + zentrale Data Centers fuer Services
• Bei Join: Routing zu existierendem Server oder Spawn eines neuen, wenn alle voll
• Ein NetworkReplicator pro verbundenem Spieler

1.6 Datenpersistenz

DataStoreService (Langzeit-Daten)

• Fuer Spielfortschritt, Inventar, Einstellungen
• Nur serverseitig zugaenglich (Sicherheit)
• 4 MB pro Key (frueher 256 KB), 30 Tage Versionshistorie
• Rate Limits: 25 MB Lese-Durchsatz / 4 MB Schreib-Durchsatz pro Key pro Minute
• Bekannte Zuverlaessigkeitsprobleme bei Peak-Traffic (Wochenenden, Feiertage)

MemoryStoreService (Kurzzeit-Daten)

• Hoher Durchsatz, niedrige Latenz (Leaderboards, Matchmaking-Queues)
• Daten verfallen nach maximal 45 Tagen
• Usage-Limit skaliert mit taeglichen Concurrent Players

1.7 Asset Pipeline & CDN

• Assets auf rbxcdn.com gespeichert mit Checksum-Hashes (Content-Addressable, Deduplizierung)
• CDN nutzt AWS CloudFront mit signierten URLs und Expiry-Timestamps
• Mesh Streaming (Early Access): Dynamische Detail- und Memory-Verwaltung ueber Geraete hinweg

1.8 KI & Moderation

Text-Filterung (Skalierung)

Metrik	Wert
Chat-Nachrichten/Tag	6,1 Milliarden
Peak RPS Text-Filtering	750.000+
BERT-Classifier Requests/Tag	1 Milliarde+
Median-Latenz	<20ms
PII-Filter Peak RPS	370.000

• BERT-basierter Classifier auf CPUs (nicht GPUs!) -- 30x Boost durch DistilBERT + Dynamic Shapes + Quantization
• 3.000 Inferences/sec auf Intel Xeon 36-Core vs. 500/sec auf Tesla V100 (CPU ist kosteneffizienter)
• PII-Filter: 30% weniger False Positives, 25% mehr PII erkannt

Voice-Moderation

• Sprachsicherheits-Classifier moderiert Chat innerhalb von 15 Sekunden in 8 Sprachen
• ASR-Transkription optimiert fuer Gaming-Sprache, dann Classifier-Analyse

Fortgeschrittene Systeme

• Sentinel: KI-System zur Erkennung von Kindesgefaehrdungsmustern (2025 open-sourced)
• Multi-modale Echtzeit-KI-Moderation: Analysiert Avatare, Text und Umgebungen zusammen
• 0,01% der Milliarden Interaktionen als Policy-Verstoss erkannt, fast alle entfernt vor User-Exposition
• Menschliche Moderatoren weltweit fuer Sarkasmus, kodierte Sprache, kulturellen Kontext

Matchmaking

• Evaluiert bis zu 4 Milliarden moegliche Join-Kombinationen pro Sekunde bei Peak

1.9 Roblox Studio

• Unified Interface fuer 3D-Weltenbau, Luau-Programmierung, Echtzeit-Kollaboration
• "Team Create": Echtzeit-Workspace-Sync, Live-Script-Editing
• Third-Party-Sync-Tools: Argon (VS Code Extension), RbxSync (MCP Integration)
• Batch Commits fuer Collaborative Editing

1.10 Der 73-Stunden-Ausfall (Oktober 2021)

• Root Cause: Consul Streaming Feature unter hoher Read/Write-Last + pathologisches BoltDB-Performance-Problem
• Ein einzelner Consul-Cluster fuer mehrere Workloads verstaerkte den Impact
• Monitoring-Systeme hingen vom selben fehlerhaften System ab -- keine Sichtbarkeit
• Loesung: HashiCorp + Roblox entwickelten BoltDB-Compaction-Prozess
• Konsequenz: Zellulaere Infrastruktur-Initiative + zusaetzliches Data Center

---

Teil 2: Wie man es heute mit modernster Technik bauen wuerde

2.1 Engine: Bevy (Rust) + wgpu -> WebGPU/WASM

Warum nicht Roblox' Ansatz kopieren?

Roblox' Custom C++-Engine ist ein 20 Jahre altes Projekt mit enormem technischen Schulden. Heute wuerde man Rust waehlen:

Empfehlung: Bevy ECS + wgpu

Bevy (Rust-basierte ECS Game Engine, 0.15+ ab Ende 2025):

Vorteil	Detail
Rust-Sicherheit	Keine Use-After-Free, keine Buffer Overflows, keine Data Races
ECS-Architektur	Entity Component System trennt Daten von Logik -- macht Sandboxing natuerlicher
WebGPU-Output	Kompiliert nativ zu WASM/WebGPU via wgpu
Cross-Platform	Eine Codebase fuer Browser, Desktop, Mobile
Performance	Rust-Level Performance ohne GC-Pausen

wgpu ist die Rendering-Abstraktion (benutzt auch von Firefox) und unterstuetzt:

• WebGPU im Browser
• Vulkan auf Linux/Android
• Metal auf macOS/iOS
• DirectX 12 auf Windows

Browser-Native: Der entscheidende Unterschied

Roblox erfordert einen nativen Client-Download. Mit WebGPU + WASM koennte eine neue Plattform direkt im Browser laufen:

• WebGPU: Shipped in Chrome 113 (2023), Firefox 141 (2025), Safari 18.2 -- ~70-75% Abdeckung
• WASM-Performance: Innerhalb von 10-20% nativer Performance fuer Compute-gebundene Arbeit
• Zero-Install: Kein Download, kein App Store -- massiv niedrigere Einstiegshuerde

Alternativen und warum nicht

Option	Bewertung
Godot 4	Maturer Editor, aber Architektur nicht fuer UGC-Sandboxing designed. WebGPU-Export experimentell. Gut fuers Prototyping, riskant fuer Produktion
Custom Engine auf wgpu	Maximale Kontrolle, maximaler Aufwand. Nur gerechtfertigt, wenn Bevy's Abstraktionen limitierend werden
Unity/Unreal	Zu schwer, zu teuer, Lizenzprobleme, nicht fuer UGC-Sandboxing gebaut

2.2 User-Scripting: WASM-Sandbox + TypeScript

Roblox' Ansatz: Luau

Luau funktioniert hervorragend fuer seinen Zweck, ist aber eine Nischen-Sprache. Die Community nutzt bereits roblox-ts (TypeScript-zu-Luau-Transpiler).

Moderner Ansatz: Duale Architektur

Client-Side: WASM Sandbox (Wasmtime)

• Hardware-Level-Sandboxing: Lineare Speicherisolation -- User-Code kann die Sandbox physisch nicht verlassen
• Fuel-basiertes Execution Metering: Instruktionslimits pro Frame verhindern Endlosschleifen
• WASI Preview 2 (Component Model): Typisierte Host-Guest-Interfaces
• User schreiben TypeScript, das zu WASM kompiliert wird. Kompilationslatenz: Sekunden -> "Compile and Hot-Reload"-Workflow
• Extism als Framework fuer WASM-Plugin-Systeme

Server-Side: V8 Isolates (Deno/workerd)

• Das Cloudflare-Workers-Modell: Startup in ~5ms, vertrautes JS-Oekosystem
• Fuer server-autoritative Logik, Matchmaking, Economy-Regeln
• V8 ist gross (~30 MB), hoehrer Memory-Overhead als WASM, unvorhersehbare GC-Pausen -- deshalb nur serverseitig

Visual Scripting Layer

• Knotenbasiert (wie Unreal Blueprints), kompiliert zu WASM
• Table Stakes fuer einen Roblox-Konkurrenten -- Kinder muessen Games ohne Code bauen koennen

Sicherheitsmodell

User-Code (TypeScript)
    |
    v
WASM-Compilation
    |
    v
Wasmtime Sandbox
  - Lineare Speicherisolation
  - Fuel Metering (Instructions/Frame)
  - Capability-based API Access (deklarierte Permissions)
  - Kein Dateisystem/Netzwerk-Zugriff

2.3 Server-Infrastruktur: Von Fly.io zu Agones

Roblox' Ansatz

• Eigene Data Centers + HashiCorp Nomad
• 135.000+ Server, zellulaere Architektur
• Funktioniert, aber enormer Ops-Aufwand

Moderner Ansatz: Gestaffelt

Tier 1 -- Leichtgewicht (<10 Spieler, einfache Logik):

• Fly.io Machines: Spin-up in ~300ms, 30+ Regionen, Pay-per-Second
• Volle Linux-Container (Rust/Go-Server direkt)

Tier 2 -- Medium (10-100 Spieler, Physik):

• Agones auf Kubernetes (GKE/EKS)
• Google/CNCF-Standard fuer Game-Server-Orchestrierung
• Handles: Allocation, Scaling, Health, Fleet Management
• Quilkin: Agones-Companion-Proxy fuer UDP Load Balancing, Telemetrie, Traffic Shaping
• Spot/Preemptible Instances fuer Kosteneffizienz

Tier 3 -- Heavy (100+ Spieler):

• Bare Metal oder Reserved Instances
• SpatialOS-aehnliche Entity-Distribution ueber mehrere Prozesse
• Fuer Massively-Multiplayer-Experiences

Weitere Komponenten:

Komponente	Technologie
Matchmaking	Open Match (Google, Open Source) oder custom
Fleet Management	Agones GameServerAllocation + Fly.io Machines API
State Persistence	Checkpoint zu Object Storage (S3/R2) alle N Sekunden
Global Routing	Anycast oder Latency-based DNS

Warum nicht Cloudflare Durable Objects?

• Starke Konsistenz innerhalb eines einzelnen Objekts
• Limitiert auf ~128 MB Memory, Single-threaded JS
• Nicht geeignet fuer physik-intensive Game-Server

2.4 Networking: WebTransport (QUIC)

Roblox' Ansatz

Custom binary protocol ueber TCP/UDP mit proprietaerem Replication-System.

Moderner Ansatz: WebTransport

WebTransport ueber HTTP/3 (QUIC) ist der klare Gewinner:

Feature	Vorteil
Unreliable Datagrams	Positionsupdates (kein Retransmit noetig)
Reliable Streams	Chat, Inventar, Transaktionen
Multiplexed	Kein Head-of-Line-Blocking (TCP-Problem)
0-RTT Connection	Sofortige Wiederverbindung

• Unterstuetzt in Chrome, Edge, Firefox (seit 114), Safari 18.2
• QUIC-Library: Quinn (Rust) -- integriert gut mit Bevy/Rust

State-Synchronisation

• Server-autoritativ mit Client-Side-Prediction (Standard)
• Interest Management: Spatial Hashing oder Grid-based AOI (Area of Interest) Culling
• ECS-Component-Level-Replikation: Transform bei 20 Hz unreliable, Health bei Aenderung reliable
• CRDTs: Nur fuer Collaborative/Creative Tools (Building, geteilte Inventare) -- NICHT fuer Physik/Kampf/Economy
• Rollback Netcode: Nur fuer kompetitive Fighting Games relevant; Standard Server-Auth + Prediction reicht

Fallbacks

• WebSocket: Reliable-only, TCP, Head-of-Line-Blocking -> nur als Fallback
• WebRTC: Nur fuer Voice Chat (Spatial Audio), zu komplex fuer Client-Server-Game-Traffic

2.5 Datenbank & Economy: TigerBeetle + PostgreSQL + Dragonfly

Roblox' Ansatz

DataStoreService (proprietaer, bekannte Zuverlaessigkeitsprobleme) + MemoryStoreService.

Moderner Ansatz: Spezialisierte Datenbanken

Virtuelle Economy: TigerBeetle

• Purpose-built fuer Financial Accounting
• 1 Mio.+ Transfers/Sekunde auf einem einzelnen Node mit strikter Serialisierbarkeit
• Double-Entry-Bookkeeping ins Datenmodell eingebaut (Debit + Credit pro Transfer)
• Keine "verlorenen" Robux, keine Race Conditions, keine Negative-Balance-Exploits

Account-Struktur:

Platform Treasury ("Zentralbank")
  |
  +-- User Wallets
  |     +-- Earned Currency (durch Spielen verdient)
  |     +-- Purchased Currency (gekauft)
  |
  +-- Game Revenue Accounts (pro veroeffentlichtem Spiel)
  |
  +-- Marketplace Escrow (Treuhand fuer Handel)
  |
  +-- Creator Payout Pending (ausstehende Auszahlungen)

Automatischer Revenue Split: 70% Creator / 30% Plattform (konfigurierbar) -- deutlich fairer als Roblox' ~24,5%.

User-Daten: PostgreSQL (Supabase)

• Bewaeherter Stack, kann spaeter zu CockroachDB migrieren fuer Multi-Region Write Consistency
• CockroachDB: Distributed SQL, Postgres-kompatibles Wire Protocol

Real-Time State: Dragonfly (Redis-kompatibel)

• Multi-threaded, speicher-effizienter als Redis
• Fuer: Player Presence, Matchmaking Queues, Leaderboards, Sessions, Pub/Sub
• Alternative: KeyDB (Multi-threaded Redis Fork, jetzt Teil von Snap)

Asset Storage: Cloudflare R2

• S3-kompatibel, null Egress-Kosten, globale Distribution
• Content-Addressable Storage wie Roblox (Hash-basiert, Deduplizierung)

2.6 KI-Integration: Was heute moeglich ist

LLM-gesteuerte NPCs

• Kleine Modelle (1-7B Parameter): Phi-3, Gemma 2, Llama 3.x bei 1-3B
• Inferenz: <100ms auf modernen GPUs
• Structured Generation (Outlines, LMFE): Beschraenkt Output auf valide Game-Actions/Schemas
• Server-Side Batch Inference: vLLM oder TensorRT-LLM. Ein A100 handhabt hunderte NPC-Konversationen
• Memory: Vector Store (Qdrant, Weaviate) pro NPC + RAG ueber Game-Lore/Regeln
• Kosten-Realitaet: LLM-NPCs sind teuer im Scale. Reservieren fuer Schluesselcharaktere -- Hintergrund-NPCs nutzen Behavior Trees

KI-Asset-Generierung

Asset-Typ	Technologie	Status
3D-Modelle	Meshy, Tripo, Rodin Gen-2	Text/Bild -> Mesh in Sekunden, Game-ready Low-Poly
Single Image -> 3D	InstantMesh / LRM-based	<10 Sekunden
Texturen	Stable Diffusion / FLUX	PBR-Textur aus Text, sehr ausgereift
Animationen	Motion Diffusion Models (MDM, MoMask)	Text -> Animation, braucht noch Cleanup

Automatische Pipeline:

KI generiert Mesh -> Auto-Retopology -> Auto-UV -> Auto-LOD -> Asset Store

KI-gestuetzte Spielerstellung

• Natural Language -> Game Logic: Claude/GPT-4-Klasse-Modelle mit gutem API-Kontext -- heute schon viable
• LLM-Autocomplete im Scripting-IDE
• KI-Playtesting: RL-Agenten erkennen automatisch Softlocks, Exploits, Balance-Probleme

KI-Moderation

• Multi-modale Modelle (Vision + Text) fuer Asset-, Chat- und Game-Content-Scanning
• Behavioral ML fuer Griefing-, Exploit- und Botting-Erkennung
• Echtzeit-Voice: Whisper-Transkription -> Text-Toxicity-Classification (~1-2 Sekunden Latenz)

2.7 3D/Grafik-Innovationen

Gaussian Splatting: Die Killer-UGC-Feature

• Echtzeit-Rendering bei 60fps auf Desktop-GPUs (2025-2026)
• Killer-Feature fuer UGC: Handy-Photogrammetrie-Scan -> Import als Game-Welt
• WebGPU kann via Compute Shaders rendern -- Open-Source WebGPU-Splat-Renderer existieren
• Limitation: View-dependent, interagiert schlecht mit traditionellem Lighting/Physik/Animation
• Empfehlung: Hybrid Rendering -- Mesh-basierte Charaktere + Gaussian-Splat-Umgebungen

Neural Rendering

• Neural Texture Compression: Hoehere Qualitaet als BC7 bei gleicher Bitrate (shipped in NVIDIA Ada GPUs)
• Neural LOD: Perzeptuell bessere Mesh-Decimation. Research-to-Production-Stadium

Nanite-aehnliche Geometry Virtualization

• Erfordert tiefes GPU-Wissen und Jahre Entwicklung -- nicht praktikabel fuer ein Startup
• Praktische Alternative: Aggressive LOD-Generierung + Meshlet-basiertes Rendering (Meshes in ~64-128 Triangle-Cluster teilen, GPU-per-Cluster-Culling)
• Machbar mit WebGPU Compute Shaders: 80% des Nutzens bei 10% des Aufwands

Ray Tracing auf Mobile

• Hardware-RT existiert auf Qualcomm Adreno, ARM Mali (limitiert auf Schatten/Reflektionen)
• WebGPU hat noch keine Ray-Tracing-APIs (Stand frueh 2026)
• Timeline: WebGPU RT experimentell in Chrome Ende 2026-2027. Praktisches Mobile-Browser-RT: 2027-2028
• Fuer jetzt: Screen-Space Reflections und Ambient Occlusion via WebGPU Compute

---

Teil 3: Was neue Technik ermoeglicht, das Roblox nicht kann

3.1 Zero-Install Browser-Experience

Roblox erfordert einen nativen Client-Download. Mit WebGPU + WASM koennte eine neue Plattform komplett im Browser laufen -- kein Download, kein App Store, kein Google/Apple-Gatekeeping. Ein Link reicht.

Impact: Massiv niedrigere Akquisitionskosten, sofortiger Zugang, einfacheres Teilen ("Schau dir mein Spiel an" -> ein Klick).

3.2 Groessere Welten

• WebGPU + WASM-Streaming-World-Loading mit Interest Management -> effektiv unbegrenzte Weltgroesse
• Prozedurale Generierung auf GPU via WebGPU Compute Shaders
• Roblox ist auf relativ kleine Welten limitiert

3.3 Mehr Spieler pro Instanz

Ansatz	Spieler
Roblox heute	200 (Standard), 700 (Beta)
Interest Management + ECS Replikation	200-500 machbar
SpatialOS-aehnliche Entity-Distribution	1.000+ (komplex)

3.4 Cross-Game-Inventare

Roblox hat nur Avatar-Items, die plattformweit funktionieren. Eine neue Plattform koennte:

• Plattform-Level Item-Archetypes definieren (Cosmetic Skin, Currency, Badge/Achievement)
• Games gewaehren diese; Games waehlen, welche Plattform-Items sie anerkennen
• TigerBeetle fuer Cross-Game-Currency; PostgreSQL-Metadaten-Registry fuer Item-Definitionen
• Kein Blockchain noetig -- Double-Entry-Bookkeeping mit TigerBeetle ist zuverlaessiger und schneller

3.5 User-generierte KI-Verhaltensweisen

Roblox-NPCs nutzen simple Skripte. Neu moeglich:

• Creator definieren NPC-Persoenlichkeit und Wissen in Natural Language
• LLM generiert dynamische Dialoge und Reaktionen
• NPCs, die sich an individuelle Spieler erinnern (Vector Store pro NPC)
• KI-gesteuerte Quests, die sich an den Spielstil anpassen

3.6 Voice-gesteuerte Spielerstellung

• Whisper/Deepgram STT + LLM: "Mach die Burg groesser und fuege einen Graben hinzu" -> modifiziert die Spielwelt in Echtzeit
• Kinder koennten Games durch Sprechen erstellen, nicht durch Code oder GUI
• WebRTC fuer Echtzeit-Spatial-Audio Voice Chat

3.7 Spatial Computing / AR

• WebXR + WebGPU ermoeglicht AR/VR UGC-Games im Browser (Meta Quest Browser unterstuetzt beides)
• Handy + LiDAR Scan -> Gaussian Splats -> editierbare Game-Welten
• Das eigene Kinderzimmer wird zum Game-Level
• Apple Vision Pro: "UGC-Spiele ueberlagert auf deinem Raum" -- kleiner Markt, Technologie bereit

3.8 On-Device KI

• WebNN (Web Neural Network API) shipped in Chrome -- ML-Modelle auf Device-GPUs/NPUs im Browser
• ONNX Runtime Web mit WebGPU-Backend laesst Phi-3 Mini interaktiv im Browser laufen
• Use Cases: Style Transfer, On-Device NPC Inference, Client-Side Moderation, Gesture Recognition
• Kein Server-Roundtrip noetig fuer bestimmte KI-Features

3.9 Fairere Creator-Economy

Roblox: ~24,5% fuer Entwickler. Mit moderner Infrastruktur:

• 70/30 Split (Creator/Plattform) wird moeglich weil:
  • Browser-Distribution eliminiert App-Store-Fees (Apple 30%, Google 30%)
  • Edge Computing und WASM-Sandbox reduzieren Server-Kosten pro Instanz
  • TigerBeetle fuer die Economy ist kosteneffizienter als proprietaere Systeme
• Transparente Echtzeit-Einnahmen-Dashboards statt monatelanger DevEx-Prozesse

---

Empfohlener Technology Stack (Zusammenfassung)

Layer	Technologie	Begruendung
Rendering	Bevy + wgpu -> WebGPU/WASM	Rust-Sicherheit, ECS, Browser + Native
Client Scripting	WASM Sandbox (TS -> WASM)	Hardware-Level-Isolation, Fuel Metering
Server Scripting	V8 Isolates (Deno)	Fast Startup, JS-Oekosystem
Game Server	Rust auf Fly.io -> Agones/K8s	Start einfach, skaliere zu Orchestrierung
Networking	WebTransport (QUIC) + WS Fallback	Unreliable Datagrams + Reliable Streams
QUIC Library	Quinn (Rust)	Native Rust, Async
User Data	PostgreSQL (Supabase) -> CockroachDB	Start bewaehrt, skaliere spaeter
Economy	TigerBeetle	Double-Entry-Bookkeeping, 1M+ TPS
Real-Time State	Dragonfly (Redis-kompatibel)	Multi-threaded, speicher-effizient
Asset Storage	Cloudflare R2	Null Egress, S3-kompatibel
KI NPCs	Phi-3, Gemma (kleine LLMs) + vLLM	Kosteneffizient, Structured Output
KI Assets	Meshy/Tripo + Custom Pipeline	Text/Bild -> Game-ready 3D
KI Code Gen	Claude API im Editor	Natural Language -> Scripts
Voice Chat	WebRTC (LiveKit)	Spatial Audio, skalierbar
Moderation	Multi-modale KI + Behavioral ML	Trust & Safety ist existenziell
3D Scanning	Gaussian Splatting Import	Handy -> Game-Welt

---

Empfohlene Build-Phasen (3-5 Jahre, 15-30 Engineers)

Phase 1: Core Engine (6-9 Monate)

Bevy + wgpu Rendering im Browser via WASM/WebGPU. Basic Multiplayer mit WebTransport.

Phase 2: Scripting Sandbox (3-6 Monate)

WASM TypeScript-Scripting. User erstellen einfache interaktive Experiences.

Phase 3: Creation Tools (6-9 Monate)

In-Browser World Editor mit Visual Scripting + Code Editor + KI Code-Generierung.

Phase 4: Economy (3-4 Monate)

TigerBeetle fuer virtuelle Waehrung. Marketplace fuer User-erstellte Assets.

Phase 5: Social + Scale (6-9 Monate)

Matchmaking, Friends, Voice Chat, Moderation. Migration zu Agones.

Phase 6: KI Features (6-12 Monate)

Asset-Generierungs-Pipeline, LLM-NPCs, Advanced Moderation.

Phase 7: Advanced Graphics (laufend)

Gaussian Splatting Import, Meshlet Rendering, Spatial Computing.

---

Entscheidendes Insight: "Distribution (Browser-nativ, Zero Install) und Creation Tools (einfaches Bauen von Games) sind wichtiger als Grafikqualitaet. Roblox' Grafik ist bescheiden -- sein Creation-Oekosystem hat es zu einem $40B+ Unternehmen gemacht."

---

Recherche-Datum: 28. Maerz 2026