Note de l’auteur : Saltline décrit sous forme de code les règles qui président à la génération de la géométrie, des textures et du son. Le poids de distribution reste donc très faible, mais une partie du travail est déportée vers les calculs exécutés à l’exécution sur la machine du joueur.
Si Saltline ne pèse qu’environ 1,4 Mo, c’est parce que son fichier HTML unique contient les règles de génération des modèles, des textures et des sons, et non des fichiers de modèles, des textures et des effets sonores déjà fabriqués à l’avance. Une fois le fichier ouvert dans le navigateur, le JavaScript et les shaders construisent en local, en temps réel, un port sous une pluie nocturne, ses conteneurs et ses drones. La génération procédurale change la manière dont les ressources d’un jeu sont représentées et livrées : le volume à télécharger diminue fortement, tandis que la charge augmente d’autant côté CPU (construction de la géométrie) et GPU (calcul des pixels). Taille du fichier, mémoire vive utilisée et charge GPU sont trois comptes distincts.
Nous allons d’abord décomposer ce fichier de 1,4 Mo, puis le comparer à la façon dont les jeux traditionnels produisent leurs assets. Nous prendrons ensuite trois exemples — les conteneurs, le matériau métallique et la pluie — pour montrer comment fonctionnent respectivement la géométrie procédurale, les textures procédurales, les shaders et le son procédural. Nous analyserons enfin le coût à l’exécution qui se cache derrière ce petit volume, avant de proposer un extrait de code exécutable qui montre comment faire générer par un Grand modèle de langage, via une API, des scènes procédurales du même type.

À savoir : le vocabulaire des jeux 3D procéduraux
| Terme | Explication |
|---|---|
| Géométrie procédurale | Créer des sommets et des formes de modèle à partir de paramètres et de règles, par exemple générer une boîte à partir de sa longueur, sa largeur et sa hauteur |
| Textures procédurales | Calculer les couleurs et les motifs de surface à l’aide de fonctions mathématiques (comme le bruit) |
| Shader | Petit programme exécuté sur le GPU, qui détermine la position de chaque sommet et la couleur de chaque pixel |
| Fonctions de bruit | Des algorithmes comme Perlin, Simplex, etc., capables de générer des motifs aléatoires naturels et irréguliers |
| Rendu par instanciation | Dessiner un grand nombre d’objets similaires en un seul appel de dessin ; dans Three.js, cela correspond à InstancedMesh |
| WebGL | Interface graphique GPU fournie par le navigateur, qui permet aux pages web de rendre des scènes 3D |
| Three.js | Bibliothèque JavaScript de graphisme 3D pour le web, qui encapsule les concepts de scène, caméra, matériau, etc. |
| HTML | Format de fichier qui organise le contenu et le code d’une page web ; tout le code central de Saltline tient dans un seul fichier HTML |
| Taille de distribution | Quantité de données que les joueurs doivent télécharger |
| Mémoire d’exécution | Mémoire occupée pendant l’exécution du programme, y compris la géométrie et les textures générées à l’exécution |
| Charge GPU | Quantité de calcul que le processeur graphique doit effectuer à chaque image |
| Token | Unité de base utilisée par les grands modèles de langage pour traiter le texte, et unité de facturation de l’API |
1 Ce que contient un fichier HTML de 1,4 Mo : l’architecture monofichier de Saltline
1.1 Quel type de jeu 3D généré par IA est Saltline ?
Le 9 novembre 2026, l’ingénieur d’Anthropic Felix Rieseberg a rendu publique une expérience de programmation menée avec Claude Fable 5.2 : à partir d’une seule invite, il demandait au modèle de créer un petit jeu de tir à la première personne dont le rendu visuel se rapproche autant que possible d’un jeu AAA, sans retour humain pendant le processus. Le résultat s’appelle Saltline.
Le jeu se déroule dans un port à conteneurs par une nuit pluvieuse. Le joueur doit désactiver trois stations relais de signal, puis évacuer ; les ennemis sont des drones de patrouille aériens et des chiens mécaniques au sol. Le jeu prend en charge les déplacements à la première personne, le tir, les interactions et les objectifs de mission, avec de la pluie, des éclairages, des sons d’ambiance et des effets d’armes, ainsi que des réglages de qualité graphique. C’est un prototype jouable en solo, avec un seul niveau ; « 3A » désigne l’objectif de l’expérience et une analogie visuelle. La version « Jimao · production 3A nationale » diffusée sur les plateformes sociales chinoises est une version chinoise ou un repackaging de Saltline, dont le nom vient du processus de diffusion.
Les chiffres communiqués par le développeur, tous des estimations publiées par lui-même sur X et non auditées par un tiers, sont les suivants :
- temps de développement : environ 8 heures ;
- coût estimé sur la base des tarifs de l’API : environ 550 dollars ;
- jetons d’entrée : environ 445 millions, dont une grande partie a bénéficié du cache ;
- jetons de sortie : environ 2,7 millions.
Comme une grande partie des jetons d’entrée a touché le cache, ce montant ne peut pas être recalculé simplement en multipliant le prix unitaire d’entrée standard par le volume total, et la structure détaillée de la facture n’a pas été rendue publique. Ces 550 dollars correspondent à un coût de génération unique : lorsque les joueurs jouent dans le navigateur, le modèle n’est plus appelé.
1.2 Composition de index.html : Three.js, code généré et polices externes
Le dépôt miroir sur GitHub donne des chiffres précis : le fichier principal index.html fait 1 425 707 octets, soit environ 1,43 Mo (1,36 MiB). La structure de ce fichier se résume en quatre parties :
- Le code d’exécution Three.js : toute la bibliothèque 3D est embarquée dans le HTML ; elle gère la scène, la caméra, les matériaux et le rendu WebGL ;
- Le code de génération de la scène et des assets : géométries, textures et matériaux sont construits par des fonctions JavaScript et des shaders ;
- Le code audio procédural : le son est lui aussi synthétisé par le code, il n’y a aucun fichier audio séparé dans le dépôt ;
- La logique de jeu : contrôles d’entrée, comportement des ennemis, déroulement des missions.
Le dépôt ne contient aucun fichier image, vidéo ou audio autonome. La seule dépendance externe explicite est la police Google Fonts. Le 10 novembre, le développeur a précisé que tout le contenu du jeu est du code, et que les textures comme les modèles sont des fonctions.
1.3 Ce qui se passe quand on ouvre Saltline dans le navigateur
Le déroulement suit un pipeline local très net : le navigateur lit le HTML → JavaScript commence à s’exécuter → initialisation de Three.js et de l’environnement de rendu WebGL → le code génère les géométries, matériaux, textures et sons → le GPU affiche une image à chaque frame → le joueur utilise le clavier et la souris, et la logique du jeu se met à jour en continu.
Dans ce pipeline, l’étape « générer les assets » se déroule sur la machine du joueur. La page d’expérience officielle de Saltline le signale d’ailleurs : l’initialisation de la page peut prendre un certain temps, et les performances de l’appareil influent sur la vitesse de démarrage ; si l’écran d’attente reste bloqué, mieux vaut vérifier WebGL 2 et l’accélération matérielle du navigateur ; en cas de saccades, on peut passer en qualité Low. Ces indications en disent déjà long sur le poids du calcul au runtime.

2 Comment les jeux traditionnels créent leurs modèles, textures et sons
2.1 Les trois types de ressources clés d’un jeu 3D traditionnel
Dans un jeu 3D traditionnel, les images et les sons proviennent essentiellement de fichiers de ressources préparés à l’avance :
- Fichiers de modèle : créés par les artistes dans un logiciel de modélisation, puis enregistrés sous forme de sommets, de faces, de coordonnées UV, etc. ;
- Textures : plusieurs images (diffuse, normale, rugosité, métallicité, etc.) plaquées sur la surface du modèle pour lui apporter du détail ;
- Fichiers audio : des sons enregistrés ou synthétisés puis exportés, déclenchés à certains événements.
Ces ressources sont créées, optimisées, compressées et empaquetées avant d’être distribuées avec le jeu. Le moteur les charge à l’exécution ; son rôle principal consiste à « lire et afficher ».
2.2 Pourquoi les ressources préfabriquées occupent-elles autant de place ?
Les ressources préfabriquées stockent un résultat. Une texture haute résolution doit enregistrer la valeur de couleur de chaque pixel ; un modèle détaillé doit enregistrer la position de chaque sommet ; un son doit enregistrer chaque point d’échantillonnage. Plus une scène est riche et plus la résolution est élevée, plus il faut stocker de données de résultat, et le volume augmente linéairement.
La génération procédurale stocke un processus. Une fonction de bruit ne demande que quelques dizaines de lignes de code, mais peut produire un motif de rouille à n’importe quelle résolution ; une fonction paramétrique de boîte peut générer un conteneur de n’importe quelle taille. C’est la raison fondamentale pour laquelle 1.4MB suffisent à représenter toute une scène portuaire.
| Critère de comparaison | Ressources préfabriquées traditionnelles | Ressources générées procéduralement |
|---|---|---|
| Contenu enregistré dans le fichier | Données du résultat final (sommets, pixels, échantillons) | Règles de génération (fonctions, paramètres, Shader) |
| Mode de production | Les artistes les créent une par une dans des outils spécialisés | On écrit du code et des paramètres, puis on calcule à l’exécution |
| Volume de distribution | Croît avec le nombre et la précision des ressources | Dépend surtout de la quantité de code, souvent très faible |
| Travail principal à l’exécution | Charger, décoder, afficher | Construire la géométrie, calculer les textures, synthétiser les sons |
| Contrôle du détail | Les artistes peuvent contrôler précisément chaque détail | Dépend de la capacité d’expression de l’algorithme ; le réglage des paramètres coûte cher |
| Objets typiquement concernés | Personnages, objets clés, scènes réalistes | Structures répétées, surfaces naturelles, effets météorologiques |
3 Comment l’IA génère des assets de jeu avec du code : quatre techniques procédurales
La génération procédurale est une technique utilisée depuis longtemps dans l’industrie du jeu vidéo : le terrain de《Minecraft》, les niveaux de nombreux Roguelike en dépendent. L’originalité de Saltline, c’est que le modèle d’IA a écrit en une seule passe de génération continue tout le code de la géométrie, des textures, des shaders, de l’audio et de la logique de jeu, ce qui réduit les passages de relais entre modélisation, matériaux, effets sonores et programmation.
| Niveau | Objet généré | Approche technique | Exemple correspondant dans Saltline |
|---|---|---|---|
| Génération de géométrie | Forme du modèle | sommets, faces, géométrie paramétrique | conteneurs, entrepôts, structures de quai |
| Génération de matériaux | Propriétés de surface | paramètres de couleur, rugosité, métallicité | coque métallique des conteneurs |
| Génération de textures | Détails de surface | bruit, fractales, Voronoi | rouille, taches, usure |
| Génération d’environnement | Disposition de la scène | règles, nombres aléatoires, relations spatiales | agencement des piles de conteneurs |
| Génération d’animation | Mouvement des objets | fonctions mathématiques, changements d’état | patrouille de drones, chute des gouttes de pluie |
| Génération de son | Effets sonores | oscillateurs, filtres, bruit | bruit de pluie, coups de feu, ambiance sonore |
3.1 Géométrie procédurale : construire un conteneur à partir de paramètres
Un conteneur est essentiellement un parallélépipède rectangle doté de panneaux latéraux ondulés. L’approche de la géométrie procédurale consiste à générer un hexaèdre à partir des paramètres de longueur, largeur et hauteur, puis à décaler les sommets le long des faces latérales selon une fonction sinus pour simuler les ondulations de la tôle ondulée. Le BufferGeometry de Three.js permet d’écrire directement dans le tableau de sommets, tandis que BoxGeometry fournit une boîte paramétrique prête à l’emploi.
Dans un port, on trouve des centaines, voire des milliers de conteneurs qui partagent les mêmes données géométriques. On utilise alors InstancedMesh pour le rendu par instances : il suffit de stocker pour chaque instance une matrice de transformation (position, rotation, échelle) et une couleur, pour dessiner tout le parc à conteneurs en un seul appel de dessin.
3.2 Textures procédurales : dessiner la rouille avec des fonctions de bruit
Les textures procédurales génèrent des données de texture par algorithme. Les algorithmes courants incluent Perlin Noise, Simplex Noise, Voronoi et le bruit fractal : en superposant plusieurs couches de bruit à des fréquences différentes, on obtient une répartition naturelle des taches de rouille ; Voronoi permet de créer des frontières en blocs pour la peinture qui s’écaille.
Dans Three.js, ce type de texture est généralement calculé une seule fois au moment de l’initialisation, écrit dans une DataTexture (remplissage direct du tableau de pixels) ou une CanvasTexture (dessin via Canvas 2D), puis utilisé par le matériau comme une texture ordinaire. Une fois générée, la texture reste en mémoire vidéo ; le surcoût à l’exécution se résume principalement à cette occupation de mémoire vidéo.
3.3 Shader : métal et pluie, calculés pixel par pixel sur le GPU
Les shaders s’exécutent sur le GPU et calculent en temps réel la couleur de chaque pixel à partir d’entrées telles que les coordonnées, le temps ou l’éclairage. Ce qui les distingue d’une texture procédurale, c’est le moment où le calcul se fait : une texture procédurale peut être précalculée en une image ; un shader, lui, recalcule à chaque image, sans avoir besoin de produire une image complète.
Le port sous la pluie, la nuit, est le terrain de jeu typique du shader. Les reflets sur le métal mouillé, les ondulations de l’eau au sol qui se déforment au fil du temps, la chute des gouttes : tout cela peut s’écrire sous forme de fonctions prenant le temps en entrée et recalculées à chaque image. Le ShaderMaterial de Three.js permet d’écrire directement un vertex shader et un fragment shader pour obtenir ces effets. Le compromis entre les deux approches est simple : une texture précalculée occupe de la mémoire et épargne du calcul ; un shader qui calcule en temps réel épargne de la mémoire et consomme du calcul.
3.4 Effets sonores procéduraux : synthétiser la pluie avec des oscillateurs et des filtres
L’API Web Audio du navigateur fournit des oscillateurs, des tampons de bruit et des nœuds de filtrage. Un bruit blanc passé dans un filtre passe-bas se rapproche déjà du bruit de la pluie ; une courte rafale de bruit assortie d’une enveloppe de volume à décroissance rapide donne une détonation ; un oscillateur basse fréquence qui module la hauteur du son peut imiter le bourdonnement d’un drone. Le dépôt Saltline ne contient aucun fichier audio : tous les sons sont synthétisés en temps réel par ce type de code.

4 Le fichier rétrécit, l’exécution est-elle plus légère pour autant : analyse des coûts de la génération procédurale
4.1 Distinguer la taille de distribution, la mémoire d’exécution et la charge GPU
Pour mesurer le « poids » d’un jeu 3D, il faut regarder au moins trois dimensions :
- La taille de distribution : la quantité de données que le joueur télécharge. Saltline a sur ce point un avantage certain ;
- La mémoire d’exécution : les tampons de sommets, les textures et les tampons audio générés à l’exécution occupent de la RAM et de la mémoire vidéo ; un programme de 1,4 Mo peut très bien créer plusieurs centaines de Mo de données pendant son exécution ;
- La charge de calcul : le travail que le CPU et le GPU doivent accomplir à chaque image ; des shaders complexes font directement grimper cet indicateur.
À l’inverse, un jeu volumineux peut aussi offrir une excellente efficacité d’exécution grâce à la compression, au chargement par blocs et au streaming des ressources. Juger de la pertinence d’une approche technique sur la seule taille du fichier conduit forcément à des conclusions partielles.
4.2 Où la génération procédurale déplace-t-elle les coûts ?
| Technique | Coûts possiblement réduits | Coûts possiblement augmentés |
|---|---|---|
| Modèles procéduraux | Téléchargement et stockage des modèles | Temps de construction géométrique sur CPU |
| Textures de shader | Fichiers d’images et transfert de textures | Calcul temps réel sur GPU à chaque frame |
| Textures procédurales (pré-générées) | Téléchargement des fichiers d’images | Calcul d’initialisation et occupation de la mémoire vidéo |
| Rendu instancié | Appels de dessin répétés | Gestion de scène et maintenance des données d’instances |
| Génération dynamique de scènes | Nombre d’assets préfabriqués | Calcul d’initialisation et d’exécution |
| Effets sonores procéduraux | Stockage des fichiers audio | Coût de synthèse audio temps réel |
L’initialisation plus lente de Saltline et la nécessité de proposer une option de qualité Low sont précisément ce que ce tableau traduit dans la réalité : le travail économisé lors du téléchargement est repayé au démarrage et à chaque frame de rendu.
4.3 Le compromis entre shader, rendu instancié et géométrie dynamique
Ces trois techniques répondent à des problèmes différents, et c’est en les combinant qu’on obtient le meilleur résultat :
- Le rendu instancié réduit le nombre d’appels de dessin envoyés du CPU au GPU ; il est idéal pour les objets répétés en grand nombre, comme les piles de conteneurs, les lampadaires ou les particules de pluie ;
- Le shader déplace le calcul des détails sur le GPU ; il convient aux effets qui évoluent dans le temps (pluie, flaques d’eau, scintillement des lumières), au prix d’une charge GPU plus lourde en haute résolution à mesure que le fragment shader se complexifie ;
- La géométrie dynamique convient aux structures qui varient selon des paramètres ou dont le nombre est limité ; le coût de construction est concentré à l’initialisation, et une fois construites, ce sont des maillages ordinaires.
En ingénierie, l’optimisation courante consiste à calculer une fois et mettre en cache à l’initialisation tout ce qui peut être précalculé, et à ne placer dans le shader par frame que ce qui doit impérativement varier dans le temps.
4.4 Différences entre la voie Saltline, le cloud gaming et les modèles de monde IA
« Faire des jeux avec l’IA » correspond aujourd’hui à au moins trois voies techniques. Saltline appartient à la première.
| Dimension de comparaison | Jeu web local | Cloud gaming | Modèle de monde IA |
|---|---|---|---|
| Exemples représentatifs | Saltline | GeForce NOW, Pixel Streaming | Genie 3, Muse/WHAMM, Oasis |
| Intervention de l’IA | Génération de code pendant le développement | Généralement absente | Génération d’images image par image à l’exécution |
| Génération des images | Rendu GPU local | Rendu GPU dans le cloud, puis diffusion d’un flux vidéo | Génération prédictive en temps réel par le modèle |
| Exigences réseau | Fonctionnement hors ligne possible après le premier chargement | Connexion permanente | Connexion permanente généralement nécessaire |
| Moment où les coûts apparaissent | Coût de développement ponctuel, puis pris en charge par l’appareil du joueur | Coût serveur à chaque session de jeu | Coût d’inférence à chaque session de jeu |
| Principales limites | Navigateur et matériel local | Latence réseau, bande passante | Cohérence, latence, contrôlabilité |
Saltline concentre les coûts liés à l’IA dans la phase de développement. Une fois la génération terminée, les règles du jeu sont définies par le code et l’exécution ne dépend plus du modèle. C’est ce qui lui permet de fonctionner hors ligne, et c’est aussi ce qui fait de la performance de l’appareil du joueur le plafond de l’expérience.
5 Démarrage rapide avec un jeu 3D procédural : faire générer le code d’une scène par un grand modèle de langage via l’API
5.1 Exemple minimal : générer une scène procédurale en un seul appel
Le script ci-dessous appelle un grand modèle de langage via l’interface compatible OpenAI et lui demande de produire un fichier HTML unique contenant un empilement de conteneurs procédural, une rouille générée par bruit et de la pluie en Shader. Pour le nom du modèle, fiez-vous au nom réel qui apparaît dans la liste des modèles de la plateforme :
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # Interface unifiée APIYI, une seule clé pour appeler plusieurs modèles
)
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", # Remplacer par le nom réel du modèle sur la plateforme
messages=[{"role": "user", "content": prompt}],
)
open("procedural_port.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
Une fois le script exécuté, ouvrez procedural_port.html dans un navigateur pour voir le résultat. Saltline, c’est un processus de génération au long cours : 8 heures et plusieurs centaines de millions de tokens. Cet exemple ne montre que la boucle minimale d’une même approche.
Voir l’implémentation complète : code de référence écrit à la main pour les conteneurs procéduraux, la rouille par bruit, la pluie en Shader et le son de pluie synthétisé
Voici une implémentation de référence écrite à la main, pratique pour comprendre par comparaison la structure du code produit par le modèle. Elle réunit dans un seul et même fichier les quatre techniques du chapitre 3 :
<!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. Texture procédurale : génération de rouille par bruit de valeur sur plusieurs octaves, écrite dans une 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. Géométrie procédurale + rendu instancié : 200 conteneurs partagent une seule géométrie
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 : la position des gouttes de pluie est calculée sur le GPU au fil du temps
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. Effets sonores procéduraux : du bruit blanc filtré passe-bas pour imiter la pluie (démarre après un clic sur la page)
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>
Le fichier tout entier ne contient ni une image, ni un fichier de modèle, ni un extrait audio. La texture de rouille est calculée une seule fois à l’initialisation (coût CPU + VRAM), les positions des traînées de pluie sont calculées à chaque image dans le vertex shader (coût GPU), et les conteneurs sont rendus en un seul appel de dessin (ce qui réduit la surcharge des appels CPU).
Conseil pour démarrer rapidement : quand vous générez du code de scène procédurale, les différences entre modèles sont nettes sur la précision des API Three.js et sur la façon d’écrire les shaders. Avec APIYI apiyi.com, utilisez une même clé pour passer d’un modèle à l’autre et comparer côte à côte la qualité des sorties ; le crédit d’essai gratuit des nouveaux utilisateurs suffit pour enchaîner plusieurs séries de comparaisons.
5.2 Trois astuces pratiques pour rédiger des invites
Mieux vaut rédiger une invite comme une spécification technique que comme une simple phrase de vision :
- Précisez les points techniques : demandez explicitement des API concrètes comme InstancedMesh, DataTexture ou ShaderMaterial ; le modèle suivra alors une démarche procédurale plutôt que de supposer que des ressources externes existent ;
- Déclarez les contraintes : indiquez explicitement « aucune image, aucun fichier de modèle, aucun fichier audio » et « HTML en un seul fichier », en restant cohérent avec les contraintes de Saltline ;
- Demandez des paliers de performance : faites en sorte que le modèle propose des niveaux de qualité faible, moyenne et élevée (par exemple réduire le nombre de gouttes de pluie, désactiver les ombres), à l’image de Saltline qui propose un niveau de qualité « Low ».
5.3 Méthode d’estimation des coûts de génération
En prenant comme référence les tarifs officiels d’Anthropic pour Claude Fable 5.2 : entrée à 8 dollars par million de tokens, sortie à 40 dollars par million de tokens, lecture du cache à 0,20 dollar par million de tokens, écriture du cache sur 5 minutes à 10 dollars par million de tokens ; fenêtre de contexte de 1M tokens, sortie maximale de 128K tokens. Pour une génération unique comme celle de la section 5.1, la consommation de tokens se situe généralement dans l’ordre de quelques milliers à quelques dizaines de milliers. Les longues itérations autonomes de 8 heures à la Saltline relisent sans cesse du code déjà présent, et l’écart de prix induit par les hits de cache pèse de façon significative sur le coût total. Il faut donc, pour les tâches longues, exploiter en priorité le cache d’invites.
Conseil coût : pour une expérience de génération de code sur la durée, vous pouvez d’abord mesurer sur APIYI apiyi.com la consommation de tokens par tour avec une invite à petite échelle, puis estimer le budget total en fonction du nombre d’itérations. La plateforme facture à l’usage, ce qui convient bien à une validation de方案 en allant du plus petit au plus grand.
6 FAQ – Questions fréquentes
Q1 : Qu’est-ce qu’un asset de jeu 3D généré de manière procédurale ?
Un asset généré de manière procédurale décrit, à l’aide de code et de paramètres, les règles de génération des modèles, des textures et des sons ; le résultat est ensuite calculé à l’exécution. Le fichier contient donc « comment dessiner », alors qu’un fichier d’asset traditionnel contient « le résultat déjà dessiné ». Les conteneurs, la rouille et le bruit de la pluie de Saltline appartiennent à cette catégorie.
Q2 : Quelle est la différence entre une texture procédurale et un shader ?
Une texture procédurale génère des données de texture au moyen d’algorithmes ; elle peut être précalculée sous forme d’image, puis chargée en mémoire vidéo. Un shader est un programme exécuté sur le GPU, qui peut calculer directement la couleur des pixels à chaque frame de rendu. La première consomme davantage de mémoire et moins de puissance de calcul, c’est l’inverse pour le second ; les deux sont souvent utilisés ensemble.
Q3 : Quand Saltline a-t-il été publié, et avec quel modèle ?
Le 9 novembre 2026, par Felix Rieseberg, ingénieur chez Anthropic, avec Claude Fable 5.2, à partir d’une invite unique et sans retour humain. Les chiffres d’environ 8 heures, 550 dollars, 445 millions de tokens en entrée et 2,7 millions de tokens en sortie sont des estimations rapportées par le développeur. Le 10 novembre, il a précisé que les modèles 3D et les textures étaient entièrement générés par code.
Q4 : Pour quels types de scènes de jeu la génération procédurale est-elle la plus adaptée ?
– **Structures très répétitives** : ports à conteneurs, ensembles de bâtiments, végétation ; c’est avec le rendu par instances que le résultat est le meilleur ;
– **Surfaces naturelles** : rouille, roche, veinage du bois et autres matériaux qui se prêtent bien à une représentation par bruit ;
– **Météo dynamique et effets** : pluie, ondulations dans les flaques, scintillement des lumières, tous ces effets qui évoluent avec le temps ;
– **Scénarios de distribution où le poids des fichiers est critique** : mini-jeux web, publicités interactives, prototypes jouables en un clic.
Pour les personnages principaux et les objets narratifs clés qui exigent un contrôle artistique précis, les assets préconçus restent plus adaptés ; les projets commerciaux optent généralement pour une approche hybride.
Q5 : Comment faire générer du code de scène 3D procédurale par un grand modèle de langage via une API ?
1. Créer un compte sur APIYI apiyi.com, puis récupérer une clé API et un quota d’essai gratuit ;
2. Utiliser le script de la section 5.1 de cet article, en définissant base_url sur `https://api.apiyi.com/v1` ;
3. Indiquer dans l’invite les contraintes : API Three.js, fichier unique, aucune ressource externe, etc. Une fois le code généré, l’ouvrir dans un navigateur pour vérifier le résultat.
L’interface étant compatible avec le format OpenAI, il suffit de modifier le paramètre model pour passer à Claude, GPT, Gemini ou à un autre modèle.
Q6 : Quelles sont les limites connues de la génération procédurale ?
– **Coût à l’exécution** : le calcul d’initialisation, l’occupation de la mémoire vidéo et la charge GPU des shaders complexes sont reportés sur l’appareil du joueur ; Saltline a d’ailleurs besoin d’une option de qualité « Low » et d’un temps d’initialisation assez long ;
– **Contraintes du navigateur** : la documentation officielle d’Unity indique que la plateforme web est limitée en matière de système de fichiers, de threads et de mémoire, avec un support mobile restreint ;
– **Contrôle artistique** : l’expressivité des algorithmes a ses limites ; les personnages réalistes et les accessoires fins sont difficiles à générer uniquement par code ;
– **Maturité technique** : l’IA peut produire rapidement des prototypes jouables, mais l’optimisation à long terme, les tests et l’extension de contenu nécessaires à un jeu commercial demandent encore beaucoup de travail d’ingénierie.
7 Jeu 3D de 1,4 MB et génération procédurale — points clés
- Source du volume : Saltline pèse environ 1,4 MB et ne stocke que des règles de génération, sans fichiers d’images, de modèles ni d’audio.
- Quatre techniques : géométrie procédurale, textures procédurales, shaders et effets sonores procéduraux gèrent chacun une couche, avec une répartition claire des rôles.
- Transfert de coûts : le volume de téléchargement diminue, mais la construction côté CPU, l’occupation de la mémoire vidéo et le calcul GPU par image augmentent en conséquence.
- Dimensions d’évaluation : examiner en même temps le volume de distribution, le temps d’initialisation, la mémoire d’exécution et le coût GPU par image.
- Le rôle de l’IA : l’IA se charge d’écrire le code de génération ; les techniques procédurales, elles, sont depuis longtemps largement utilisées dans le développement de jeux.
- Pour se lancer : via APIYI apiyi.com, comparer avec une seule clé le code de scène Three.js produit par plusieurs modèles.
8 Conclusion : le développement de jeux passe de la fabrication d’assets à l’écriture de règles de génération d’assets
Saltline illustre un changement dans la manière d’exprimer les ressources : un jeu traditionnel livre des « assets déjà fabriqués », un jeu procédural livre des « règles de génération d’assets ». La génération de code par IA abaisse nettement le seuil de cette approche : un modèle peut, au fil d’une même génération continue, écrire en une fois la géométrie, les textures, les shaders, l’audio et la logique de jeu, ce qui supprime les passages de relais entre corps de métier.
Cette voie a des limites d’application bien définies. Elle brille par son volume de distribution réduit et sa facilité de déploiement, tout en déplaçant la pression de calcul vers l’appareil du joueur ; elle excelle dans les structures répétitives, les surfaces naturelles et les effets dynamiques, tandis que les assets artistiques fins restent dépendants d’une production traditionnelle. Production traditionnelle d’assets et production procédurale resteront complémentaires sur le long terme ; la valeur de Saltline est de démontrer qu’un programme de petite taille peut aussi construire des scènes interactives riches.
Pour vérifier cette approche par vous-même, vous pouvez partir du script de la section 5.1 : l’idéal est d’appeler différents modèles via APIYI apiyi.com pour générer des scènes procédurales, puis de comparer leur maîtrise de Three.js et des shaders.
📚 Références
- Miroir du code et README de Saltline : structure monofichier, taille en octets et attribution des données au développeur
- Lien :
github.com/realcodebear/saltline-fable-5.2 -
Description : permet de consulter directement le code généré par programmation dans
index.html -
Page d’expérience autonome de Saltline : essai en ligne, initialisation et paramètres de qualité graphique
- Lien :
saltline.games -
Description : la version chinoise se trouve sur
saltline.games/zh -
Dépôt GitHub de la version chinoise Jimao : archive de la version diffusée en Chine
- Lien :
github.com/Megasu/jimao-3a-game -
Description : fournit des instructions pour exécuter le jeu hors ligne et des données sur la taille des fichiers
-
Spécifications et tarifs du modèle Claude Fable 5.2 : documentation officielle d’Anthropic
- Lien :
platform.claude.com/docs/en/models/fable-5-2/overview -
Description : tarifs d’entrée, de sortie et de cache, ainsi que spécifications de la fenêtre de contexte
-
Documentation et exemples officiels de Three.js : InstancedMesh, ShaderMaterial, BufferGeometry, DataTexture
- Lien :
threejs.org/docsetthreejs.org/examples -
Description : documentation de référence pour les API utilisées dans le code de cet article
-
API WebGL de MDN : interface de rendu GPU du navigateur
- Lien :
developer.mozilla.org/en-US/docs/Web/API/WebGL_API -
Description : pour comprendre le mécanisme de rendu sous-jacent de Three.js
-
Présentation technique d’Unity WebGL : threads, mémoire et limites mobiles sur la plateforme Web
- Lien :
docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html - Description : référence pour évaluer les limites d’ingénierie d’un jeu dans le navigateur
Auteur : équipe technique APIYI
Échanges techniques : n’hésitez pas à nous contacter depuis la page d’accueil d’APIYI apiyi.com. Pour plus de ressources d’intégration, consultez le centre de documentation docs.apiyi.com
