Pourquoi les jeux AAA créés par l’IA peuvent-ils tourner dans un navigateur ? Décryptage de Saltline (1,4 Mo) et de 3 pistes pour les jeux web

Pourquoi les jeux AAA créés par l’IA peuvent-ils tourner dans un navigateur ? Décryptage de Saltline (1,4 Mo) et de 3 pistes pour les jeux web

Note de l’auteur : Saltline exécute le code du jeu dans le navigateur et fait appel au GPU local du joueur pour le rendu. Des assets procéduraux combinés à WebGL expliquent pourquoi un fichier web d’environ 1,4 MB peut afficher une scène de tir 3D complète.

Un « jeu AAA » réalisé par une IA peut tourner sur le web, pour trois raisons. Premièrement, un navigateur moderne est à lui seul un environnement complet d’exécution de programmes 3D : JavaScript exécute la logique du jeu, Three.js organise la scène, et WebGL confie le travail de dessin au GPU de l’ordinateur du joueur. Deuxièmement, ce que produit l’IA au stade du développement est un programme de jeu ; une fois le développement terminé, toute l’exécution revient au navigateur, et le joueur n’appelle plus de modèle IA pendant sa partie. Troisièmement, les modèles, textures et sons de Saltline sont tous générés par du code : un seul fichier HTML d’environ 1,4 MB suffit, et il suffit d’ouvrir la page pour entrer dans le jeu.

Le « AAA » dont il est question ici est l’objectif visuel que le développeur a fixé à l’IA, par analogie avec un style graphique. Saltline lui-même est un prototype jouable à petite échelle, avec un seul niveau.

Nous commencerons par le cas Saltline pour bien comprendre où le jeu tourne réellement. Nous démonterons ensuite la chaîne technique du rendu 3D dans le navigateur, nous expliquerons pourquoi la génération procédurale permet de réduire le fichier à 1,4 MB, puis nous mettrons côte à côte trois approches : l’exécution locale dans le navigateur, le cloud gaming et les modèles de monde IA. Enfin, nous fournirons un code directement exécutable pour générer avec l’IA et mesurer une scène 3D web, et nous discuterons de la distance réelle entre les jeux de navigateur et les jeux AAA commerciaux.

why-ai-made-3a-game-runs-in-browser-fr-image-0

Table of Contents

À savoir : comprendre le jargon des jeux 3A sur le Web avec IA

Terme Explication
JavaScript Langage de programmation exécuté par le navigateur ; c’est avec lui qu’est écrite la logique de jeu de Saltline
Three.js Bibliothèque graphique 3D en JavaScript, utilisée pour construire les scènes, les caméras, les lumières et les objets
WebGL Interface graphique fournie par le navigateur, qui permet à une page web d’appeler le GPU de l’appareil pour dessiner des images 3D
WebGPU Interface graphique et de calcul de nouvelle génération pour le navigateur, plus moderne ; Saltline ne s’appuie pas dessus
WebAssembly (Wasm) Bytecode de bas niveau exécutable par le navigateur, qui permet à des programmes C++, Rust et autres de tourner à grande vitesse dans une page web
GPU Processeur graphique, particulièrement efficace pour traiter en parallèle de grands volumes de pixels et de sommets
Shader Petit programme exécuté sur le GPU, qui calcule la position de chaque sommet ou la couleur de chaque pixel
Génération procédurale Construire le contenu du jeu à partir de règles et de fonctions mathématiques, au lieu d’images et de fichiers de modèles préparés à l’avance
Instancing (rendu par instanciation) Dessiner un grand nombre d’objets de forme identique en un seul appel de dessin, par exemple des rangées de conteneurs
Temps par image Temps nécessaire pour rendre une image ; à 60 FPS, cela correspond à environ 16,67 ms par image
Cloud gaming Le jeu tourne sur des serveurs distants et le flux vidéo est envoyé au joueur
WebRTC Technologie de transmission audio/vidéo en temps réel du navigateur, souvent utilisée par le cloud gaming pour envoyer l’image et les entrées
Modèle du monde Modèle d’IA qui apprend les règles d’évolution d’un environnement et prédit ou génère les scènes suivantes en fonction des entrées du joueur

1 Pourquoi un jeu AAA créé par IA tient-il dans une simple page web : commençons par Saltline

1.1 Qu’est-ce que Saltline, ce jeu web conçu par IA ?

Le 9 novembre 2026, l’ingénieur Anthropic Felix Rieseberg a rendu publique une expérience de programmation réalisée avec Claude Fable 5.2. Il a fourni au modèle une seule invite, lui demandant de créer un petit jeu de tir à la première personne dont les visuels se rapprochent autant que possible d’un jeu AAA, sans fournir de retour humain tout au long du processus. Le résultat final est Saltline.

Le jeu se déroule dans un port à conteneurs par une nuit pluvieuse, avec des entrepôts, des quais et des conteneurs empilés. Le joueur doit désactiver trois relais de signal et évacuer, tandis que les ennemis incluent 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 contrôle de la vue, le tir, les interactions et les objectifs de mission, ainsi que la pluie, l’éclairage, les effets sonores d’ambiance et les effets d’armes. La page propose des paramètres de qualité graphique, dont une option de faible qualité.

Selon le développeur lui-même sur X, cette expérience a duré environ 8 heures, avec un coût estimé à environ 550 dollars selon la tarification API, en consommant environ 445 millions de tokens d’entrée (dont une grande partie mise en cache) et environ 2,7 millions de tokens de sortie. Ces chiffres sont des estimations rapportées par le développeur, et non des factures auditées par un tiers.

Sur les réseaux sociaux chinois, une version nommée « 几猫·国产3A大作 » a ensuite circulé ; il s’agissait d’une version chinoise ou d’un repackaging de Saltline, le nom « 国产3A大作 » lui ayant été donné au fil de sa diffusion.

1.2 Un jeu complet de style AAA dans un seul fichier de 1,4 Mo

La version HTML autonome de Saltline ne contient qu’un seul index.html, dont la taille enregistrée dans le dépôt GitHub est de 1 425 707 octets, soit environ 1,43 Mo (1,36 MiB). Ce fichier contient le code central nécessaire au fonctionnement du jeu, et le code d’exécution de Three.js y est également intégré. Le jeu ne dispose d’aucun fichier séparé de modèle 3D, de texture ou d’effet sonore.

À titre de comparaison, les paquets d’installation des jeux 3D traditionnels contiennent généralement de nombreux modèles, textures haute résolution, animations, effets sonores et données de scène. Saltline remplace tous ces assets par du « code qui génère les assets », ce qui explique fondamentalement sa petite taille ; la section 3 y reviendra en détail.

1.3 Le jeu Saltline s’exécute en réalité sur l’appareil du joueur

L’IA n’intervient qu’au stade du développement. Le miroir GitHub de Saltline le montre : la version originale était un Claude Artifact ; lors du portage, le script d’exécution du framework Artifact a été supprimé, le code du jeu conservé, les déclarations DOCTYPE, charset et Viewport ajoutées, puis un simple serveur HTTP local suffit à le lancer.

Cela montre que la logique du jeu et l’interface de conversation de Claude sont désormais totalement séparées. Lorsque le joueur ouvre la page, le navigateur lit le HTML, exécute JavaScript, initialise WebGL, puis le GPU local dessine chaque frame ; aucun modèle d’IA ne participe à l’inférence tout au long du processus.

Un détail mérite d’être précisé : la note du miroir mentionne que les polices sont toujours chargées depuis Google Fonts. La description exacte est la suivante : le programme de jeu principal de Saltline s’exécute localement, les scènes, textures et sons sont générés par du code local, mais le chargement des polices dépend d’une ressource externe.


2 Comment le navigateur devient un environnement d’exécution 3D pour les jeux 3A à IA

Les navigateurs modernes savent analyser du HTML, mais aussi appeler des interfaces graphiques, exécuter du code haute performance, gérer la mémoire et traiter l’audio et la vidéo. Saltline utilise l’une des combinaisons les plus courantes : JavaScript + Three.js + WebGL.

2.1 JavaScript gère la logique du jeu web

JavaScript, c’est le « cerveau » du jeu. Où les ennemis patrouillent, si une balle touche sa cible, si une station relais a été désactivée, si le joueur peut s’extraire : toutes ces règles sont écrites en JavaScript et exécutées par le moteur JavaScript du navigateur, sur le CPU.

Pour les tâches de calcul plus lourdes, le navigateur propose aussi WebAssembly. Quand des moteurs comme Unity exportent une version web, ils compilent une partie du programme en WebAssembly pour gagner en vitesse d’exécution. WebAssembly se charge de l’exécution du programme, tandis que le rendu visuel reste assuré par WebGL : les deux peuvent collaborer. Saltline s’appuie principalement sur JavaScript pour sa logique.

2.2 Three.js organise la scène 3D

Écrire directement une scène 3D en WebGL oblige à gérer une foule de détails bas niveau. Three.js les encapsule dans des objets intuitifs :

  • Scene : le conteneur de la scène, qui accueille tous les objets et toutes les lumières
  • Camera : la caméra ; dans un jeu à la première personne, c’est l’œil du joueur
  • Geometry : la géométrie, qui définit la forme des conteneurs et des entrepôts
  • Material : le matériau, qui détermine si une surface ressemble à du métal ou à du béton
  • Mesh : l’objet visible obtenu en combinant une géométrie et un matériau
  • Light : les lumières, comme les lampadaires et les feux d’avertissement d’un port un soir de pluie
  • Renderer : le moteur de rendu, qui confie tout cela au GPU pour qu’il dessine l’image

La bibliothèque d’exemples officiels de Three.js met aussi en avant l’animation squelettique, le mappage d’ombres, les effets de post-traitement, le rendu par instanciation, etc. Parmi ces techniques, l’instanciation (Instancing) est particulièrement utile pour une scène portuaire : des centaines, voire des milliers de conteneurs similaires peuvent partager une même géométrie, en ne changeant que leur position et leurs paramètres de couleur, et être dessinés en un seul appel. Le navigateur est ainsi nettement moins sollicité.

2.3 WebGL confie le dessin au GPU local

WebGL est l’interface graphique que le navigateur met à la disposition de JavaScript, et qui s’appuie sur les technologies associées à OpenGL ES. Son fonctionnement est très direct : le code du jeu appelle WebGL via JavaScript, WebGL envoie les instructions de dessin au GPU, le GPU calcule l’image, puis le navigateur l’affiche dans la page.

Le point important, c’est que ce GPU est la carte graphique installée dans l’ordinateur du joueur. Chaque image de Saltline est calculée sur la machine du joueur ; le réseau ne sert qu’à envoyer le fichier de 1.4MB au navigateur au tout début. C’est aussi pour cela que la page officielle de Saltline conseille aux joueurs bloqués sur l’écran de chargement de vérifier WebGL 2 et l’accélération matérielle du navigateur.

2.4 Shaders, matériaux et éclairage composent l’apparence d’une scène 3D

L’apparence d’une scène 3D dépend de quatre éléments : le modèle fournit la forme, les matériaux définissent les propriétés de surface, l’éclairage produit les zones claires et sombres, et les shaders transforment l’ensemble en couleur finale des pixels.

Les shaders s’exécutent sur le GPU et se répartissent en deux catégories. Le shader de sommets calcule la position de chaque sommet à l’écran ; le shader de fragments calcule la couleur de chaque pixel. Dans l’exemple du conteneur sous la pluie, le shader de fragments peut utiliser des fonctions mathématiques pour générer les rayures d’une tôle ondulée, les taches de rouille et les reflets d’une surface mouillée, sans avoir besoin d’une texture pré-dessinée.

2.5 Boucle de jeu web : traiter les entrées et rafraîchir l’image en continu

Ce qui distingue un jeu d’une page web statique, c’est qu’il doit redessiner l’image plusieurs dizaines de fois par seconde. Le navigateur fournit l’interface requestAnimationFrame, qui appelle le code du jeu avant chaque rafraîchissement de l’écran, formant ainsi la boucle de jeu :

  1. Lire les entrées clavier, souris ou tactile (Saltline demande de cliquer sur la zone de jeu pour capturer le contrôle de la souris)
  2. Mettre à jour l’état du jeu : position du joueur, comportement des ennemis, trajectoire des projectiles
  3. Appeler le moteur de rendu Three.js, qui fait dessiner une nouvelle image par le GPU via WebGL
  4. Le navigateur affiche l’image, puis attend le prochain rafraîchissement

why-ai-made-3a-game-runs-in-browser-fr-image-1


3 Pourquoi 1,4 Mo suffisent à générer une scène complète de style AAA : la génération procédurale

3.1 Modèles, textures et sons : tout est écrit sous forme de fonctions

Le 10 novembre, Felix Rieseberg a apporté une précision : tout le contenu du jeu est du code, les textures et les modèles sont des fonctions, il n’existe aucun fichier d’image ou de modèle 3D séparé. Ce que Claude génère, c’est le code et les shaders qui construisent ces éléments.

Face à la méthode traditionnelle, la différence saute aux yeux :

  • Textures : l’approche classique télécharge une image de texture de conteneur et la plaque sur la surface ; l’approche procédurale calcule la surface métallique en temps réel à partir de fonctions de bruit, de variations de couleur et de shaders
  • Modèles : l’approche classique importe un fichier de modèle préparé dans un logiciel de modélisation ; l’approche procédurale construit la géométrie à l’exécution à partir de sommets et de paramètres géométriques
  • Sons : l’approche classique charge un fichier audio déjà enregistré ; l’approche procédurale effectue une synthèse en temps réel via les interfaces audio du navigateur

Ce que le fichier stocke, ce sont les « règles de génération » ; l’image finale n’est calculée qu’au moment de l’exécution. Les règles sont en général bien plus petites que le résultat : un shader de quelques dizaines de lignes suffit à couvrir le sol de tout un port.

3.2 Distinguer taille du fichier, mémoire d’exécution et charge de calcul

Pour comprendre les 1,4 Mo, il faut séparer trois notions :

Notion Ce qu’elle mesure Cas de Saltline
Taille du fichier La quantité de code et de ressources à télécharger Environ 1,4 Mo, une distribution très légère
Mémoire d’exécution La mémoire vive et la mémoire graphique occupées pendant l’exécution La scène est générée à l’exécution, l’éditeur ne publie pas de chiffres
Charge de calcul Le travail accompli par le CPU et le GPU à chaque image Dépend des réglages de qualité et du matériel, l’éditeur ne publie pas de chiffres
Temps d’initialisation Le délai entre l’ouverture de la page et le moment où l’on peut jouer L’éditeur précise qu’il faut construire le port, les entrepôts, les éclairages et les sons ; la durée dépend de l’appareil

La génération procédurale échange du « calcul à l’exécution » contre de la « taille de téléchargement ». Un programme de 1,4 Mo peut créer à l’exécution une grande quantité de géométries, de matériaux et de textures, et le GPU doit toujours accomplir à chaque image un travail considérable de shaders. La page officielle de Saltline prévient d’ailleurs clairement que l’apparition du bouton START dépend de l’appareil du joueur, et qu’en cas de saccades on peut basculer en qualité Low.

why-ai-made-3a-game-runs-in-browser-fr-image-2

3.3 Une architecture mono-fichier qui rend la distribution ultra légère

L’intérêt d’un HTML tenant en un seul fichier, c’est la distribution. On peut le déposer sur n’importe quel service d’hébergement statique, ou le télécharger et l’ouvrir en local avec un serveur HTTP ; pour le partager, un simple lien suffit. Le dépôt GitHub de la version chinoise de « 几猫 » propose directement une démo en ligne et un lien de téléchargement, en précisant que le jeu peut tourner hors ligne (hors chargement des polices).

Ce format est particulièrement pratique pour les prototypes générés par IA. Le modèle produit un fichier complet en une seule fois, le développeur n’a ni pipeline d’assets, ni outil de build, ni configuration serveur à gérer : dès la génération terminée, il peut l’envoyer à quelqu’un pour qu’il l’essaie.


4 Faire tourner des jeux AAA dans le navigateur : trois routes aux modes de calcul totalement différents

Derrière l’expression « jouer dans le navigateur » se cachent trois routes techniques dont les principes de calcul n’ont rien à voir les uns avec les autres. Il faut les distinguer pour bien comprendre ce que fait Saltline.

4.1 Exécution locale dans le navigateur : la route de Saltline

L’IA génère le code, le code est envoyé au joueur, puis le navigateur exécute la logique et effectue le rendu de l’image localement grâce au GPU. C’est l’appareil du joueur qui supporte l’essentiel du calcul : le jeu n’a pas besoin d’être connecté à un modèle d’IA pendant son exécution, et une fois les fichiers téléchargés, il a la possibilité de fonctionner hors ligne. Le prix à payer, c’est que les performances dépendent entièrement de l’appareil et du navigateur du joueur.

4.2 Cloud gaming : les approches GeForce NOW et Pixel Streaming

Le jeu s’exécute sur des serveurs distants : les GPU du cloud rendent l’image, puis le flux vidéo est envoyé au navigateur. Le navigateur se charge uniquement d’afficher la vidéo, de jouer le son et de renvoyer les entrées du joueur au serveur.

Pixel Streaming d’Epic Games permet à une application Unreal Engine de tourner dans le cloud ou sur un ordinateur distant, puis de transmettre l’image et l’audio au navigateur via WebRTC. NVIDIA GeForce NOW est un service de cloud gaming destiné aux joueurs. Selon les prérequis réseau officiels pour le navigateur : 15 Mbps minimum pour du 720p/60 FPS, 25 Mbps minimum pour du 1080p/60 FPS, 35 Mbps minimum pour du 1440p/120 FPS, avec une latence recommandée inférieure à 80 ms. Cette approche abaisse les exigences matérielles locales, mais impose une dépendance continue au réseau.

4.3 Les modèles du monde en IA : l’approche Genie 3

Les modèles du monde ne reposent pas sur des scènes et des règles définies à l’avance. Ils prédisent et génèrent la séquence d’images suivante à partir de l’état courant et des entrées du joueur. En août 2025, Google DeepMind a publié Genie 3, qui, selon l’annonce officielle, peut générer en temps réel des environnements explorables en 720p, jusqu’à 24 FPS, avec une cohérence de scène maintenue pendant plusieurs minutes. Muse/WHAMM de Microsoft et Oasis de Decart explorent également cette voie.

En janvier 2026, Project Genie, basé sur Genie 3, a ouvert son accès. La première phase s’adresse aux abonnés Google AI Ultra âgés de 18 ans et plus aux États-Unis, avec une limite de 60 secondes par session de génération. Cette approche n’en est pour l’instant qu’au stade de la recherche et du prototype produit ; elle n’a rien à voir avec la technologie utilisée par Saltline.

4.4 Comparaison des trois approches

why-ai-made-3a-game-runs-in-browser-fr-image-3

Dimension de comparaison Exécution locale dans le navigateur Cloud gaming Modèle de monde IA
Cas représentatifs Saltline GeForce NOW, Pixel Streaming Genie 3
Logique de jeu Exécution de code pré-écrit en local Exécution de code pré-écrit dans le cloud Le modèle apprend la dynamique de l’environnement à partir des données
Génération de l’image Rendu GPU local Rendu GPU dans le cloud Génération en temps réel par IA
Rôle du navigateur Environnement d’exécution du jeu Terminal vidéo et d’interaction Point d’entrée d’interaction
Dépendance réseau Quasiment hors ligne après le premier chargement Connexion permanente, bande passante élevée et faible latence requises Nécessite généralement une connexion permanente
Exigences matérielles locales Relativement élevées Relativement faibles Dépend du mode de déploiement du modèle
Moment où survient le coût IA Concentré sur la phase de développement Pas d’inférence IA, consommation continue de GPU cloud Inférence continue à chaque session de jeu

La structure de coûts est la différence la plus concrète entre les trois. Saltline concentre le coût IA dans un seul développement, puis le rendu est pris en charge par l’appareil du joueur : l’estimation de 550 dollars ne croît pas avec le nombre de joueurs. Le cloud gaming et les modèles de monde, en revanche, consomment continuellement de la puissance de calcul serveur à chaque session de jeu.


5 Pratique : générer et exécuter une scène 3D web avec l’IA

Le moyen le plus rapide de comprendre le principe, c’est de le faire soi-même une fois. Cette section se déroule en trois étapes : d’abord exécuter une scène procédurale écrite à la main, ensuite demander au grand modèle de langage de générer un jeu monofichier via l’API, et enfin mesurer son temps de frame.

5.1 Scène procédurale Three.js minimale et fonctionnelle

Ce fichier dessine 400 conteneurs grâce à l’Instancing : les stries ondulées et les taches de rouille de chaque conteneur sont calculées en temps réel par le Shader, sans aucun fichier image. Enregistrez-le sous index.html, lancez python3 -m http.server 8000 dans le même répertoire, puis ouvrez http://localhost:8000 dans votre navigateur.

<!DOCTYPE html>
<html lang="zh">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Port de conteneurs procédural</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);

// Matériau procédural : stries ondulées + taches de rouille bruitées + éclairage directionnel simple
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));   // stries ondulées
      float rust = smoothstep(0.82, 1.0, hash(floor(vUv * 40.0)));  // taches de rouille
      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 conteneurs dessinés en un seul appel de dessin
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);

// Boucle de jeu : mise à jour de la caméra et rendu à chaque frame
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>

Ce code résume l’idée centrale de Saltline : la géométrie est construite avec BoxGeometry, l’apparence est calculée par un Shader, et les nombreux objets répétés sont dessinés par Instancing. Le fichier entier ne pèse que quelques Ko, Three.js est chargé depuis un CDN ; Saltline, de son côté, intègre directement Three.js dans le HTML.

5.2 Générer un jeu 3D mono-fichier avec un grand modèle de langage via l’API

Le processus de génération de Saltline relève de la programmation agentique, longue et répartie sur de nombreux tours, et a consommé des centaines de millions de tokens. Les développeurs indépendants peuvent commencer par un seul appel et demander au modèle de produire un petit jeu Three.js mono-fichier exécutable, histoire de vivre concrètement la répartition des rôles : « l’IA écrit le programme, le navigateur l’exécute ». Le code ci-dessous utilise une interface compatible OpenAI. Remplacez le nom du modèle par un modèle de la liste de la plateforme qui prend en charge les sorties de code long.

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Interface compatible OpenAI d'APIYI
)

resp = client.chat.completions.create(
    model="YOUR_MODEL_NAME",  # Voir la liste des modèles de la plateforme
    messages=[{"role": "user", "content": "用 Three.js 写一个单文件 HTML 第一人称小游戏,所有模型和纹理用代码与 Shader 生成,只输出完整 HTML。"}],
)
open("game.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
Voir le code d’implémentation complet (avec nettoyage des blocs de code et contraintes d’invite)
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:
    """Supprime les balises de bloc de code ```html dont le modèle peut entourer sa réponse"""
    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",
    )

Le fichier généré suit la même logique d’exécution que Saltline : l’appel à l’API n’a lieu qu’une seule fois, au moment de la génération. Ensuite, vous pouvez ouvrir game.html et jouer autant de fois que vous le souhaitez, sans générer de nouveaux coûts de modèle.

🚀 Conseil pour démarrer rapidement : si vous voulez comparer le rendu de différents modèles sur l’écriture d’un jeu Three.js, vous pouvez passer de Claude à GPT, Gemini ou autres avec la même clé API via APIYI apiyi.com. L’interface est compatible OpenAI ; dans le code ci-dessus, il suffit de modifier le paramètre model. Les nouveaux utilisateurs disposent d’un quota de test gratuit, ce qui est idéal pour valider la qualité de génération avec une invite courte.

5.3 Mesurer les performances réelles d’un jeu 3D dans le navigateur

1,4 Mo ne répond qu’à une seule question : « à quelle vitesse le téléchargement se fait-il ? ». Pour savoir si un jeu web tourne ou rame, il faut mesurer d’autres indicateurs :

Indicateur Objectif de la mesure Méthode de mesure
Temps avant première interaction Expérience de démarrage Du chargement de la page jusqu’au moment où l’on peut contrôler le personnage, via des points de mesure avec l’API Performance
FPS / temps de frame Fluidité et stabilité 60 FPS correspond à environ 16,67 ms par frame ; surveiller les variations du temps de frame
Utilisation CPU Charge de la logique de jeu Observer le thread principal dans le panneau Performance de Chrome DevTools
Utilisation GPU et mémoire vidéo Charge de rendu Gestionnaire de tâches du système ou outil de surveillance de la carte graphique
Mémoire système Ressources à l’exécution Observer la mémoire du processus du navigateur une fois la scène initialisée
Trafic réseau après chargement Dépendances externes Panneau Network de DevTools, en distinguant les requêtes de polices, de programmes, etc.

Collez le code ci-dessous dans la console du navigateur pour calculer le temps de frame moyen et la frame la plus lente sur 10 secondes :

(() => {
  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);
})();

Pendant les tests, fixez la version du navigateur, le système d’exploitation, le modèle d’appareil, la résolution et le niveau de qualité graphique. Les mesures doivent couvrir des scènes où le joueur se déplace, où des ennemis sont actifs, où l’on tire et où les effets de pluie apparaissent en même temps : mesurer uniquement une scène vide juste après l’entrée dans le jeu donne des résultats bien trop optimistes.


6. Un jeu 3A sur navigateur web : à quelle distance d’un véritable jeu 3A commercial ?

6.1 Les limites matérielles et de plateforme des jeux dans le navigateur

La documentation officielle d’Unity est très claire sur les contraintes de la plateforme Web : accès limité au système de fichiers, certaines fonctions de cache indisponibles, multithreading soumis aux contraintes de l’environnement du navigateur, ressources mémoire restreintes, compatibilité variable d’un navigateur à l’autre. Les builds WebGL d’Unity sont avant tout conçus pour les navigateurs de bureau, avec un support limité sur mobile.

La page d’expérience de Saltline confirme ces limites. Elle prévient que l’initialisation peut être lente, que la vitesse de démarrage dépend des performances de l’appareil, qu’il faut vérifier la prise en charge de WebGL 2 et de l’accélération matérielle, et basculer en qualité « Low » en cas de saccades. Franchir la porte d’entrée d’une page web est très simple ; en revanche, faire tourner le jeu de façon fluide dépend toujours du GPU du joueur.

6.2 1,4 Mo : une distribution légère, la charge d’exécution est une autre histoire

La génération procédurale transforme des « assets à télécharger » en « assets calculés à l’exécution ». Les textures sont calculées pixel par pixel en temps réel sur le GPU, la géométrie est construite par le CPU au démarrage : tout ce travail s’accomplit sur la machine du joueur. À ce jour, les développeurs n’ont publié ni temps de lancement standard pour Saltline, ni FPS moyen, ni empreinte VRAM ou mémoire vive ; pour évaluer sa charge d’exécution, il faut mesurer soi-même, en suivant la méthode de la section 5.3.

6.3 L’ampleur d’ingénierie d’un jeu AAA commercial

Un jeu AAA commercial implique en général des moyens financiers, humains et matériels considérables ; l’expression décrit l’échelle de production, sans norme technique de certification unifiée. Un jeu AAA commercial, c’est des dizaines d’heures de contenu, des animations de personnages et des systèmes physiques complexes, de la synchronisation réseau multijoueur, une adaptation multiplateforme, et des années de mises à jour, de maintenance et d’optimisation des tests. La génération procédurale excelle sur les contenus très réguliers — conteneurs, sol, pluie — mais dès qu’il faut des personnages et des scènes narratives longuement peaufinés par les artistes, la production d’assets traditionnelle reste plus adaptée.

6.4 Ce que Saltline démontre vraiment

Ce que Saltline démontre, c’est qu’un modèle d’IA doté de solides capacités de programmation peut, au cours d’un seul processus de génération continu, intégrer la conception des niveaux, la construction des scènes, les shaders, les mécaniques de jeu, la logique de commandes et la génération audio, pour produire un prototype de jeu 3D au style cohérent et directement partageable. Dans le flux de travail traditionnel, les coûts de transition entre outils et postes différents se trouvent ici compressés dans la fenêtre de contexte d’un seul modèle.

En confrontant les données déclarées par le développeur et les prix publics officiels du modèle, on distingue clairement la structure des coûts de cette expérience :

Élément Donnée Source
Temps de développement Environ 8 heures Déclaration de Felix Rieseberg, 2026-11-09
Coût estimé Environ 550 dollars (estimation sur la base des tarifs API) Déclaration de Felix Rieseberg
Tokens en entrée Environ 445 millions, dont une grande partie en cache Déclaration de Felix Rieseberg
Tokens en sortie Environ 2,7 millions Déclaration de Felix Rieseberg
Prix entrée / sortie de Fable 5.2 8 $ / 40 $ par million de tokens Documentation officielle du modèle Anthropic
Prix de lecture du cache de Fable 5.2 0,20 $ par million de tokens Documentation officielle du modèle Anthropic
Fenêtre de contexte / sortie maximale 1M tokens / 128K tokens Documentation officielle du modèle Anthropic

Le prix de lecture du cache étant bien inférieur au prix d’entrée standard, les 445 millions de tokens en entrée ne peuvent pas être convertis directement en coût total sur la base du tarif d’entrée standard. Le développeur n’a pas publié le détail précis de la facture ; les 550 dollars doivent donc être compris comme une estimation du coût d’une expérience de génération.

💰 Conseil sur les coûts : le coût de génération d’un jeu web par IA se concentre sur la phase de développement, les longs contextes et les itérations multiples constituant les principales dépenses. Avant de vous lancer dans une tâche longue, vous pouvez comparer la qualité du code de plusieurs modèles à l’aide d’invites plus courtes via APIYI apiyi.com, puis décider sur quel modèle réaliser une génération prolongée ; la facturation à l’usage facilite le contrôle des coûts d’essai.


7 FAQ – questions fréquentes

Q1 : Un jeu AAA créé par IA qui tourne dans le navigateur, l’image vient-elle du serveur ?

Les graphismes de Saltline sont rendus par le GPU local du joueur. Après avoir téléchargé un fichier HTML d’environ 1,4 Mo, le navigateur exécute la logique du jeu en JavaScript et dessine chaque image via WebGL en sollicitant la carte graphique locale. Les jeux qui transmettent l’image depuis un serveur sont des jeux cloud comme GeForce NOW, ce qui relève d’une autre approche technique.

Q2 : Jouer à Saltline déclenche-t-il des appels au modèle Claude en temps réel ?

Non. Claude Fable 5.2 ne sert qu’à générer le code du jeu pendant la phase de développement. Le miroir GitHub a retiré le script de framework de Claude Artifact ; le jeu démarre avec un simple serveur HTTP, et le fait de jouer ne génère aucun coût d’invocation du modèle.

Q3 : Quelle différence entre Saltline et les modèles de monde IA comme Genie 3 ?

Les règles et les scènes de Saltline sont écrites à l’avance sous forme de code par l’IA, puis exécutées à l’exécution par un pipeline de rendu classique. Genie 3, lui, prédit et génère l’image frame par frame à partir des entrées du joueur, et ses règles sont apprises à partir de données. Dans un cas l’IA écrit un programme, dans l’autre elle génère directement l’image : les deux approches sont techniquement indépendantes.

Q4 : Un jeu AAA web de 1,4 Mo, quelle configuration faut-il pour qu’il tourne fluidement ?

Le développeur n’a publié ni configuration minimale ni chiffres de FPS. La page officielle recommande de vérifier que le navigateur prend en charge WebGL 2 et que l’accélération matérielle est activée, puis de passer en qualité Low en cas de saccades. Pour des mesures concrètes, mieux vaut utiliser le script de temps de frame de la section 5.3 de cet article sur son propre appareil.

Q5 : Comment générer soi-même un jeu 3D web similaire via API ?

Inscrivez-vous sur APIYI apiyi.com et récupérez une clé API, définissez `base_url` dans le code de la section 5.2 sur `https://api.apiyi.com/v1`, choisissez un modèle à l’aise avec de longues sorties de code, et précisez dans l’invite : « fichier HTML unique, Three.js, tous les assets générés par du code et des shaders ». Une fois le résultat généré, ouvrez-le avec un serveur HTTP local pour tester.

Q6 : Quelles sont les limites des jeux de navigateur générés par IA ?

La longueur de sortie d’un seul appel est limitée ; un jeu complexe demande plusieurs passes avec de longues fenêtres de contexte, et le coût augmente en conséquence. Le code généré nécessite souvent du débogage sur les performances et la compatibilité. Le navigateur impose aussi ses propres limites : mémoire, threads, support mobile. Mieux vaut commencer par comparer plusieurs modèles à petite échelle via APIYI apiyi.com, repérer celui dont le code est le plus stable, puis passer à une échelle supérieure.


8 Points clés : l’IA et les jeux AAA sur le web

  • Où ça tourne : Saltline fonctionne dans le navigateur du joueur, et c’est le GPU local qui assure le rendu.
  • Une répartition claire des rôles : l’IA écrit le code pendant la phase de développement, puis le navigateur exécute ce code au moment de l’exécution.
  • La chaîne technique : JavaScript gère la logique, Three.js assemble la scène et WebGL pilote le GPU.
  • Le secret de la taille : les modèles, les textures et les sons sont tous écrits sous forme de fonctions ; le fichier unique fait environ 1,4 Mo.
  • Un petit fichier ne signifie pas une exécution légère : les assets procéduraux transforment le coût de téléchargement en coût de calcul à l’exécution.
  • Trois approches : l’exécution locale dans le navigateur, le cloud gaming et les modèles de monde IA n’ont pas le même emplacement de calcul.
  • Vérifier par soi-même : on peut appeler plusieurs modèles via APIYI apiyi.com pour générer un jeu Three.js en un seul fichier, puis le tester en conditions réelles.

9 Conclusion

Un jeu de style AAA réalisé par l’IA peut tourner sur le web grâce aux capacités 3D déjà présentes dans le navigateur et à la génération procédurale. Trois points essentiels :

  1. Le navigateur est l’environnement d’exécution du moteur de jeu : la combinaison de JavaScript, Three.js et WebGL permet à une page web d’appeler directement le GPU local pour rendre une scène 3D.
  2. Le coût de l’IA se concentre pendant le développement : une fois généré, Saltline fonctionne indépendamment de Claude ; le coût d’environ 550 dollars cité par le développeur est une estimation ponctuelle.
  3. Les 1,4 Mo règlent surtout le problème de distribution : la mémoire et la charge GPU à l’exécution restent supportées par l’appareil du joueur ; Saltline se positionne comme un prototype 3D jouable construit rapidement.

Si vous voulez tester vous-même le processus « l’IA écrit le jeu, le navigateur exécute le jeu », je vous recommande d’utiliser APIYI apiyi.com avec la même interface compatible OpenAI pour comparer les résultats de différents modèles sur la génération de code Three.js, puis de mesurer les résultats avec le script de temps de frame de cet article.


📚 Références

  1. Page d’essai indépendante de Saltline : point d’entrée pour tester le jeu, chargement, qualité graphique et instructions de manipulation
  2. Lien : saltline.games
  3. Description : inclut les indications officielles sur le temps d’initialisation, WebGL 2 et l’accélération matérielle

  4. Miroir de code et README de Saltline : version HTML mono-fichier

  5. Lien : github.com/realcodebear/saltline-fable-5.2
  6. Description : documente le processus de portage de l’Artifact, la structure du fichier et la dépendance externe aux Google Fonts

  7. Dépôt GitHub de la version chinoise Jimao : version emballée en chinois de Saltline

  8. Lien : github.com/Megasu/jimao-3a-game
  9. Description : fournit la taille des fichiers, l’exécution hors ligne et les exigences navigateur

  10. Spécifications et tarifs du modèle Claude Fable 5.2 : documentation officielle Anthropic

  11. Lien : platform.claude.com/docs/en/models/fable-5-2/overview
  12. Description : tarifs d’entrée, de sortie, de cache et fenêtre de contexte

  13. MDN WebGL API : documentation de l’interface de rendu GPU du navigateur

  14. Lien : developer.mozilla.org/en-US/docs/Web/API/WebGL_API
  15. Description : ressource de référence pour comprendre le fonctionnement de WebGL

  16. Documentation officielle Three.js : bibliothèque graphique 3D pour le Web

  17. Lien : threejs.org/docs
  18. Description : documentation des API Scene, Mesh, ShaderMaterial, InstancedMesh, etc.

  19. Limites techniques d’Unity WebGL : restrictions de la plateforme de jeux dans le navigateur

  20. Lien : docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html
  21. Description : restrictions concernant le système de fichiers, les threads, la mémoire et la prise en charge du mobile

  22. Configuration système requise pour NVIDIA GeForce NOW : exigences réseau du cloud gaming

  23. Lien : nvidia.com/en-us/geforce-now/system-reqs
  24. Description : recommandations de bande passante et de latence selon la qualité graphique et la fréquence d’images

  25. Epic Games Pixel Streaming : diffusion de rendu depuis le cloud

  26. Lien : dev.epicgames.com/documentation/unreal-engine/pixel-streaming-in-unreal-engine
  27. Description : documentation officielle sur la transmission des images d’Unreal Engine vers le navigateur via WebRTC

  28. Annonce technique de Genie 3 : modèle de monde de Google DeepMind

    • Lien : deepmind.google/blog/genie-3-a-new-frontier-for-world-models
    • Description : capacités et limites de la génération d’environnements interactifs en temps réel

Auteur : équipe technique APIYI
Échanges techniques : n’hésitez pas à nous contacter depuis la page d’accueil du site officiel APIYI ; pour davantage de ressources sur l’intégration de modèles, consultez le centre de documentation docs.apiyi.com

Articles connexes

Publications similaires