Anmerkung des Autors: Saltline beschreibt die Generierungsregeln für Geometrie, Texturen und Sound in Code. Dadurch ist die Auslieferungsgröße sehr klein, aber ein Teil der Arbeit wird in die Laufzeitberechnung auf den Geräten der Spieler verlagert.
Saltline ist nur etwa 1,4 MB groß, weil in der einzelnen HTML-Datei die Regeln zur Generierung von Modellen, Texturen und Sound gespeichert sind – und nicht vorab erstellte Modelldateien, Texturen und Soundeffekte. Nachdem der Browser die Datei geöffnet hat, bauen JavaScript und Shader den Hafen bei Regennacht, die Container und die Drohnen lokal in Echtzeit auf. Prozedurale Generierung verändert die Repräsentation und Auslieferung von Spielressourcen: Der Download wird deutlich kleiner, während die Arbeit für die Geometrieerstellung auf der CPU und die Pixelberechnung auf der GPU entsprechend zunimmt. Dateigröße, Arbeitsspeicher und GPU-Last sind drei getrennte Kostenposten.
Im Folgenden wird zunächst die Zusammensetzung dieser 1,4-MB-Datei aufgeschlüsselt und anschließend mit der traditionellen Asset-Produktion von Spielen verglichen. Danach zeigen drei Beispiele – Container, Metallmaterial und Regen –, wie prozedurale Geometrie, prozedurale Texturen, Shader und prozedurale Soundeffekte jeweils funktionieren. Darauf folgt eine Analyse der Laufzeitkosten hinter der kleinen Dateigröße. Zum Schluss gibt es einen ausführbaren Codeabschnitt, der zeigt, wie man über eine API ein großes Sprachmodell dazu bringt, eine ähnliche prozedurale Szene zu generieren.

To Know: Kleines Glossar zur Terminologie prozeduraler 3D-Spiele
| Begriff | Erklärung |
|---|---|
| Prozedurale Geometrie | Erzeugt Scheitelpunkte und Modellformen anhand von Parametern und Regeln – etwa einen Quader aus Länge, Breite und Höhe |
| Prozedurale Texturen | Berechnet Oberflächenfarben und Muster mithilfe mathematischer Funktionen (zum Beispiel Rauschen) |
| Shader | Ein kleines Programm, das auf der GPU läuft und die Position jedes Scheitelpunkts sowie die Farbe jedes Pixels bestimmt |
| Rauschfunktion | Algorithmen wie Perlin oder Simplex, die natürliche, unregelmäßige Zufallsmuster erzeugen |
| Instanziertes Rendering | Zeichnet viele ähnliche Objekte mit einem einzigen Draw Call; in Three.js entspricht das InstancedMesh |
| WebGL | Vom Browser bereitgestellte GPU-Grafikschnittstelle, mit der Webseiten 3D-Szenen rendern können |
| Three.js | Eine auf JavaScript basierende Web-3D-Grafikbibliothek, die Konzepte wie Szene, Kamera und Material kapselt |
| HTML | Dateiformat zur Strukturierung von Webseiteninhalten und -code; der gesamte Kerncode von Saltline steckt in einer einzigen HTML-Datei |
| Auslieferungsgröße | Die Datenmenge, die Spieler herunterladen müssen |
| Arbeitsspeicher zur Laufzeit | Der Speicher, den das Programm während der Ausführung belegt, einschließlich der zur Laufzeit erzeugten Geometrien und Texturen |
| GPU-Last | Die Rechenmenge, die der Grafikprozessor pro Frame bewältigen muss |
| Token | Die grundlegende Einheit, in der große Sprachmodelle Text verarbeiten – zugleich die Abrechnungseinheit der API |
1 Was steckt in einer 1,4 MB großen HTML-Datei: Saltlines Ein-Datei-Architektur
1.1 Was für ein KI-generiertes 3D-Spiel ist Saltline?
Am 9. November 2026 veröffentlichte der Anthropic-Engineer Felix Rieseberg ein Programmier-Experiment mit Claude Fable 5.2: Eine einzige Eingabeaufforderung sollte das Modell dazu bringen, einen kleinen First-Person-Shooter zu bauen, dessen Optik einem AAA-Spiel so nahe wie möglich kommt – und zwar ohne menschliches Feedback während des Prozesses. Das Ergebnis ist Saltline.
Das Spiel spielt in einem Containerhafen in einer Regennacht. Der Spieler muss drei Signalrelaisstationen abschalten und sich evakuieren; die Gegner sind patrouillierende Drohnen in der Luft und mechanische Spürhunde am Boden. Es unterstützt First-Person-Bewegung, Schießen, Interaktion und Missionsziele, bietet Regen, Licht, Umgebungsgeräusche und Waffeneffekte sowie Grafikoptionen. Es ist ein spielbarer Prototyp für einen Spieler und einen Level – „3A“ ist das Experimentziel und eine optische Analogie. Die auf chinesischen Social-Media-Plattformen verbreitete Bezeichnung „几猫·国产3A大作“ ist eine chinesische Version bzw. eine Neuverpackung von Saltline; der Name stammt aus dem Verbreitungsprozess.
Die vom Entwickler selbst genannten Zahlen sind Schätzungen, die er auf X veröffentlicht hat und die nicht von Dritter Seite geprüft wurden:
- Entwicklungszeit ca. 8 Stunden;
- Kosten nach API-Preisen geschätzt ca. 550 US-Dollar;
- Eingabe-Token ca. 445 Millionen, wobei ein großer Teil davon aus dem Cache kam;
- Ausgabe-Token ca. 2,7 Millionen.
Da bei den Eingabe-Token ein großer Teil Cache-Treffer sind, lässt sich diese Rechnung nicht einfach mit dem normalen Eingabepreis pro Token über die Gesamtmenge nachvollziehen; auch die genaue Rechnungsstruktur wurde nicht veröffentlicht. Die 550 US-Dollar sind einmalige Generierungskosten – beim Spielen im Browser werden keine Modelle mehr aufgerufen.
1.2 Aufbau von index.html: Three.js, generierter Code und externe Schriftarten
Das GitHub-Spiegelrepository liefert genaue Zahlen: Die Kerndatei index.html umfasst 1.425.707 Bytes, also rund 1,43 MB (1,36 MiB). Der Aufbau dieser Datei lässt sich in vier Teile gliedern:
- Three.js-Laufzeitcode: Die gesamte 3D-Bibliothek ist in die HTML-Datei gepackt und kümmert sich um Szene, Kamera, Materialien und das WebGL-Rendering;
- Code zur Erzeugung von Szene und Assets: Geometrie, Texturen und Materialien entstehen aus JavaScript-Funktionen und Shadern;
- Prozeduraler Audiocode: Auch der Klang wird per Code synthetisiert, im Repository liegen keine separaten Audiodateien;
- Spiellogik: Eingabesteuerung, Gegnerverhalten und Missionsablauf.
Im Repository gibt es keine separaten Bild-, Video- oder Audiodateien. Die einzige eindeutige externe Abhängigkeit sind die Google-Fonts-Schriften. Am 10. November ergänzte der Entwickler, dass sämtliche Inhalte des Spiels Code sind – Texturen und Modelle sind Funktionen.
1.3 Was passiert, wenn man Saltline im Browser öffnet
Der Ablauf ist eine saubere lokale Pipeline: Der Browser liest die HTML-Datei → JavaScript beginnt mit der Ausführung → Three.js und die WebGL-Rendering-Umgebung werden initialisiert → der Code erzeugt Szenengeometrie, Materialien, Texturen und Klänge → die GPU rendert Bild für Bild → der Spieler bedient Tastatur und Maus, und die Spiellogik aktualisiert sich fortlaufend.
In dieser Pipeline findet der Schritt „Assets erzeugen“ auf dem Gerät des Spielers statt. Auch die offizielle Saltline-Erlebnisseite weist darauf hin: Die Initialisierung der Seite kann eine Weile dauern, und die Geräteleistung beeinflusst die Startgeschwindigkeit; wenn die Seite im Wartebildschirm hängt, sollte man WebGL 2 und die Hardwarebeschleunigung des Browsers prüfen; bei Ruckeln lässt sich auf die Qualitätsstufe „Low“ umschalten. Diese Hinweise allein zeigen schon, wie viel Rechenleistung zur Laufzeit nötig ist.

2 Wie traditionelle Spiele Modelle, Texturen und Sounds erstellen
2.1 Die drei zentralen Asset-Typen traditioneller 3D-Spiele
Bild und Ton traditioneller 3D-Spiele stammen hauptsächlich aus vorab erstellten Asset-Dateien:
- Modelldateien: von Künstlern in Modellierungssoftware erstellt und als Daten wie Vertices, Flächen und UV-Koordinaten gespeichert;
- Textur-Maps: mehrere Bilder für Diffuse, Normal, Rauheit, Metallizität usw., die auf die Modelloberfläche gelegt werden und für Details sorgen;
- Soundeffekte: aufgenommene oder synthetisierte und exportierte Audiodaten, die bei bestimmten Ereignissen abgespielt werden.
Diese Assets werden erstellt, optimiert, komprimiert und gepackt und anschließend zusammen mit dem Spiel ausgeliefert. Die Engine lädt sie zur Laufzeit; ihre Hauptaufgabe besteht darin, sie zu „lesen und anzuzeigen“.
2.2 Warum traditionelle Assets viel Platz belegen
Vorgefertigte Assets speichern das Ergebnis. Eine hochauflösende Textur muss den Farbwert jedes einzelnen Pixels festhalten; ein fein detailliertes Modell muss die Position jedes einzelnen Vertex festhalten; ein Soundeffekt muss jeden einzelnen Sample-Punkt festhalten. Je reicher die Szene und je höher die Auflösung, desto mehr Ergebnisdaten müssen gespeichert werden – und das Volumen wächst entsprechend linear.
Der prozedurale Ansatz speichert den Prozess. Eine Noise-Funktion braucht nur wenige Dutzend Zeilen Code, kann aber Rostmuster in beliebiger Auflösung erzeugen; eine parametrisierte Box-Funktion kann Container in jeder Größe generieren. Das ist der grundlegende Grund dafür, dass 1,4 MB eine komplette Hafenszene tragen können.
| Vergleichsaspekt | Traditionelle vorgefertigte Assets | Prozedural generierte Assets |
|---|---|---|
| In der Datei gespeicherter Inhalt | Endgültige Ergebnisdaten (Vertices, Pixel, Samples) | Generierungsregeln (Funktionen, Parameter, Shader) |
| Erstellungsweise | Künstler fertigen alles einzeln in professionellen Tools an | Code und Parameter schreiben, zur Laufzeit berechnen |
| Auslieferungsvolumen | Wächst mit Anzahl und Genauigkeit der Assets | Wird überwiegend vom Codeumfang bestimmt, meist sehr klein |
| Hauptaufgabe zur Laufzeit | Laden, Dekodieren, Anzeigen | Geometrie aufbauen, Texturen berechnen, Sound synthetisieren |
| Kontrolle über Details | Künstler können jedes Detail präzise steuern | Hängt von der Ausdrucksfähigkeit der Algorithmen ab, hoher Aufwand beim Parameter-Tuning |
| Typische Einsatzbereiche | Charaktere, zentrale Gegenstände, realistische Szenen | Wiederkehrende Strukturen, natürliche Oberflächen, Wettereffekte |
3 Wie KI Spiel-Assets mit Code erzeugt: Vier prozedurale Techniken
Prozedurale Generierung ist eine Technik, die die Spielebranche seit Langem einsetzt: Das Terrain von „Minecraft“ und die Level zahlreicher Roguelikes beruhen darauf. Das Neue an Saltline ist, dass ein KI-Modell in einem einzigen fortlaufenden Generierungsprozess gleichzeitig den gesamten Code für Geometrie, Texturen, Shader, Audio und Spiellogik schreibt – und damit die Übergaben zwischen Modeling, Materialien, Sounddesign und Programmierung verringert.
| Ebene | Generiertes Objekt | Technischer Ansatz | Entsprechendes Beispiel in Saltline |
|---|---|---|---|
| Geometrieerzeugung | Modellformen | Vertizes, Flächen, parametrische Geometrie | Container, Lagerhallen, Hafenstrukturen |
| Materialerzeugung | Oberflächeneigenschaften | Parameter für Farbe, Rauheit, Metallizität | Metallgehäuse der Container |
| Texturerzeugung | Oberflächendetails | Rauschen, Fraktale, Voronoi | Rost, Flecken, Abnutzung |
| Umgebungserzeugung | Szenenlayout | Regeln, Zufallszahlen, räumliche Beziehungen | Anordnung der Containerstapel |
| Animationserzeugung | Objektbewegung | Mathematische Funktionen, Zustandsänderungen | Drohnenpatrouillen, fallende Regentropfen |
| Klangerzeugung | Soundeffekte | Oszillatoren, Filter, Rauschen | Regen, Schüsse, Umgebungsgeräusche |
3.1 Prozedurale Geometrie: Mit Parametern einen Container bauen
Ein Container ist im Grunde ein Quader mit gewellten Seitenwänden. Prozedurale Geometrie funktioniert so: Aus den Parametern Länge, Breite und Höhe wird ein Hexaeder erzeugt, anschließend werden die Vertices entlang der Seitenflächen nach einer Sinusfunktion verschoben, um die Wellung des gewalzten Stahlblechs nachzubilden. BufferGeometry von Three.js erlaubt es, Vertex-Arrays direkt zu beschreiben, während BoxGeometry einen fertigen parametrisierten Quader bereitstellt.
Im Hafen stehen Hunderte oder Tausende von Containern, die alle dieselben Geometriedaten teilen. Hier setzt man auf instanziiertes Rendering mit InstancedMesh: Man speichert pro Instanz nur eine Transformationsmatrix (Position, Rotation, Skalierung) und eine Farbe – und kann so einen kompletten Container-Stapelplatz mit einem einzigen Draw Call zeichnen.
3.2 Prozedurale Texturen: Mit Rauschfunktionen Rost malen
Prozedurale Texturen erzeugen die Texturdaten algorithmisch. Gängige Algorithmen sind Perlin Noise, Simplex Noise, Voronoi und fraktales Rauschen: Überlagert man mehrere Rauschschichten unterschiedlicher Frequenz, entsteht eine natürliche Verteilung von Rostflecken; mit Voronoi lassen sich die blockartigen Ränder abblätternder Farbe erzeugen.
In Three.js werden solche Texturen üblicherweise einmal in der Initialisierungsphase berechnet, in eine DataTexture (direkt mit einem Pixel-Array befüllt) oder eine CanvasTexture (mit Canvas 2D gezeichnet) geschrieben und dann wie gewöhnliche Maps an das Material übergeben. Nach der einmaligen Erzeugung bleibt die Textur dauerhaft im Grafikspeicher; der zusätzliche Aufwand zur Laufzeit besteht im Wesentlichen in dieser Speicherbelegung.
3.3 Shader: Metall und Regen Pixel für Pixel auf der GPU berechnen
Shader laufen auf der GPU und berechnen anhand von Eingaben wie Koordinaten, Zeit und Beleuchtung in Echtzeit die Farbe jedes Pixels. Der Unterschied zu prozeduralen Texturen liegt im Zeitpunkt der Berechnung: Prozedurale Texturen lassen sich im Voraus zu einem Bild berechnen; Shader können dagegen in jedem Frame direkt rechnen, ohne ein vollständiges Bild erzeugen zu müssen.
Ein Hafen in einer Regennacht ist ein typisches Einsatzgebiet für Shader. Reflexionen auf feuchten Metalloberflächen, zeitlich veränderliche Wellen in Pfützen auf dem Boden und herabfallende Regenfäden lassen sich als Funktionen mit der Zeit als Eingabe formulieren und in jedem Frame neu berechnen. Das ShaderMaterial von Three.js erlaubt es, Vertex- und Fragment-Shader direkt zu schreiben, um diese Effekte umzusetzen. Die Abwägung zwischen beiden Ansätzen ist unkompliziert: Vorab erzeugte Texturen belegen Speicher und sparen Rechenleistung; Shader, die in Echtzeit berechnen, sparen Speicher und verbrauchen Rechenleistung.
3.4 Prozedurale Soundeffekte: Regen mit Oszillatoren und Filtern synthetisieren
Die Web Audio API des Browsers bietet Nodes für Oszillatoren, Rauschpuffer und Filter. Weißes Rauschen, das einen Tiefpassfilter passiert, kommt Regen bereits nahe; ein kurzer Rauschausbruch mit einer schnell abklingenden Lautstärkehüllkurve ergibt ein Schussgeräusch; ein niederfrequenter Oszillator, der die Tonhöhe moduliert, kann das Summen einer Drohne nachahmen. Im Saltline-Repository gibt es keine einzige Audiodatei; sämtliche Geräusche werden von solcherart Code in Echtzeit synthetisiert.

4 Kleinere Dateien, leichterer Betrieb? Eine Kostenanalyse der prozeduralen Generierung
4.1 Distributionsgröße, Arbeitsspeicher und GPU-Last auseinanderhalten
Um das „Gewicht“ eines 3D-Spiels zu messen, muss man mindestens drei Dimensionen betrachten:
- Distributionsgröße: Wie viele Daten der Spieler herunterlädt. Saltline hat in dieser Kategorie einen klaren Vorteil;
- Arbeitsspeicher zur Laufzeit: Zur Laufzeit erzeugte Vertexpuffer, Texturen und Audiopuffer belegen Arbeitsspeicher und VRAM – ein 1.4MB großes Programm kann zur Laufzeit ohne Weiteres Daten im Umfang von mehreren hundert MB erzeugen;
- Rechenlast: Die Arbeit, die CPU und GPU pro Frame erledigen müssen. Komplexe Shader treiben diesen Wert direkt nach oben.
Umgekehrt kann auch ein sehr großes Spiel durch Kompression, chunkweises Laden und Asset-Streaming eine gute Laufzeiteffizienz erreichen. Wer den technischen Ansatz allein an der Dateigröße beurteilt, kommt zu einseitigen Schlüssen.
4.2 Wohin die prozedurale Generierung die Kosten verschiebt
| Technik | Möglicherweise eingesparte Kosten | Möglicherweise zusätzliche Kosten |
|---|---|---|
| Prozedurale Modelle | Modell-Download und -Speicherung | CPU-Zeit für den Geometrieaufbau |
| Shader-Texturen | Bilddateien und Texturübertragung | GPU-Echtzeitberechnung pro Frame |
| Prozedurale Texturen (vorgeneriert) | Download von Bilddateien | Berechnung bei der Initialisierung und VRAM-Belegung |
| Instanced Rendering | Wiederholte Draw Calls | Szenenverwaltung und Pflege der Instanzdaten |
| Dynamisch generierte Szenen | Anzahl vorgefertigter Assets | Berechnung bei Initialisierung und Laufzeit |
| Prozeduraler Sound | Speicherung von Audiodateien | Aufwand für Echtzeit-Audiosynthese |
Dass Saltline langsam startet und eine „Low“-Grafikoption anbieten muss, ist genau die reale Ausprägung dieser Tabelle: Was in der Download-Phase eingespart wird, wird beim Start und in jedem gerenderten Frame erneut bezahlt.
4.3 Die Abwägung zwischen Shader, Instanced Rendering und dynamischer Geometrie
Die drei Techniken lösen jeweils unterschiedliche Probleme – kombiniert wirken sie am besten:
- Instanced Rendering reduziert die Zahl der Draw Calls, die die CPU an die GPU schickt, und eignet sich am besten für viele identische Objekte, etwa Containerstapel, Straßenlaternen oder Regentropfen-Partikel;
- Shader verlagert die Detailberechnung auf die GPU und passt zu Effekten, die sich mit der Zeit verändern (Regen, Wasserpfützen, flackerndes Licht). Der Preis dafür: Je komplexer der Fragment-Shader, desto stärker lastet er bei hoher Auflösung auf der GPU;
- Dynamische Geometrie eignet sich für Strukturen, die sich je nach Parameter ändern oder nur in begrenzter Zahl vorkommen. Der Aufwand konzentriert sich auf die Initialisierung; danach ist es ein ganz normales Mesh.
In der Praxis geht die Optimierung meist in diese Richtung: Was sich vorab berechnen lässt, wird beim Initialisieren einmal berechnet und zwischengespeichert. Nur was sich tatsächlich mit der Zeit ändern muss, landet im Shader pro Frame.
4.4 Die Saltline-Route und ihre Unterschiede zu Cloud-Gaming und KI-Weltmodellen
„KI macht Spiele“ entspricht derzeit mindestens drei technischen Routen. Saltline gehört zur ersten.
| Vergleichsdimension | Lokales Webspiel | Cloud-Gaming | KI-Weltmodell |
|---|---|---|---|
| Repräsentative Beispiele | Saltline | GeForce NOW, Pixel Streaming | Genie 3, Muse/WHAMM, Oasis |
| Wo KI beteiligt ist | Codeerzeugung in der Entwicklungsphase | Normalerweise nicht beteiligt | Bild-für-Bild-Erzeugung zur Laufzeit |
| Bilderzeugung | Lokales GPU-Rendering | Cloud-GPU-Rendering, danach Video-Streaming | Echtzeit-Vorhersage und -Erzeugung durch das Modell |
| Netzwerkanforderungen | Nach dem ersten Laden offline spielbar | Permanente Internetverbindung | In der Regel permanente Internetverbindung |
| Wann Kosten entstehen | Einmalige Entwicklungskosten, danach trägt das Gerät des Spielers | Serverkosten bei jeder Spielsession | Inferenzkosten bei jeder Spielsession |
| Hauptbeschränkungen | Browser und lokale Hardware | Netzwerklatenz, Bandbreite | Konsistenz, Latenz, Kontrollierbarkeit |
Saltline bündelt die KI-Kosten in der Entwicklungsphase. Nach Abschluss der Erzeugung werden die Spielregeln durch Code festgelegt, und der Betrieb ist vom Modell unabhängig. Das entscheidet darüber, dass es offline laufen kann – und auch darüber, dass die Leistungsfähigkeit des Spielergeräts die Obergrenze des Erlebnisses bildet.
5 Schnelleinstieg in prozedurale 3D-Spiele: Szenencode mit der API von einem großen Sprachmodell generieren lassen
5.1 Minimalbeispiel: prozedurale Szene mit einem einzigen Aufruf erzeugen
Das folgende Skript ruft über eine OpenAI-kompatible Schnittstelle ein großes Sprachmodell auf und lässt es eine Single-File-HTML-Datei ausgeben, die prozedurale Container, verrauschte Rosteffekte und Shader-Regen enthält. Verwenden Sie als Modellnamen bitte den tatsächlichen Namen aus der Modellliste der Plattform:
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # APIYI einheitliche Schnittstelle: ein Key für mehrere Modelle
)
prompt = """生成一个单文件 HTML,用 Three.js(CDN 引入)实现:
1. 用 InstancedMesh 程序化生成 200 个随机颜色的集装箱堆场;
2. 用 DataTexture + 多层噪声生成锈迹纹理,不使用任何图片文件;
3. 用 ShaderMaterial 实现随时间下落的雨丝;
4. 用 Web Audio API 合成低通滤波白噪声作为雨声。
只输出完整 HTML 代码。"""
resp = client.chat.completions.create(
model="your-model-name", # Durch den tatsächlichen Modellnamen der Plattform ersetzen
messages=[{"role": "user", "content": prompt}],
)
open("procedural_port.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
Öffnen Sie nach dem Ausführen procedural_port.html in einem Browser, um das Ergebnis zu sehen. Saltline war ein acht Stunden dauernder Generierungsprozess mit mehreren hundert Millionen Token; dieses Beispiel demonstriert nur den kleinsten vollständigen Ablauf derselben Idee.
Vollständige Implementierung ansehen: handgeschriebener Referenzcode für prozedurale Container, verrauschte Rosteffekte, Shader-Regen und synthetisierten Regensound
Im Folgenden finden Sie eine handgeschriebene Referenzimplementierung, die beim Abgleich mit der vom Modell erzeugten Code-Struktur hilft. Sie vereint die vier Techniken aus Kapitel 3 in einer einzigen Datei:
<!DOCTYPE html>
<html><head><meta charset="utf-8"><style>body{margin:0;background:#000}</style></head>
<body>
<script type="module">
import * as THREE from 'https://unpkg.com/[email protected]/build/three.module.js';
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(0x0a0f18, 20, 120);
const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 0.1, 500);
camera.position.set(0, 12, 40);
camera.lookAt(0, 0, 0);
// 1. Prozedurale Textur: mehrschichtiges Value-Noise erzeugt Rost und schreibt ihn in eine DataTexture
const size = 256, data = new Uint8Array(size * size * 4);
const rand = (x, y) => (Math.sin(x * 127.1 + y * 311.7) * 43758.5453) % 1;
function noise(x, y) {
const xi = Math.floor(x), yi = Math.floor(y), xf = x - xi, yf = y - yi;
const a = rand(xi, yi), b = rand(xi + 1, yi), c = rand(xi, yi + 1), d = rand(xi + 1, yi + 1);
const u = xf * xf * (3 - 2 * xf), v = yf * yf * (3 - 2 * yf);
return Math.abs(a + (b - a) * u + (c - a) * v + (a - b - c + d) * u * v);
}
for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
let n = 0, amp = 0.5, f = 4 / size;
for (let o = 0; o < 4; o++) { n += noise(x * f, y * f) * amp; amp *= 0.5; f *= 2; }
const rust = Math.min(1, n * 1.4), i = (y * size + x) * 4;
data[i] = 120 + rust * 100; data[i + 1] = 110 - rust * 40; data[i + 2] = 100 - rust * 60; data[i + 3] = 255;
}
const rustTex = new THREE.DataTexture(data, size, size, THREE.RGBAFormat);
rustTex.wrapS = rustTex.wrapT = THREE.RepeatWrapping;
rustTex.needsUpdate = true;
// 2. Prozedurale Geometrie + Instanced Rendering: 200 Container teilen sich eine einzige Geometrie
const box = new THREE.BoxGeometry(6, 2.6, 2.4);
const mat = new THREE.MeshStandardMaterial({ map: rustTex, metalness: 0.6, roughness: 0.5 });
const containers = new THREE.InstancedMesh(box, mat, 200);
const m = new THREE.Matrix4(), color = new THREE.Color();
for (let i = 0; i < 200; i++) {
const col = i % 10, row = Math.floor(i / 10) % 5, layer = Math.floor(i / 50);
m.makeTranslation(col * 6.5 - 30, layer * 2.7 + 1.3, row * 3 - 7);
containers.setMatrixAt(i, m);
containers.setColorAt(i, color.setHSL(Math.random(), 0.5, 0.45));
}
containers.instanceMatrix.needsUpdate = true;
scene.add(containers);
scene.add(new THREE.HemisphereLight(0x6688aa, 0x111111, 0.6));
const lamp = new THREE.PointLight(0xffaa55, 80, 60);
lamp.position.set(0, 15, 10);
scene.add(lamp);
// 3. Shader: Die Position der Regentropfen wird auf der GPU zeitabhängig berechnet
const rainCount = 6000, pos = new Float32Array(rainCount * 3);
for (let i = 0; i < rainCount * 3; i++) pos[i] = (Math.random() - 0.5) * 80;
const rainGeo = new THREE.BufferGeometry();
rainGeo.setAttribute('position', new THREE.BufferAttribute(pos, 3));
const rainMat = new THREE.ShaderMaterial({
uniforms: { uTime: { value: 0 } },
transparent: true,
vertexShader: `uniform float uTime;
void main(){
vec3 p = position;
p.y = mod(p.y - uTime * 25.0, 40.0);
gl_Position = projectionMatrix * modelViewMatrix * vec4(p, 1.0);
gl_PointSize = 2.0;
}`,
fragmentShader: `void main(){ gl_FragColor = vec4(0.6, 0.7, 0.9, 0.5); }`
});
scene.add(new THREE.Points(rainGeo, rainMat));
// 4. Prozeduraler Sound: Weißes Rauschen wird tiefpassgefiltert und simuliert so Regen (startet nach Klick auf die Seite)
addEventListener('click', () => {
const ctx = new AudioContext();
const buf = ctx.createBuffer(1, ctx.sampleRate * 2, ctx.sampleRate);
const ch = buf.getChannelData(0);
for (let i = 0; i < ch.length; i++) ch[i] = Math.random() * 2 - 1;
const src = ctx.createBufferSource(); src.buffer = buf; src.loop = true;
const lp = ctx.createBiquadFilter(); lp.type = 'lowpass'; lp.frequency.value = 1200;
const gain = ctx.createGain(); gain.gain.value = 0.15;
src.connect(lp).connect(gain).connect(ctx.destination); src.start();
}, { once: true });
const clock = new THREE.Clock();
renderer.setAnimationLoop(() => {
rainMat.uniforms.uTime.value = clock.getElapsedTime();
renderer.render(scene, camera);
});
</script>
</body></html>
Die gesamte Datei enthält kein einziges Bild, keine Modelldatei und keine Audiodatei. Die Rosttextur wird bei der Initialisierung einmal berechnet (CPU-Kosten + VRAM), die Positionen der Regenstreifen werden in jedem Frame im Vertex-Shader berechnet (GPU-Kosten), und die Container werden in einem einzigen Draw Call gezeichnet (was den CPU-Overhead durch Aufrufe reduziert).
Tipp für den Schnellstart: Beim Generieren von Code für prozedurale Szenen unterscheiden sich verschiedene Modelle deutlich in der Genauigkeit der Three.js-API und in der Art, Shader zu schreiben. Mit APIYI apiyi.com kannst du mit demselben API-Schlüssel zwischen mehreren Modellen wechseln und die Ausgabequalität direkt nebeneinander vergleichen. Das kostenlose Testkontingent für neue Nutzer reicht für mehrere Vergleichsrunden.
5.2 Drei praktische Tipps zum Schreiben von Eingabeaufforderungen
Es funktioniert besser, die Eingabeaufforderung wie eine technische Spezifikation statt wie eine vage Vision zu schreiben:
- Technische Details vorgeben: Fordere ausdrücklich konkrete APIs wie InstancedMesh, DataTexture und ShaderMaterial an; dann setzt das Modell die Szene prozedural um, anstatt externe Ressourcen als vorhanden anzunehmen;
- Einschränkungen deutlich machen: Schreibe ausdrücklich „keine Bilder, Modelldateien oder Audiodateien verwenden“ und „eine einzelne HTML-Datei“ hinein – im Einklang mit den Einschränkungen von Saltline;
- Performance-Stufen verlangen: Lass das Modell Umschaltoptionen für niedrige, mittlere und hohe Grafikqualität anbieten (z. B. weniger Regentropfen, Schatten deaktivieren), entsprechend Saltlines Ansatz, eine Low-Qualitätsstufe anzubieten.
5.3 So werden die Generierungskosten geschätzt
Als Referenz dienen die von Anthropic offiziell veröffentlichten Preise für Claude Fable 5.2: 8 US-Dollar pro Million Input-Token, 40 US-Dollar pro Million Output-Token, 0,20 US-Dollar pro Million Token für Cache-Lesevorgänge und 10 US-Dollar pro Million Token für das Schreiben in den 5-Minuten-Cache; Kontextfenster 1M Token, maximale Ausgabe 128K Token. Bei einer einzelnen Generierung wie in Abschnitt 5.1 liegt der Token-Verbrauch normalerweise nur im Bereich von einigen Tausend bis einigen Zehntausend. Bei einer langen autonomen Iteration wie bei Saltline über 8 Stunden wird vorhandener Code immer wieder gelesen; die durch Cache-Treffer entstehenden Preisunterschiede können die Gesamtkosten deutlich beeinflussen. Bei langen Aufgaben sollte daher vorrangig Prompt-Caching genutzt werden.
Kostenhinweis: Bei Experimenten zur langfristigen Codegenerierung können Sie zunächst auf APIYI apiyi.com mit einer kleinen Eingabeaufforderung den Token-Verbrauch pro Runde messen und dann anhand der Anzahl der Iterationsrunden das Gesamtbudget schätzen. Die Plattform rechnet nach Verbrauch ab; das eignet sich gut, um ein Konzept zunächst klein und dann immer größer zu validieren.
6 Häufig gestellte Fragen (FAQ)
Q1: Was sind prozedural generierte 3D-Game-Assets?
Prozedural generierte Assets beschreiben mit Code und Parametern die Regeln, nach denen Modelle, Texturen und Sounds erzeugt werden; das Ergebnis wird erst zur Laufzeit berechnet. In der Datei steht also „wie gezeichnet wird“, während klassische Asset-Dateien „das fertige Ergebnis“ speichern. Saltlines Container, Rostspuren und Regengeräusche gehören in diese Kategorie.
Q2: Worin unterscheiden sich prozedurale Texturen und Shader?
Prozedurale Texturen erzeugen die Texturdaten über Algorithmen und lassen sich vorab zu einem Bild berechnen und in den Grafikspeicher legen; Shader sind Programme auf der GPU, die die Pixelfarbe bei jedem Frame direkt berechnen. Erstere belegen mehr Speicher und weniger Rechenleistung, letztere umgekehrt – häufig werden beide kombiniert eingesetzt.
Q3: Wann wurde Saltline veröffentlicht und welches Modell kam zum Einsatz?
Veröffentlicht am 9. November 2026 vom Anthropic-Ingenieur Felix Rieseberg, mit Claude Fable 5.2, einer einzigen Eingabeaufforderung und ohne menschliches Feedback. Die Angaben von rund 8 Stunden, rund 550 US-Dollar, rund 445 Millionen Input-Token und 2,7 Millionen Output-Token sind Schätzungen des Entwicklers selbst. Am 10. November ergänzte er, dass Modell und Texturen vollständig durch Code generiert wurden.
Q4: Für welche Spielszenarien eignet sich prozedurale Generierung am besten?
– **Viele sich wiederholende Strukturen**: Container-Terminals, Gebäudekomplexe, Vegetation – am besten in Kombination mit Instanced Rendering;
– **Natürliche Oberflächen**: Materialien wie Rost, Gestein und Holzmaserung, die sich gut über Noise ausdrücken lassen;
– **Dynamisches Wetter und Effekte**: zeitabhängige Effekte wie Regen, Kräuselungen in Pfützen und flackerndes Licht;
– **Volumenempfindliche Distributionsszenarien**: Browser-Minispiele, interaktive Werbung, Prototypen zum Sofort-Spielen.
Für Hauptfiguren und zentrale Story-Props, die präzise künstlerische Kontrolle erfordern, sind vorgefertigte Assets weiterhin die bessere Wahl; kommerzielle Projekte setzen meist auf einen Hybrid-Ansatz.
Q5: Wie lässt man ein Großes Sprachmodell per API prozeduralen 3D-Szenencode generieren?
1. Bei APIYI apiyi.com registrieren und API-Schlüssel sowie kostenloses Testkontingent erhalten;
2. Mit dem Skript aus Abschnitt 5.1 dieses Artikels die base_url auf `https://api.apiyi.com/v1` setzen;
3. In der Eingabeaufforderung Einschränkungen wie Three.js-API, einzelne Datei und keine externen Ressourcen vorgeben; nach der Generierung im Browser öffnen und prüfen.
Da die Schnittstelle zum OpenAI-Format kompatibel ist, muss beim Wechsel zwischen Modellen wie Claude, GPT oder Gemini nur der Parameter model geändert werden.
Q6: Welche bekannten Einschränkungen hat die prozedurale Generierung?
– **Laufzeitkosten**: Initialisierungsberechnung, Grafikspeicherbelegung und die GPU-Last komplexer Shader gehen zulasten der Spielergeräte; auch Saltline benötigt eine Low-Qualitätsoption und eine längere Initialisierungszeit;
– **Browser-Einschränkungen**: Laut offizieller Unity-Dokumentation ist die Web-Plattform bei Dateisystem, Threads und Speicher eingeschränkt, die mobile Unterstützung ist begrenzt;
– **Künstlerische Kontrollierbarkeit**: Die Ausdrucksstärke von Algorithmen hat Grenzen; fotorealistische Charaktere und filigrane Props lassen sich kaum rein per Code erzeugen;
– **Engineering-Reife**: KI liefert schnell spielbare Prototypen, doch die für kommerzielle Spiele nötige langfristige Optimierung, Tests und Content-Erweiterung erfordern weiterhin viel Engineering-Aufwand.
7 1,4 MB 3D-Spiel und prozedurale Generierung – die wichtigsten Erkenntnisse
- Woher die Größe kommt: Saltline umfasst rund 1,4 MB, gespeichert werden die Generierungsregeln – keine Bilder, Modelle oder Audiodateien.
- Vier Techniken: prozedurale Geometrie, prozedurale Texturen, Shader und prozedurale Klänge – jede deckt eine Ebene ab, die Aufgaben sind klar verteilt.
- Verlagerte Kosten: Die Downloadgröße sinkt, dafür steigen CPU-Aufbau, Speicherbelegung der GPU und die Berechnung pro Frame.
- Worauf man schauen sollte: Auslieferungsgröße, Initialisierungszeit, Arbeitsspeicher und GPU-Kosten pro Frame gemeinsam bewerten.
- Die Rolle der KI: Die KI schreibt den Generierungscode – die prozeduralen Techniken selbst sind in der Spieleentwicklung schon lange weit verbreitet.
- So legt man los: Über APIYI apiyi.com lässt sich mit einem einzigen Key der von mehreren Modellen erzeugte Three.js-Szenencode direkt vergleichen.
8 Fazit: Spieleentwicklung wandert vom Erstellen von Assets zum Schreiben von Asset-Generierungsregeln
Saltline zeigt einen Wandel darin, wie Ressourcen ausgedrückt werden: Klassische Spiele liefern „fertig erstellte Assets“, prozedurale Spiele liefern „die Regeln, nach denen Assets entstehen“. KI-Codegenerierung senkt die Einstiegshürde für diesen Weg deutlich – ein Modell kann in einem fortlaufenden Generierungsprozess gleichzeitig Geometrie, Texturen, Shader, Audio und Spiellogik schreiben, sodass die Übergaben zwischen verschiedenen Gewerken entfallen.
Dieser Weg hat klare Grenzen. Bei Auslieferungsgröße und Betriebseinfachheit ist er deutlich im Vorteil, dafür wandert der Rechenaufwand auf die Geräte der Spieler. Er eignet sich gut für wiederkehrende Strukturen, natürliche Oberflächen und dynamische Effekte; aufwendige künstlerische Assets hängen weiterhin von der klassischen Produktion ab. Klassische Asset-Produktion und prozedurale Produktion werden sich langfristig ergänzen – der Wert von Saltline liegt darin, zu zeigen, dass auch ein kleines Programm eine reichhaltige interaktive Szene aufbauen kann.
Wer diesen Weg selbst ausprobieren möchte, kann mit dem Skript aus Abschnitt 5.1 beginnen. Empfehlenswert ist, über APIYI apiyi.com verschiedene Modelle anzusteuern und prozedurale Szenen generieren zu lassen, um zu vergleichen, wie gut sie Three.js und Shader beherrschen.
📚 Referenzen
- Saltline-Codespiegel und README: Ein-Datei-Struktur, Byteanzahl und Datenzuordnung der Entwickler
- Link:
github.com/realcodebear/saltline-fable-5.2 -
Beschreibung: Der programmatisch generierte Code von index.html kann dort direkt eingesehen werden
-
Eigenständige Saltline-Demoseite: Online-Anspieltest sowie Hinweise zu Initialisierung und Grafikqualität
- Link:
saltline.games -
Beschreibung: Die chinesische Version findest du unter
saltline.games/zh -
GitHub-Repository der chinesischen Fassung von 几猫: Archiv der im Inland verbreiteten Version
- Link:
github.com/Megasu/jimao-3a-game -
Beschreibung: Enthält Anleitung zum Offline-Betrieb und Angaben zur Dateigröße
-
Modellspezifikationen und Preise von Claude Fable 5.2: Offizielle Dokumentation von Anthropic
- Link:
platform.claude.com/docs/en/models/fable-5-2/overview -
Beschreibung: Preise für Eingabe, Ausgabe und Caching sowie Angaben zum Kontextfenster
-
Offizielle Three.js-Dokumentation und Beispiele: InstancedMesh, ShaderMaterial, BufferGeometry, DataTexture
- Link:
threejs.org/docsundthreejs.org/examples -
Beschreibung: Maßgebliche Erläuterungen zu den in diesem Artikel verwendeten APIs
-
MDN WebGL API: Die GPU-Rendering-Schnittstelle des Browsers
- Link:
developer.mozilla.org/en-US/docs/Web/API/WebGL_API -
Beschreibung: Hilft beim Verständnis der zugrunde liegenden Rendering-Mechanismen von Three.js
-
Unity WebGL – technische Übersicht: Threads, Speicher und Einschränkungen auf Mobilgeräten im Web
- Link:
docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html - Beschreibung: Eine Referenz zur Einschätzung der technischen Grenzen von Browser-Spielen
Autor: APIYI-Technikteam
Technischer Austausch: Du kannst uns gerne über die Startseite von APIYI apiyi.com kontaktieren; weitere Integrationsunterlagen findest du im Dokumentationszentrum unter docs.apiyi.com
