Anmerkung des Autors: Saltline führt den Spielcode im Browser aus und lässt die lokale GPU des Spielers das Rendering übernehmen. Prozedurale Assets plus WebGL erklären, warum eine rund 1,4 MB große Webseitendatei eine vollständige 3D-Shooter-Szene darstellen kann.
Ein von KI erstelltes „3A-Spiel“ kann im Browser laufen – dafür gibt es drei Gründe. Erstens: Ein moderner Browser ist selbst eine komplette Laufzeitumgebung für 3D-Programme. JavaScript führt die Spiellogik aus, Three.js strukturiert die Szene, und WebGL übergibt die Zeichenarbeit an die GPU auf dem Rechner des Spielers. Zweitens: Was die KI in der Entwicklungsphase produziert, ist ein Spielprogramm. Nach Abschluss der Entwicklung läuft alles im Browser – beim Spielen werden keine KI-Modelle mehr aufgerufen. Drittens: Modelle, Texturen und Sounds in Saltline entstehen komplett per Code. Die einzelne HTML-Datei ist etwa 1,4 MB groß, Webseite öffnen und schon geht es ins Spiel.
Das „3A“ ist hier ein visuelles Ziel, das der Entwickler der KI vorgegeben hat, als Analogie zum Grafikstil. Saltline selbst ist ein kleiner, spielbarer Prototyp mit nur einem Level.
Im Folgenden gehen wir vom Fall Saltline aus und klären, wo das Spiel eigentlich läuft. Danach zerlegen wir die technische Kette, mit der der Browser 3D-Szenen rendert, und erklären, warum prozedurale Erzeugung die Datei auf 1,4 MB drücken kann. Anschließend stellen wir drei Wege gegenüber: lokales Ausführen im Browser, Cloud-Gaming und KI-Weltmodelle. Zum Schluss gibt es einen direkt ausführbaren Code, mit dem du per KI eine 3D-Webszene erzeugst und vermisst – dazu eine Diskussion darüber, wie weit Browser-Spiele und kommerzielle 3A-Titel tatsächlich auseinanderliegen.

Wissenswertes: Die Terminologie von KI-Web-3A-Spielen verstehen
| Begriff | Erklärung |
|---|---|
| JavaScript | Eine vom Browser ausgeführte Programmiersprache; die Spiel-Logik von Saltline ist genau damit geschrieben |
| Three.js | Eine JavaScript-3D-Grafikbibliothek zum Aufbauen von Szenen, Kameras, Lichtern und Objekten |
| WebGL | Eine vom Browser bereitgestellte Grafik-Schnittstelle, die es Webseiten erlaubt, die GPU des Geräts zum Zeichnen von 3D-Bildern zu nutzen |
| WebGPU | Eine neue Generation von Browser-Schnittstelle für Grafik und Compute mit moderneren Fähigkeiten; Saltline verlässt sich jedoch nicht darauf |
| WebAssembly (Wasm) | Ausführbarer Low-Level-Bytecode im Browser, der Programme wie C++ oder Rust mit hoher Geschwindigkeit im Web laufen lässt |
| GPU | Grafikprozessor, der gut darin ist, viele Pixel und Vertices gleichzeitig in parallelen Berechnungen zu verarbeiten |
| Shader | Ein kleines Programm, das auf der GPU läuft und die Position jedes Vertices oder die Farbe jedes Pixels berechnet |
| Prozedurale Generierung | Mit Regeln und mathematischen Funktionen Spielinhalte erzeugen, anstelle vorab erstellter Bild- und Modelldateien |
| Instancing (instanzierte Darstellung) | Mit einem einzigen Draw-Call eine große Menge gleich geformter Objekte zeichnen, zum Beispiel Reihen von Containern |
| Frame-Zeit | Die Zeit, die zum Rendern eines Frames benötigt wird; 60 FPS entsprechen etwa 16.67 Millisekunden pro Frame |
| Cloud-Gaming | Das Spiel läuft auf einem entfernten Server und das Bild wird als Videostream an den Spieler übertragen |
| WebRTC | Echtzeit-Technik für Audio- und Videoübertragung im Browser; Cloud-Gaming nutzt sie häufig, um Bild und Eingaben zu übertragen |
| Weltmodell | Ein KI-Modell, das die Regeln der Veränderung einer Umgebung lernt und auf Basis von Spieler-Eingaben nachfolgende Szenen vorhersagt und generiert |
1 Warum ein von KI erstelltes AAA-Spiel nur einen Browser braucht: am Beispiel Saltline
1.1 Was für ein KI-Webspiel ist Saltline?
Am 9. November 2026 veröffentlichte der Anthropic-Ingenieur Felix Rieseberg ein Programmierexperiment mit Claude Fable 5.2. Er gab dem Modell nur eine einzige Eingabeaufforderung: Es sollte einen kleinen First-Person-Shooter bauen, dessen Optik so nah wie möglich an ein AAA-Spiel heranreicht – und zwar ohne menschliches Feedback während des gesamten Prozesses. Das Ergebnis war Saltline.
Der Schauplatz ist ein Containerhafen in einer regnerischen Nacht, mit Lagerhäusern, Kais und gestapelten Containern. Die Spieler müssen drei Signalrelais abschalten und sich dann absetzen. Zu den Gegnern gehören patrouillierende Drohnen in der Luft und mechanische Hunde am Boden. Das Spiel unterstützt Bewegung aus der Ich-Perspektive, Kamerasteuerung, Schießen, Interaktion und Missionsziele; dazu kommen Regen, Licht, Umgebungsgeräusche und Waffeneffekte. Die Seite bietet Einstellungen für die Grafikqualität, darunter eine Option für niedrige Qualität.
Laut eigener Darstellung des Entwicklers auf X dauerte das Experiment etwa 8 Stunden. Die nach API-Preisen geschätzten Kosten lagen bei rund 550 US-Dollar; verbraucht wurden etwa 445 Millionen Input-Token (davon ein großer Teil aus dem Cache) und etwa 2,7 Millionen Output-Token. Diese Zahlen sind vom Entwickler berichtete Schätzungen und keine von Dritten geprüften Abrechnungen.
Die später auf chinesischen Social-Media-Plattformen kursierende Bezeichnung „JiMao · inländischer AAA-Blockbuster“ ist die chinesische Version bzw. eine neu verpackte Fassung von Saltline; „inländischer AAA-Blockbuster“ war der Name, der sich bei der Verbreitung einbürgerte.
1.2 In einer einzigen 1,4-MB-Datei steckt das komplette Spiel im AAA-Stil
Die eigenständige HTML-Version von Saltline besteht aus nur einer index.html. Die im GitHub-Repository verzeichnete Größe beträgt 1.425.707 Bytes, also etwa 1,43 MB (1,36 MiB). In dieser Datei steckt der Kerncode, den das Spiel zum Laufen braucht; auch der Three.js-Laufzeitcode ist mit eingebunden. Es gibt keine separaten 3D-Modelle, Texturen oder Sounddateien.
Zum Vergleich: Bei klassischen 3D-Spielen stecken im Installationspaket normalerweise jede Menge Modelle, hochauflösende Texturen, Animationen, Soundeffekte und Szenendaten. Saltline ersetzt all diese Assets durch „Code, der die Assets erzeugt“ – das ist die eigentliche Ursache für die geringe Größe. Abschnitt 3 erklärt das genauer.
1.3 Saltline läuft tatsächlich auf dem Gerät der Spieler
KI ist nur in der Entwicklungsphase beteiligt. Der GitHub-Mirror von Saltline macht das deutlich: Die Originalfassung ist ein Claude Artifact. Beim Portieren wurde das Laufzeitskript des Artifact-Frameworks entfernt, der Spielcode blieb erhalten, DOCTYPE-, Zeichensatz- und Viewport-Deklarationen wurden ergänzt – danach lässt sich das Ganze mit einem lokalen HTTP-Server starten.
Das bedeutet, dass die Spiellogik vollständig von der Claude-Chat-Oberfläche getrennt ist. Wenn die Spieler die Webseite öffnen, liest der Browser das HTML, führt JavaScript aus, initialisiert WebGL, und die lokale GPU rendert jedes Frame. Am gesamten Ablauf ist kein KI-Modell an der Inferenz beteiligt.
Ein Detail am Rande: In der Beschreibung des Mirrors heißt es, dass die Schriften nach wie vor von Google Fonts geladen werden. Genauer gesagt: Der Kern des Spiels läuft lokal, Szene, Texturen und Sound werden von lokalem Code erzeugt – nur bei den Schriften gibt es eine externe Ladeabhängigkeit.
2 Wie der Browser zur 3D-Laufzeitumgebung für KI-AAA-Spiele wird
Ein moderner Browser kann HTML parsen, aber auch Grafik-Schnittstellen ansprechen, performanten Code ausführen, Speicher verwalten und Audio sowie Video verarbeiten. Saltline nutzt daraus eine der gängigsten Kombinationen: JavaScript + Three.js + WebGL.
2.1 JavaScript übernimmt die Logik des Browserspiels
JavaScript ist das „Gehirn“ des Spiels. Wo Gegner patrouillieren, ob eine Kugel trifft, ob eine Relaisstation abgeschaltet wurde und ob der Spieler evakuieren kann – all diese Regeln stehen als JavaScript-Code da und werden von der JavaScript-Engine des Browsers auf der CPU ausgeführt.
Für rechenintensivere Aufgaben bietet der Browser zusätzlich WebAssembly. Wenn Engines wie Unity eine Web-Version exportieren, kompilieren sie einen Teil des Programms zu WebAssembly, um die Ausführung zu beschleunigen. WebAssembly übernimmt die Programmausführung, das Rendern der Grafik läuft weiterhin über WebGL – beide arbeiten Hand in Hand. Saltline setzt für die Spiellogik hauptsächlich auf JavaScript.
2.2 Three.js organisiert 3D-Szenen
Eine 3D-Szene direkt mit WebGL zu programmieren, bedeutet, sich mit vielen Low-Level-Details auseinanderzusetzen. Three.js kapselt diese Details in intuitive Objekte:
- Scene: Szenencontainer, der alle Objekte und Lichter enthält
- Camera: Kamera – in einem First-Person-Spiel die Augen des Spielers
- Geometry: Geometrie, die die Form von Containern und Lagerhallen definiert
- Material: Material, das bestimmt, ob eine Oberfläche wie Metall oder Beton aussieht
- Mesh: das sichtbare Objekt aus Geometrie und Material
- Light: Licht – Straßenlaternen und Warnleuchten im regnerischen Hafen bei Nacht
- Renderer: Renderer, der die obigen Inhalte an die GPU zum Zeichnen übergibt
Die offizielle Beispielbibliothek von Three.js zeigt außerdem Funktionen wie Skelettanimation, Shadow Mapping, Post-Processing-Effekte und Instanced Rendering. Besonders Instancing ist für die Hafenszene nützlich: Hunderte oder Tausende ähnlicher Container können eine gemeinsame Geometrie verwenden, wobei nur Position und Farbparameter geändert werden. So lässt sich alles mit einem einzigen Draw Call zeichnen, was den Browser deutlich entlastet.
2.3 WebGL überträgt die Zeichenarbeit an die lokale GPU
WebGL ist eine Grafiksschnittstelle, die der Browser JavaScript zur Verfügung stellt und die auf Technologien rund um OpenGL ES aufbaut. Der Ablauf ist denkbar direkt: Der Spielcode ruft über JavaScript WebGL auf, WebGL schickt die Zeichenbefehle an die GPU, die GPU berechnet das Bild, und der Browser zeigt es auf der Seite an.
Entscheidend ist dabei: Diese GPU ist die Grafikkarte im Rechner des Spielers. Jedes einzelne Frame von Saltline wird auf dem Gerät des Spielers berechnet – das Netzwerk ist nur dafür zuständig, die 1,4 MB große Datei anfangs in den Browser zu bringen. Genau deshalb empfiehlt die offizielle Saltline-Seite Spielern, die im Ladebildschirm hängen bleiben, WebGL 2 und die Hardwarebeschleunigung des Browsers zu prüfen.
2.4 Shader, Materialien und Beleuchtung bestimmen das Aussehen einer 3D-Szene
Das Aussehen einer 3D-Szene ergibt sich aus vier Zutaten: Das Modell liefert die Form, das Material die Oberflächeneigenschaften, die Beleuchtung das Hell-Dunkel, und der Shader verrechnet all das zum endgültigen Pixelfarbwert.
Shader laufen auf der GPU und teilen sich in zwei Arten. Der Vertex-Shader berechnet die Position jedes Eckpunkts auf dem Bildschirm, der Fragment-Shader die Farbe jedes Pixels. Am Beispiel eines Containers in einer Regennacht kann der Fragment-Shader die Streifen des Wellblechs, Rostflecken und die Reflexionen der nassen Oberfläche per mathematischer Funktion berechnen – ganz ohne eine vorab gezeichnete Textur.
2.5 Die Game Loop für Browserspiele: Eingaben verarbeiten und das Bild kontinuierlich neu zeichnen
Der Unterschied zwischen einem Spiel und einer statischen Webseite besteht darin, dass das Spiel Dutzende Male pro Sekunde neu gezeichnet wird. Der Browser stellt die Schnittstelle requestAnimationFrame bereit, die den Spielcode vor jeder Bildschirmaktualisierung aufruft und so die Game Loop bildet:
- Tastatur-, Maus- oder Touchscreen-Eingaben einlesen (bei Saltline muss man auf den Spielbereich klicken, um die Maussteuerung zu erhalten)
- Spielzustand aktualisieren: Spielerposition, Gegnerverhalten, Flugbahnen der Projektile
- Den Three.js-Renderer aufrufen, damit die GPU über WebGL ein neues Frame zeichnet
- Der Browser zeigt das Bild an und wartet auf die nächste Aktualisierung

3 Warum 1,4 MB eine komplette Szene im 3A-Stil erzeugen können: prozedurale Generierung
3.1 Modelle, Texturen und Sound werden als Funktionen geschrieben
Felix Rieseberg ergänzte am 10. November, dass sämtliche Inhalte im Spiel Code sind: Texturen und Modelle sind Funktionen, es gibt keine separaten Bilddateien oder 3D-Modell-Assets. Claude erzeugt den Code und die Shader, mit denen diese Inhalte aufgebaut werden.
Im Vergleich zum traditionellen Vorgehen wird der Unterschied sofort deutlich:
- Texturen: Herkömmlich wird ein Container-Texturbild heruntergeladen und aufgeklebt; prozedural werden Metalloberflächen mit Rauschfunktionen, Farbvariationen und Shadern in Echtzeit berechnet
- Modelle: Herkömmlich wird eine in der Modellierungssoftware fertig gebaute Modelldatei importiert; prozedural werden Geometrien zur Laufzeit aus Vertices und Geometrieparametern konstruiert
- Sound: Herkömmlich werden aufgenommene Audiodateien geladen; prozedural wird der Klang über die Audio-Schnittstelle des Browsers in Echtzeit synthetisiert
In der Datei sind die „Erzeugungsregeln“ gespeichert, das endgültige Bild wird erst zur Laufzeit berechnet. Regeln sind in der Regel viel kleiner als das Ergebnis: Ein Shader mit ein paar Dutzend Zeilen deckt bereits die Bodenfläche eines ganzen Hafens ab.
3.2 Dateigröße, Arbeitsspeicher und Rechenlast auseinanderhalten
Um die 1,4 MB zu verstehen, muss man drei Begriffe getrennt betrachten:
| Begriff | Was gemessen wird | Situation bei Saltline |
|---|---|---|
| Dateigröße | Wie viel Code und Ressourcen heruntergeladen werden müssen | etwa 1,4 MB, sehr leicht zu verteilen |
| Arbeitsspeicher | Wie viel RAM und Grafikspeicher zur Laufzeit belegt werden | Die Szene entsteht zur Laufzeit, offizielle Zahlen liegen nicht vor |
| Rechenlast | Wie viel Arbeit CPU und GPU pro Frame erledigen | Hängt von Qualitätseinstellungen und Gerät ab, offizielle Zahlen liegen nicht vor |
| Initialisierungszeit | Zeit vom Öffnen der Seite bis zur Bedienbarkeit | Laut offizieller Angabe müssen Hafen, Lagerhallen, Licht und Sound aufgebaut werden; die Dauer hängt vom Gerät ab |
Prozedurale Generierung tauscht „Rechenzeit zur Laufzeit“ gegen „Downloadvolumen“. Ein Programm von 1,4 MB kann zur Laufzeit enorme Mengen an Geometrie, Materialien und Texturen erzeugen – die GPU muss trotzdem in jedem Frame eine Menge Shader-Berechnungen erledigen. Die offizielle Saltline-Seite weist auch ausdrücklich darauf hin, dass der Zeitpunkt, an dem der START-Button erscheint, vom Gerät des Spielers abhängt und man bei Ruckeln auf die „Low“-Grafikqualität umschalten kann.

3.3 Die Einzeldatei-Architektur macht die Verteilung extrem leicht
Der Wert einer Single-File-HTML liegt in der Verteilung. Sie lässt sich auf jedem beliebigen statischen Hosting-Dienst ablegen oder lokal herunterladen und mit einem HTTP-Server öffnen; zum Teilen genügt ein Link. Das GitHub-Repository der chinesischen Version von „几猫“ bietet direkt einen Einstieg zum Online-Ausprobieren und zum Download und weist darauf hin, dass das Spiel auch offline läuft (mit Ausnahme des Ladens der Schriften).
Diese Form ist besonders freundlich zu KI-generierten Prototypen. Das Modell gibt in einem Durchgang eine komplette Datei aus, Entwickler müssen sich weder mit Asset-Pipelines noch mit Build-Tools oder Serverkonfiguration beschäftigen – nach der Generierung kann man sie sofort an andere zum Ausprobieren schicken.
4 Drei verschiedene Wege, 3A-Spiele im Web laufen zu lassen
Hinter „Spielen im Web“ stehen drei technische Ansätze, deren Rechenweise sich grundlegend unterscheidet. Wer diese drei Wege klar auseinanderhält, versteht Saltline richtig.
4.1 Lokale Ausführung im Browser: Saltlines Weg
Die KI erzeugt Code, dieser Code wird an den Spieler ausgeliefert, und der Browser führt die Logik lokal aus und rendert die Grafik mit der lokalen GPU. Den Hauptteil der Berechnung übernimmt das Gerät des Spielers; beim Spielen ist keine Verbindung zum KI-Modell nötig, und nach dem Herunterladen der Dateien ist auch ein Offline-Betrieb möglich. Der Preis dafür: Die Performance hängt vollständig vom Gerät und vom Browser des Spielers ab.
4.2 Cloud-Gaming: Der Weg von GeForce NOW und Pixel Streaming
Das Spiel läuft auf einem entfernten Server, die Cloud-GPU rendert das Bild, und dieses wird als Videostream zum Browser übertragen. Der Browser ist nur dafür zuständig, das Video anzuzeigen, den Ton abzuspielen und die Spielereingaben zurück an den Server zu schicken.
Pixel Streaming von Epic Games lässt Unreal-Engine-Anwendungen in der Cloud oder auf einem entfernten Rechner laufen und überträgt Bild und Ton per WebRTC zum Browser. NVIDIA GeForce NOW ist ein Cloud-Gaming-Dienst für Spieler; die offiziell veröffentlichten Netzwerkanforderungen für den Browser lauten: mindestens 15 Mbps für 720p/60FPS, mindestens 25 Mbps für 1080p/60FPS und mindestens 35 Mbps für 1440p/120FPS, empfohlene Latenz unter 80 ms. Dieser Ansatz senkt die Einstiegshürde bei der lokalen Hardware – der Preis dafür ist eine ständige Abhängigkeit vom Netzwerk.
4.3 KI-Weltmodelle: Der Weg von Genie 3
Ein Weltmodell legt Szenen und Regeln nicht im Voraus fest, sondern sagt auf Basis des aktuellen Zustands und der Spielereingaben den nächsten Bildabschnitt voraus und erzeugt ihn. Im August 2025 veröffentlichte Google DeepMind Genie 3; laut offiziellen Angaben kann es in Echtzeit erkundbare Umgebungen in 720p mit bis zu 24FPS generieren, wobei die Szenenkonsistenz mehrere Minuten lang erhalten bleibt. Auch Microsofts Muse/WHAMM und Decarts Oasis erkunden diesen Weg.
Im Januar 2026 wurde Project Genie auf Basis von Genie 3 für erste Erfahrungen geöffnet – zunächst für Google AI Ultra-Abonnenten ab 18 Jahren in den USA, mit einem Limit von 60 Sekunden pro generierter Sitzung. Dieser Ansatz befindet sich derzeit im Forschungs- und Prototypenstadium und hat nichts mit der Technologie zu tun, die Saltline verwendet.
4.4 Vergleich der drei Ansätze

| Vergleichsdimension | Lokale Web-Ausführung | Cloud-Gaming | KI-Weltmodell |
|---|---|---|---|
| Repräsentative Beispiele | Saltline | GeForce NOW, Pixel Streaming | Genie 3 |
| Spiellogik | Lokal vorab geschriebener Code wird ausgeführt | In der Cloud vorab geschriebener Code wird ausgeführt | Modell lernt die Umgebungsdynamik aus Daten |
| Bildgenerierung | Lokales GPU-Rendering | Cloud-GPU-Rendering | KI-generiert in Echtzeit |
| Rolle des Browsers | Spielumgebung | Video- und Interaktionsendgerät | Interaktionsschnittstelle |
| Netzwerkabhängigkeit | Nach dem ersten Laden weitgehend offline nutzbar | Dauerhafte Internetverbindung, hohe Bandbreite und niedrige Latenz erforderlich | In der Regel dauerhafte Internetverbindung erforderlich |
| Lokale Hardwareanforderungen | Relativ hoch | Relativ niedrig | Abhängig von der Art der Modellbereitstellung |
| Zeitpunkt der KI-Kosten | Konzentriert auf die Entwicklungsphase | Keine KI-Inferenz, kontinuierlicher Verbrauch von Cloud-GPUs | Kontinuierliche Inferenz bei jedem Spielen |
Die Kostenstruktur ist der praktischste Unterschied zwischen den drei Ansätzen. Saltline bündelt die KI-Kosten in einer einzigen Entwicklungsphase; danach übernimmt das Gerät des Spielers das Rendering, sodass die geschätzten Kosten von 550 US-Dollar nicht mit der Spielerzahl wachsen. Cloud-Gaming und Weltmodelle verbrauchen dagegen bei jedem Spielen kontinuierlich Serverrechenleistung.
5 Praktische Umsetzung: Eine 3D-Webszene mit KI erzeugen und ausführen
Der schnellste Weg, die Grundlagen zu verstehen, ist, es selbst einmal durchzuspielen. Dieser Abschnitt ist in drei Schritte gegliedert: Zuerst führen wir eine handgeschriebene prozedurale Szene aus, dann lassen wir mithilfe der API ein Großes Sprachmodell ein Spiel als einzelne Datei generieren, und schließlich messen wir dessen Frame-Zeit.
5.1 Eine minimal lauffähige prozedurale Three.js-Szene
Die folgende Datei zeichnet mit Instancing 400 Container. Die Wellblechstreifen und Rostflecken jedes Containers werden vollständig vom Shader in Echtzeit berechnet – ganz ohne Bilddateien. Speichern Sie die Datei als index.html, führen Sie im selben Verzeichnis python3 -m http.server 8000 aus und öffnen Sie anschließend http://localhost:8000 im Browser.
<!DOCTYPE html>
<html lang="zh">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Prozeduraler Containerhafen</title>
<style>body{margin:0;overflow:hidden;background:#05070a}</style>
<script type="importmap">
{ "imports": { "three": "https://unpkg.com/[email protected]/build/three.module.js" } }
</script>
</head>
<body>
<script type="module">
import * as THREE from 'three';
const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(innerWidth, innerHeight);
document.body.appendChild(renderer.domElement);
const scene = new THREE.Scene();
scene.fog = new THREE.Fog(0x05070a, 20, 90);
const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 0.1, 200);
// Prozedurales Material: Wellblech-Sicken + verrauschte Rostflecken + einfaches Richtungslicht
const material = new THREE.ShaderMaterial({
uniforms: { uTime: { value: 0 } },
vertexShader: `
varying vec2 vUv; varying vec3 vNormal; varying vec3 vColor;
void main() {
vUv = uv;
vNormal = normalize(mat3(modelMatrix * instanceMatrix) * normal);
vColor = vec3(1.0);
#ifdef USE_INSTANCING_COLOR
vColor = instanceColor;
#endif
gl_Position = projectionMatrix * viewMatrix * modelMatrix * instanceMatrix * vec4(position, 1.0);
}`,
fragmentShader: `
varying vec2 vUv; varying vec3 vNormal; varying vec3 vColor;
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
void main() {
float ribs = 0.75 + 0.25 * step(0.5, fract(vUv.x * 14.0)); // Wellblech-Sicken
float rust = smoothstep(0.82, 1.0, hash(floor(vUv * 40.0))); // Rostflecken
vec3 base = mix(vColor * ribs, vec3(0.35, 0.18, 0.08), rust);
float light = max(dot(vNormal, normalize(vec3(0.4, 1.0, 0.3))), 0.15);
gl_FragColor = vec4(base * light, 1.0);
}`
});
// Instancing: 400 Container in einem einzigen Draw-Call
const count = 400;
const mesh = new THREE.InstancedMesh(new THREE.BoxGeometry(6, 2.6, 2.4), material, count);
const m = new THREE.Matrix4(), c = new THREE.Color();
const palette = [0x8a2b1e, 0x1f4e79, 0x2f6b3a, 0x9a7b1c];
for (let i = 0; i < count; i++) {
const x = (i % 20) * 7 - 70, z = Math.floor(i / 20) * 4 - 40;
const y = 1.3 + Math.floor(Math.random() * 3) * 2.6;
m.makeTranslation(x, y, z);
mesh.setMatrixAt(i, m);
mesh.setColorAt(i, c.set(palette[i % palette.length]));
}
scene.add(mesh);
// Game-Loop: Kamera pro Frame aktualisieren und rendern
renderer.setAnimationLoop((t) => {
const s = t * 0.0001;
camera.position.set(Math.sin(s) * 50, 18, Math.cos(s) * 50);
camera.lookAt(0, 0, 0);
renderer.render(scene, camera);
});
addEventListener('resize', () => {
camera.aspect = innerWidth / innerHeight;
camera.updateProjectionMatrix();
renderer.setSize(innerWidth, innerHeight);
});
</script>
</body>
</html>
Dieser Code verdichtet die Kernidee von Saltline: Die Geometrie entsteht aus BoxGeometry, das Aussehen berechnet der Shader, und massenhaft wiederholte Objekte werden per Instancing gezeichnet. Die ganze Datei ist nur wenige KB groß, Three.js wird vom CDN geladen – Saltline hingegen packt Three.js direkt in die HTML-Datei.
5.2 Mit der API ein Großes Sprachmodell ein 3D-Spiel als Single-File-Datei generieren lassen
Saltlines Generierungsprozess ist ein langwieriges, mehrstufiges agentisches Programmieren, das hunderte Millionen Token verbraucht. Wer als Einzelentwickler anfängt, kann mit einem einzigen Aufruf starten und das Modell ein lauffähiges Three.js-Minispiel als eine einzige Datei ausgeben lassen – so lässt sich die Arbeitsteilung „KI schreibt das Programm, der Browser führt es aus“ direkt erleben. Der folgende Code verwendet eine OpenAI-kompatible Schnittstelle; der Modellname sollte durch ein Modell aus der Modellliste der Plattform ersetzt werden, das lange Codeausgaben unterstützt.
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # OpenAI-kompatible Schnittstelle von APIYI
)
resp = client.chat.completions.create(
model="YOUR_MODEL_NAME", # richtet sich nach der Modellliste der Plattform
messages=[{"role": "user", "content": "用 Three.js 写一个单文件 HTML 第一人称小游戏,所有模型和纹理用代码与 Shader 生成,只输出完整 HTML。"}],
)
open("game.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
Vollständigen Implementierungscode ansehen (inkl. Codeblock-Bereinigung und Vorgaben für die Eingabeaufforderung)
import re
import openai
from pathlib import Path
SYSTEM_PROMPT = """你是一名资深 Web 3D 游戏工程师。
要求:
1. 只输出一个完整的 HTML 文件,不要任何解释文字。
2. 使用 Three.js(通过 importmap 从 CDN 引入 [email protected])。
3. 不引用任何外部图片、模型或音频文件;几何体用代码构造,纹理用 ShaderMaterial 计算,音效用 Web Audio API 合成。
4. 使用 requestAnimationFrame 或 renderer.setAnimationLoop 实现游戏循环。
5. 提供 Low / High 两档画质切换,Low 档降低像素比和物体数量。
6. 点击画面后使用 Pointer Lock 获取鼠标控制,WASD 移动。
"""
def extract_html(text: str) -> str:
"""Entfernt die möglicherweise vom Modell hinzugefügten Markierungen des ```html-Codeblocks"""
match = re.search(r"```(?:html)?\s*(.*?)```", text, re.S)
return (match.group(1) if match else text).strip()
def generate_game(idea: str, model: str, out_file: str = "game.html") -> Path:
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1"
)
resp = client.chat.completions.create(
model=model,
messages=[
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": idea},
],
max_tokens=16000,
)
html = extract_html(resp.choices[0].message.content)
path = Path(out_file)
path.write_text(html, encoding="utf-8")
print(f"已生成 {path},大小 {path.stat().st_size / 1024:.1f} KB")
print("运行:python3 -m http.server 8000,然后打开 http://localhost:8000/" + out_file)
return path
if __name__ == "__main__":
generate_game(
idea="雨夜集装箱港口,玩家需要关闭三个信号塔后撤离,有巡逻无人机。",
model="YOUR_MODEL_NAME",
)
Die erzeugte Datei folgt derselben Ausführungslogik wie Saltline: Der API-Aufruf findet nur bei der Generierung statt. Wenn Sie danach game.html öffnen und spielen – egal wie oft –, entstehen keine weiteren Modellkosten.
🚀 Tipp für den schnellen Einstieg: Wenn Sie die Ergebnisse verschiedener Modelle beim Schreiben von Three.js-Spielen vergleichen möchten, können Sie über APIYI apiyi.com mit demselben API-Schlüssel zwischen Modellen wie Claude, GPT und Gemini wechseln. Die Schnittstelle ist OpenAI-kompatibel, im obigen Code muss nur der Parameter
modelgeändert werden. Neue Nutzer erhalten ein kostenloses Testkontingent – ideal, um mit einer kurzen Eingabeaufforderung zunächst die Qualität der Generierung zu prüfen.
5.3 Die tatsächliche Leistung von Browser-3D-Spielen messen
1,4 MB beantworten nur die Frage, wie schnell der Download war. Ob ein Browserspiel flüssig läuft oder nicht, lässt sich erst anhand der folgenden Kennzahlen beurteilen:
| Kennzahl | Messziel | Messmethode |
|---|---|---|
| Zeit bis zur ersten Bedienbarkeit | Starterlebnis | Von der Seiteneröffnung bis zur Charaktersteuerung; lässt sich mit der Performance API per Time-Mark erfassen |
| FPS / Frame-Zeit | Flüssigkeit und Stabilität | 60 FPS entsprechen etwa 16,67 ms pro Frame; auf Schwankungen der Frame-Zeit achten |
| CPU-Auslastung | Last der Spiellogik | Hauptthread im Performance-Panel der Chrome DevTools beobachten |
| GPU-Auslastung und VRAM | Rendering-Last | Task-Manager des Systems oder GPU-Überwachungstools |
| Systemspeicher | Ressourcen zur Laufzeit | Nach abgeschlossener Szenen-Initialisierung den Speicher des Browserprozesses beobachten |
| Netzwerkverkehr nach dem Laden | Externe Abhängigkeiten | Network-Panel der DevTools; Anfragen für Schriftarten, Programmcode usw. auseinanderhalten |
Wenn du den folgenden Code in die Browser-Konsole einfügst, ermittelst du die durchschnittliche Frame-Zeit und den langsamsten Frame innerhalb von 10 Sekunden:
(() => {
const times = []; let last = performance.now();
const start = last;
function tick(now) {
times.push(now - last); last = now;
if (now - start < 10000) return requestAnimationFrame(tick);
const avg = times.reduce((a, b) => a + b, 0) / times.length;
const worst = Math.max(...times);
console.log(`平均帧时间 ${avg.toFixed(2)}ms(约 ${(1000 / avg).toFixed(1)} FPS),最慢一帧 ${worst.toFixed(2)}ms`);
}
requestAnimationFrame(tick);
})();
Beim Testen sollten Browser-Version, Betriebssystem, Gerätemodell, Auflösung und Qualitätsstufe fest vorgegeben sein. Die Messung sollte Szenarien abdecken, in denen der Spieler sich bewegt, Gegner aktiv sind, geschossen wird und gleichzeitig Regeneffekte dargestellt werden. Misst man nur die leere Szene direkt nach dem Start des Spiels, erhält man zu optimistische Werte.
6 Wie weit sind Web-3A-Spiele noch von echten kommerziellen 3A-Titeln entfernt?
6.1 Hardware- und Plattformbeschränkungen für Browserspiele
Die offizielle Unity-Dokumentation beschreibt die Einschränkungen der Web-Plattform recht deutlich: eingeschränkter Dateisystemzugriff, einige Caching-Funktionen sind nicht verfügbar, Multithreading ist an die Browserumgebung gebunden, die Speicherressourcen sind begrenzt und die Kompatibilität zwischen den Browsern unterscheidet sich. Unitys WebGL-Builds richten sich in erster Linie an Desktop-Browser; die Unterstützung auf Mobilgeräten ist begrenzt.
Die Erlebnisseite von Saltline bestätigt diese Einschränkungen. Die Seite weist darauf hin, dass die Initialisierung langsam sein kann, die Startgeschwindigkeit von der Geräteleistung abhängt, WebGL 2 und Hardwarebeschleunigung geprüft werden müssen und bei Ruckeln auf die Low-Grafikqualität umgeschaltet werden sollte. Die Hürde, eine Webseite zu öffnen, ist sehr niedrig; ob das Spiel flüssig läuft, hängt jedoch weiterhin von der GPU des Spielers ab.
6.2 1.4MB: Leicht zu verteilen – die Laufzeitlast steht auf einem anderen Blatt
Programmatische Generierung verwandelt „das Herunterladen von Assets“ in „zur Laufzeit berechnete Assets“. Texturen werden auf der GPU Pixel für Pixel in Echtzeit berechnet, Geometrie wird bei der Initialisierung von der CPU aufgebaut – all diese Arbeit findet auf dem Gerät des Spielers statt. Bislang haben die Entwickler keine Standard-Startzeit, keine durchschnittlichen FPS und keine Angaben zu VRAM- oder Arbeitsspeicherbelegung von Saltline veröffentlicht. Um die Laufzeitlast einzuschätzen, muss man sie nach der Methode aus Abschnitt 5.3 selbst messen.
6.3 Der Engineering-Maßstab kommerzieller AAA-Spiele
Kommerzielle AAA-Spiele bedeuten in der Regel einen großen Einsatz an Geld, Personal und Ressourcen. Diese Bezeichnung beschreibt den Produktionsumfang und hat keinen einheitlichen technischen Zertifizierungsstandard. Ein kommerzielles AAA-Spiel braucht Dutzende Stunden Inhalt, komplexe Charakteranimationen und Physiksysteme, Mehrspieler-Netzwerksynchronisation, plattformübergreifende Anpassung sowie über Jahre hinweg laufende Updates, Wartung, Tests und Optimierung. Programmatische Generierung eignet sich gut für stark regelbasiertes Material wie Container, Boden und Regen. Bei Charakteren und narrativen Szenen, die viel künstlerische Feinarbeit erfordern, bleibt die traditionelle Asset-Produktion jedoch die passendere Wahl.
6.4 Was Saltline wirklich beweist
Saltline zeigt, dass ein KI-Modell mit starken Programmierfähigkeiten in einem einzigen durchgängigen Generierungsprozess Level-Design, Szenenaufbau, Shader, Spielmechaniken, Steuerungslogik und Audiogenerierung zu einem stilistisch stimmigen, direkt teilbaren 3D-Spielprototyp zusammenführen kann. Die Übergabekosten zwischen verschiedenen Tools und Rollen, die im klassischen Workflow entstehen, werden hier in den Kontext eines einzigen Modells komprimiert.
Vergleicht man die vom Entwickler selbst genannten Daten mit den offiziell veröffentlichten Modellpreisen, lässt sich die Kostenstruktur dieses Experiments klar erkennen:
| Kategorie | Wert | Quelle |
|---|---|---|
| Entwicklungszeit | ca. 8 Stunden | Aussage von Felix Rieseberg, 2026-11-09 |
| Geschätzte Kosten | ca. 550 US-Dollar (geschätzt anhand der API-Preise) | Aussage von Felix Rieseberg |
| Eingabe-Token | ca. 445 Millionen, davon ein großer Teil gecacht | Aussage von Felix Rieseberg |
| Ausgabe-Token | ca. 2,7 Millionen | Aussage von Felix Rieseberg |
| Fable 5.2 Preis Eingabe / Ausgabe | $8 / $40 pro Million Token | Offizielle Modelldokumentation von Anthropic |
| Fable 5.2 Preis für Cache-Lesezugriffe | $0.20 pro Million Token | Offizielle Modelldokumentation von Anthropic |
| Kontextfenster / maximale Ausgabe | 1M Token / 128K Token | Offizielle Modelldokumentation von Anthropic |
Der Preis für Cache-Lesezugriffe liegt deutlich unter dem normalen Eingabepreis. Die 445 Millionen Eingabe-Token lassen sich daher nicht einfach mit dem regulären Eingabe-Stückpreis in Gesamtkosten umrechnen. Der Entwickler hat die genaue Aufschlüsselung der Abrechnung nicht veröffentlicht, weshalb die 550 US-Dollar als geschätzte Kosten eines einzelnen Generierungsexperiments verstanden werden sollten.
💰 Kostentipp: Bei der KI-Generierung von Webspielen konzentrieren sich die Kosten auf die Entwicklungsphase, wobei lange Kontexte und viele Iterationsrunden den größten Anteil ausmachen. Bevor Sie sich in lang laufende Aufgaben investieren, können Sie über APIYI apiyi.com mit kleineren Eingabeaufforderungen zunächst die Codequalität mehrerer Modelle vergleichen und dann entscheiden, auf welchem Modell Sie eine längere Generierung durchführen. Die nutzungsbasierte Abrechnung erleichtert es, die Kosten für Trial-and-Error zu kontrollieren.
7 Häufig gestellte Fragen (FAQ)
F1: Läuft ein von einer KI erstelltes 3A-Spiel im Browser, indem das Spielbild vom Server gestreamt wird?
Die Grafik von Saltline wird von der lokalen GPU des Spielers gerendert. Der Browser lädt eine etwa 1,4 MB große HTML-Datei herunter, führt die Spiel-Logik mit JavaScript aus und zeichnet jedes Bild über WebGL mit der lokalen Grafikkarte. Cloud-Gaming-Dienste wie GeForce NOW, bei denen das Bild vom Server übertragen wird, verfolgen einen anderen technischen Ansatz.
F2: Wird beim Spielen von Saltline in Echtzeit das Claude-Modell aufgerufen?
Nein. Claude Fable 5.2 wird nur während der Entwicklungsphase eingesetzt, um den Spielcode zu generieren. Das GitHub-Mirror-Repository enthält keine Framework-Skripte von Claude Artifact mehr, sodass das Spiel mit einem gewöhnlichen HTTP-Server gestartet werden kann. Beim Spielen entstehen keine Kosten für Modellaufrufe.
F3: Worin unterscheidet sich Saltline von KI-Weltmodellen wie Genie 3?
Bei Saltline werden Regeln und Szenen von der KI im Voraus als Code geschrieben und zur Laufzeit von herkömmlichen Rendering-Pipelines ausgeführt. Genie 3 sagt Bild für Bild basierend auf den Eingaben des Spielers voraus und erzeugt die Grafik, wobei die Regeln aus Daten gelernt werden. Ersteres bedeutet, dass die KI ein Programm schreibt, Letzteres, dass die KI direkt die Grafik erzeugt – technisch sind beide Ansätze unabhängig voneinander.
F4: Welche Hardware brauche ich, um ein 1,4 MB großes Browser-3A-Spiel flüssig zu spielen?
Der Entwickler hat weder Mindestanforderungen noch FPS-Werte veröffentlicht. Die offizielle Seite empfiehlt, sicherzustellen, dass der Browser WebGL 2 unterstützt und die Hardwarebeschleunigung aktiviert ist, und bei Ruckeln auf die Qualitätsstufe „Low“ umzuschalten. Für konkrete Messwerte empfiehlt es sich, das Frametime-Skript aus Abschnitt 5.3 dieses Artikels auf dem eigenen Gerät auszuführen.
F5: Wie kann ich mit einer API selbst ein ähnliches 3D-Browserspiel erstellen?
Registrieren Sie sich bei APIYI apiyi.com und holen Sie sich einen API-Schlüssel. Setzen Sie im Code aus Abschnitt 5.2 den Wert `base_url` auf `https://api.apiyi.com/v1`, wählen Sie ein Modell, das sich für lange Code-Ausgaben eignet, und fordern Sie in der Eingabeaufforderung ausdrücklich „eine einzelne HTML-Datei, Three.js, alle Assets per Code und Shader generiert“ an. Nach der Generierung öffnen Sie die Datei einfach über einen lokalen HTTP-Server und können losspielen.
F6: Welche Einschränkungen gibt es beim Erzeugen von Browser-Spielen mit KI?
Die Ausgabelänge eines einzelnen Aufrufs ist begrenzt, komplexe Spiele erfordern mehrere Generierungsrunden mit langem Kontextfenster, wodurch die Kosten steigen. Der generierte Code muss häufig in puncto Performance und Kompatibilität noch debuggt werden. Der Browser selbst bringt außerdem Einschränkungen bei Speicher, Threads und mobiler Unterstützung mit. Es empfiehlt sich, zunächst über APIYI apiyi.com mit mehreren Modellen einen kleinen Vergleich durchzuführen, das Modell mit der stabilsten Code-Qualität auszuwählen und erst dann den Projektumfang zu vergrößern.
8 Kernpunkte: KI-generierte 3A-Spiele im Browser
- Wo es läuft: Saltline läuft im Browser des Spielers, die lokale GPU übernimmt das Rendering
- Klare Aufgabenteilung: Die KI schreibt in der Entwicklungsphase den Code, der Browser führt ihn zur Laufzeit aus
- Technische Kette: JavaScript steuert die Logik, Three.js baut die Szene zusammen, WebGL spricht die GPU an
- Das Geheimnis der Dateigröße: Modelle, Texturen und Sounds liegen komplett als Funktionen vor – eine einzelne Datei von etwa 1.4MB
- Kleine Datei heißt nicht leichte Ausführung: Prozedurale Assets verwandeln Downloadkosten in Rechenkosten zur Laufzeit
- Drei Wege: Lokale Ausführung im Browser, Cloud-Gaming und KI-Weltmodelle – der Rechenort ist jeweils ein anderer
- Selbst ausprobieren: Über APIYI apiyi.com lassen sich verschiedene Modelle aufrufen, um ein Single-File-Three.js-Spiel zu erzeugen und direkt zu testen
9 Fazit
Ein von der KI erstelltes Spiel im 3A-Look kann im Browser laufen – möglich machen das die 3D-Fähigkeiten, die Browser längst mitbringen, zusammen mit prozeduraler Generierung. Drei Kernpunkte stechen heraus:
- Der Browser ist die Laufzeitumgebung der Spiel-Engine: JavaScript, Three.js und WebGL zusammen erlauben es einer Webseite, direkt die lokale GPU zum Rendern von 3D-Szenen zu nutzen.
- Die KI-Kosten fallen in der Entwicklungsphase an: Nach der Generierung läuft Saltline unabhängig von Claude weiter; die vom Entwickler selbst genannten rund 550 US-Dollar sind eine einmalige Kostenschätzung.
- 1.4MB lösen das Verteilungsproblem: Speicher- und GPU-Last zur Laufzeit trägt weiterhin das Gerät des Spielers. Saltline ist ein schnell gebauter, spielbarer 3D-Prototyp.
Wer den Ablauf „KI schreibt das Spiel, der Browser führt es aus“ selbst erleben möchte, kann über APIYI apiyi.com mit derselben OpenAI-kompatiblen Schnittstelle verschiedene Modelle dabei vergleichen, wie gut sie Three.js-Code generieren – und die Ergebnisse anschließend mit dem Frame-Zeit-Skript aus diesem Artikel messen.
📚 Referenzen
- Saltline eigenständige Demo-Seite: Einstieg in die Spiel-Demo sowie Hinweise zu Ladevorgang, Bildqualität und Steuerung
- Link:
saltline.games -
Beschreibung: Enthält offizielle Hinweise zu Initialisierungszeit, WebGL 2 und Hardwarebeschleunigung
-
Saltline Code-Mirror und README: HTML-Version als Einzeldatei
- Link:
github.com/realcodebear/saltline-fable-5.2 -
Beschreibung: Dokumentiert den Portierungsprozess des Artifacts, die Dateistruktur und die externe Abhängigkeit von Google Fonts
-
GitHub-Repository der chinesischen 几猫-Version: Chinesisch lokalisierte Variante von Saltline
- Link:
github.com/Megasu/jimao-3a-game -
Beschreibung: Bietet Angaben zu Dateigröße, Offline-Betrieb und Browser-Anforderungen
-
Claude Fable 5.2 Modellspezifikationen und Preise: Offizielle Anthropic-Dokumentation
- Link:
platform.claude.com/docs/en/models/fable-5-2/overview -
Beschreibung: Preise für Eingabe, Ausgabe und Caching sowie das Kontextfenster
-
MDN WebGL API: Dokumentation der GPU-Rendering-Schnittstelle im Browser
- Link:
developer.mozilla.org/en-US/docs/Web/API/WebGL_API -
Beschreibung: Autoritative Quelle zum Verständnis der Funktionsweise von WebGL
-
Offizielle Three.js-Dokumentation: Web-3D-Grafikbibliothek
- Link:
threejs.org/docs -
Beschreibung: API-Dokumentation zu Scene, Mesh, ShaderMaterial, InstancedMesh und weiteren Klassen
-
Technische Einschränkungen von Unity WebGL: Grenzen der Browser-Spielplattform
- Link:
docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html -
Beschreibung: Erläuterung der Einschränkungen bei Dateisystem, Threads, Speicher und Mobilgeräte-Unterstützung
-
NVIDIA GeForce NOW Systemanforderungen: Netzwerkanforderungen für Cloud-Gaming
- Link:
nvidia.com/en-us/geforce-now/system-reqs -
Beschreibung: Empfohlene Bandbreite und Latenz für verschiedene Bildqualitäten und Bildraten
-
Epic Games Pixel Streaming: Streaming von Cloud-Rendering
- Link:
dev.epicgames.com/documentation/unreal-engine/pixel-streaming-in-unreal-engine -
Beschreibung: Offizielle Dokumentation zur Übertragung von Unreal-Engine-Bildern per WebRTC an den Browser
-
Technische Veröffentlichung von Genie 3: Weltmodell von Google DeepMind
- Link:
deepmind.google/blog/genie-3-a-new-frontier-for-world-models - Beschreibung: Fähigkeiten und Grenzen bei der Echtzeit-Generierung interaktiver Umgebungen
- Link:
Autor: APIYI-Technikteam
Technischer Austausch: Kontaktieren Sie uns gerne über die Startseite der APIYI-Website; weitere Materialien zur Modellintegration finden Sie im Dokumentationszentrum unter docs.apiyi.com
