Nota del autor: Saltline ejecuta el código del juego en el navegador y delega el renderizado a la GPU local del jugador. Los assets procedurales más WebGL explican por qué un archivo web de unos 1,4 MB puede mostrar una escena completa de shooter en 3D.
Que un «juego 3A» hecho por IA pueda correr en el navegador se explica por tres razones. Primero, los navegadores modernos son ya de por sí un entorno completo para ejecutar programas 3D: JavaScript mueve la lógica del juego, Three.js organiza la escena y WebGL le entrega el trabajo de dibujo a la GPU del ordenador del jugador. Segundo, lo que produce la IA durante el desarrollo es un programa de juego; una vez terminado, toda la ejecución queda en manos del navegador y, mientras el jugador juega, ya no se invoca ningún modelo de IA. Tercero, en Saltline los modelos, las texturas y el sonido se generan por código: un único archivo HTML de unos 1,4 MB, abres la página y entras al juego.
Ese «3A» es el objetivo visual que el desarrollador le puso a la IA, a modo de analogía con cierto estilo gráfico. Saltline en sí es un prototipo jugable y de pequeña escala, con una sola fase.
A continuación arrancamos desde el caso de Saltline para aclarar dónde se ejecuta realmente el juego. Después desarmamos la cadena técnica con la que el navegador renderiza escenas 3D, explicamos por qué la generación procedural consigue comprimir el archivo hasta 1,4 MB y ponemos frente a frente tres rutas: ejecución local en el navegador, cloud gaming y modelos de mundo de IA. Para cerrar, incluimos código que puedes ejecutar tal cual, te llevamos a generar y medir con IA una escena 3D web, y comentamos la distancia real que hay entre un juego de navegador y un 3A comercial.

Para entender: terminología de los juegos AAA para navegador con IA
| Término | Explicación |
|---|---|
| JavaScript | Lenguaje de programación que ejecuta el navegador; la lógica del juego de Saltline está escrita con él |
| Three.js | Biblioteca de gráficos 3D en JavaScript que se usa para construir escenas, cámaras, luces y objetos |
| WebGL | Interfaz gráfica que ofrece el navegador y permite que las páginas web usen la GPU del dispositivo para dibujar imágenes 3D |
| WebGPU | Nueva generación de interfaz gráfica y de cómputo del navegador, con capacidades más modernas; Saltline no depende de ella |
| WebAssembly (Wasm) | Bytecode de bajo nivel que el navegador puede ejecutar, lo que permite que programas como C++ o Rust se ejecuten a alta velocidad en la web |
| GPU | Procesador gráfico, especializado en procesar en paralelo grandes cantidades de píxeles y vértices |
| Shader | Pequeño programa que se ejecuta en la GPU y calcula la posición de cada vértice o el color de cada píxel |
| Generación procedural | Construir contenido de juego mediante reglas y funciones matemáticas, en lugar de imágenes y archivos de modelos ya preparados |
| Instancing (renderizado por instancias) | Dibujar una gran cantidad de objetos con la misma forma mediante una sola llamada de dibujo; por ejemplo, filas de contenedores |
| Tiempo de fotograma | Tiempo necesario para renderizar un fotograma; 60FPS corresponden a aproximadamente 16.67 milisegundos por fotograma |
| Juego en la nube | El juego se ejecuta en servidores remotos y transmite las imágenes al jugador en forma de vídeo en streaming |
| WebRTC | Tecnología del navegador para transmitir audio y vídeo en tiempo real; los juegos en la nube suelen usarla para enviar la imagen y la entrada |
| Modelo del mundo | Modelo de IA que aprende los patrones de cambio del entorno y, a partir de la entrada del jugador, predice y genera las escenas siguientes |
1 Por qué un juego AAA hecho por IA solo necesita abrir una página web: el caso de Saltline
1.1 Qué tipo de juego web con IA es Saltline
El 9 de noviembre de 2026, el ingeniero de Anthropic Felix Rieseberg hizo público un experimento de programación con Claude Fable 5.2. Solo le dio al modelo una indicación: crear un shooter en primera persona de pequeña escala cuya calidad visual se acercara lo más posible a la de un juego AAA, sin proporcionar retroalimentación humana en ningún momento. El producto final fue Saltline.
La escena del juego se desarrolla en un puerto de contenedores en una noche lluviosa, con almacenes, muelles y pilas de contenedores. El jugador debe apagar tres estaciones repetidoras de señal y evacuarse; entre los enemigos hay drones de patrulla aérea y sabuesos mecánicos terrestres. El juego incluye movimiento en primera persona, control de cámara, disparos, interacción y objetivos de misión, además de lluvia, iluminación, sonido ambiental y efectos de armas. La página ofrece ajustes de calidad gráfica, incluida una opción de baja calidad.
Según lo que el propio desarrollador contó en X, el experimento tomó aproximadamente 8 horas y, según los precios de la API, el coste estimado fue de unos 550 dólares. Consumió aproximadamente 445 millones de tokens de entrada (gran parte en caché) y unos 2,7 millones de tokens de salida. Estas cifras son estimaciones reportadas por el desarrollador, no facturas auditadas por terceros.
La denominación «几猫·国产3A大作» que después circuló en plataformas sociales chinas corresponde a la versión china, o a una versión reempaquetada, de Saltline; «国产3A大作» (literalmente, «obra maestra AAA de producción nacional») fue el nombre que se le dio durante la difusión.
1.2 Un solo archivo de 1,4 MB contiene todo un juego de estilo AAA
La versión HTML independiente de Saltline consta de un único index.html; el tamaño registrado en el repositorio de GitHub es de 1.425.707 bytes, aproximadamente 1,43 MB (1,36 MiB). El archivo contiene el código central necesario para ejecutar el juego; el código de ejecución de Three.js también viene empaquetado dentro. El juego no tiene archivos separados de modelos 3D, texturas ni efectos de sonido.
A modo de comparación, los paquetes de instalación de los juegos 3D tradicionales suelen incluir grandes cantidades de modelos, texturas de alta resolución, animaciones, efectos de sonido y datos de escena. Saltline sustituyó todos esos recursos por «código que genera los recursos», y esa es la razón fundamental de su tamaño reducido; lo veremos en detalle en la sección 3.
1.3 El juego Saltline se ejecuta realmente en el dispositivo del jugador
La IA solo participa en la fase de desarrollo. La réplica de Saltline en GitHub lo demuestra: la versión original era un Claude Artifact; al portarla, se eliminó el script de ejecución del framework Artifact, se conservó el código del juego, se añadieron la declaración DOCTYPE, el juego de caracteres y la declaración de viewport, y después basta con lanzarlo mediante un servidor HTTP local.
Esto demuestra que la lógica del juego está completamente separada de la interfaz de conversación de Claude. Cuando el jugador abre la página web, el navegador lee el HTML, ejecuta JavaScript, inicializa WebGL y la GPU local dibuja cada fotograma; en todo el proceso no participa ningún modelo de IA en la inferencia.
Cabe añadir un detalle: la descripción de la réplica menciona que las fuentes todavía se cargan desde Google Fonts. La descripción precisa es que el programa principal del juego Saltline se ejecuta localmente, la escena, las texturas y el sonido se generan con código local, y para las fuentes existe una dependencia de carga externa.
2 Cómo el navegador se convierte en el entorno de ejecución 3D de los juegos 3A con IA
Los navegadores modernos no solo parsean HTML: también pueden invocar interfaces gráficas, ejecutar código de alto rendimiento, gestionar memoria y procesar audio y video. Saltline utiliza una de las combinaciones más comunes: JavaScript + Three.js + WebGL.
2.1 JavaScript se encarga de la lógica del juego web
JavaScript es el «cerebro» del juego. Dónde patrullan los enemigos, si las balas aciertan, si la estación de retransmisión está apagada, si el jugador puede evacuar: todas estas reglas se escriben como código JavaScript, que el motor de JavaScript del navegador ejecuta en la CPU.
Para tareas de cálculo más pesadas, el navegador también ofrece WebAssembly. Cuando motores como Unity exportan versiones web, compilan parte del programa a WebAssembly para mejorar la velocidad de ejecución. WebAssembly se encarga de la ejecución del programa, mientras que la renderización de imágenes sigue a cargo de WebGL; ambos pueden trabajar juntos. Saltline se apoya principalmente en JavaScript para completar la lógica.
2.2 Three.js organiza la escena 3D
Escribir una escena 3D directamente con WebGL implica lidiar con un montón de detalles de bajo nivel. Three.js encapsula esos detalles en objetos intuitivos:
- Scene: el contenedor de la escena, donde se colocan todos los objetos y luces
- Camera: la cámara; en un juego en primera persona, son los ojos del jugador
- Geometry: la estructura geométrica, que define las formas de los contenedores y del almacén
- Material: el material, que determina si una superficie parece metal o hormigón
- Mesh: el objeto visible que resulta de combinar geometría y material
- Light: las luces, como las farolas y luces de advertencia del puerto en una noche de lluvia
- Renderer: el renderizador, que entrega todo lo anterior a la GPU para dibujarlo
La biblioteca de ejemplos oficiales de Three.js también muestra capacidades como animación esquelética, mapeado de sombras, efectos de posprocesado y renderizado por instancias. Entre ellas, Instancing resulta especialmente útil para la escena del puerto: cientos o miles de contenedores similares pueden compartir una misma geometría, cambiando solo los parámetros de posición y color, y completarse con una sola llamada de dibujo, lo que alivia notablemente la carga del navegador.
2.3 WebGL delega el trabajo de dibujo a la GPU local
WebGL es la interfaz gráfica que el navegador pone a disposición de JavaScript, construida sobre tecnologías relacionadas con OpenGL ES. Su flujo de trabajo es muy directo: el código del juego llama a WebGL mediante JavaScript, WebGL envía las instrucciones de dibujo a la GPU, la GPU calcula la imagen y el navegador la muestra en la página.
La clave está en que esa GPU es la tarjeta gráfica del ordenador del jugador. Cada fotograma de Saltline se calcula en el dispositivo del jugador; la red solo se encarga de entregar inicialmente el archivo de 1.4 MB al navegador. Por eso la página oficial de Saltline recomienda a los jugadores que se quedan atascados en la pantalla de carga que comprueben WebGL 2 y la aceleración de hardware del navegador.
2.4 Shader, materiales e iluminación: cómo se forma el aspecto de una escena 3D
El aspecto de una escena 3D está determinado por cuatro elementos: el modelo aporta la forma, el material aporta las propiedades de la superficie, la iluminación aporta luces y sombras, y el shader calcula todos esos factores hasta obtener el color final de cada píxel.
Los shader se ejecutan en la GPU y se dividen en dos tipos. El shader de vértices calcula la posición de cada vértice en pantalla; el shader de fragmentos calcula el color de cada píxel. Tomando como ejemplo el contenedor de una noche lluviosa, el shader de fragmentos puede usar funciones matemáticas para calcular las franjas de la chapa ondulada, las manchas de óxido y los reflejos de una superficie mojada, sin necesidad de usar una textura dibujada de antemano.
2.5 Bucle de juego web: procesar la entrada y refrescar la imagen continuamente
La diferencia entre un juego y una página web estática es que el juego tiene que redibujar la imagen decenas de veces por segundo. El navegador ofrece la interfaz requestAnimationFrame, que llama al código del juego antes de cada refresco de pantalla, formando el bucle de juego:
- Leer la entrada de teclado, ratón o pantalla táctil (Saltline necesita hacer clic en el área del juego para obtener control del ratón)
- Actualizar el estado del juego: posición del jugador, comportamiento de los enemigos, trayectoria de las balas
- Llamar al renderizador de Three.js y, a través de WebGL, hacer que la GPU dibuje el nuevo fotograma
- El navegador muestra la imagen y espera el siguiente refresco

3 Por qué 1.4MB puede generar una escena completa de estilo AAA: generación procedural
3.1 Modelos, texturas y sonidos escritos como funciones
En una aclaración del 10 de noviembre, Felix Rieseberg explicó que todo el contenido del juego es código: las texturas y los modelos son funciones, y no hay imágenes ni recursos de modelos 3D independientes. Claude genera el código y los shaders que construyen ese contenido.
Si lo comparamos con el método tradicional, la diferencia salta a la vista:
- Texturas: en el método tradicional, se descarga una imagen de textura de contenedor y se pega encima; en el método procedural, la superficie metálica se calcula en tiempo real con funciones de ruido, variaciones de color y shaders.
- Modelos: en el método tradicional, se importa un archivo de modelo creado en software de modelado; en el método procedural, se construyen en tiempo de ejecución con vértices y parámetros geométricos.
- Sonidos: en el método tradicional, se carga un archivo de audio pregrabado; en el método procedural, se sintetiza en tiempo real con la API de audio del navegador.
Lo que se guarda en el archivo son las “reglas de generación”; la imagen final solo se calcula en tiempo de ejecución. Por lo general, las reglas son mucho más pequeñas que el resultado: un shader de unas pocas decenas de líneas basta para cubrir la textura del suelo de todo un puerto.
3.2 Distinguir entre tamaño de archivo, memoria en ejecución y carga computacional
La clave para entender los 1.4MB es separar estos conceptos:
| Concepto | Qué mide | Situación de Saltline |
|---|---|---|
| Tamaño del archivo | Cuánto código y cuántos recursos hay que descargar | Unos 1.4MB, distribución muy ligera |
| Memoria en tiempo de ejecución | Cuánta memoria y VRAM ocupa durante la ejecución | La escena se genera en tiempo de ejecución; no hay datos oficiales publicados |
| Carga computacional | Cuánto trabajo realizan la CPU y la GPU en cada fotograma | Depende de los ajustes de calidad y del dispositivo; no hay datos oficiales publicados |
| Tiempo de inicialización | Tiempo desde que se abre la página hasta que se puede interactuar | La documentación oficial indica que hay que construir el puerto, los almacenes, la iluminación y el sonido; el tiempo depende del dispositivo |
La generación procedural cambia cálculo en tiempo de ejecución por menor volumen de descarga. Un programa de 1.4MB puede crear una gran cantidad de geometría, materiales y texturas durante la ejecución, y la GPU sigue teniendo que hacer muchos cálculos de shader en cada fotograma. La página oficial de Saltline también advierte claramente que el tiempo que tarda en aparecer el botón START depende del dispositivo del jugador, y que, si hay tirones, se puede cambiar a la calidad Low.

3.3 La arquitectura de archivo único hace que la distribución sea extremadamente ligera
El valor del HTML de archivo único está en la distribución. Se puede alojar en cualquier servicio de hosting estático o descargar en local y abrir con un servidor HTTP; para compartirlo, basta con un enlace. El repositorio de GitHub de la versión china de “几猫” ofrece directamente accesos para probarlo en línea y descargarlo, y aclara que puede ejecutarse sin conexión (salvo la carga de fuentes).
Este formato resulta especialmente adecuado para prototipos generados por IA. El modelo entrega un archivo completo de una sola vez, el desarrollador no tiene que lidiar con pipelines de assets, herramientas de empaquetado ni configuración de servidores, y, en cuanto se genera, puede enviárselo a otra persona para que lo pruebe.
4 Tres rutas tecnológicas diferentes para ejecutar juegos AAA en la web
Cuando hablamos de «jugar en la web» hay en realidad tres rutas tecnológicas cuyo modelo de cómputo es completamente distinto. Solo entendiéndolas bien podrás comprender con precisión qué es Saltline.
4.1 Ejecución local en la web: la ruta de Saltline
La IA genera código, el código se envía al jugador y el navegador ejecuta la lógica en local y renderiza las imágenes con la GPU del propio dispositivo. El equipo del jugador asume la mayor parte del cómputo; durante la ejecución del juego no hace falta conectarse al modelo de IA, y una vez descargados los archivos existe la posibilidad de jugar sin conexión. El precio a pagar: el rendimiento depende por completo del equipo y del navegador del jugador.
4.2 Juego en la nube: el enfoque de GeForce NOW y Pixel Streaming
El juego se ejecuta en servidores remotos, la GPU en la nube renderiza la imagen y luego la transmite al navegador como un video en streaming. El navegador solo se encarga de mostrar el video, reproducir el audio y enviar de vuelta al servidor lo que introduce el jugador.
Pixel Streaming de Epic Games permite que las aplicaciones de Unreal Engine se ejecuten en la nube o en un equipo remoto, transmitiendo imagen y audio al navegador mediante WebRTC. NVIDIA GeForce NOW es un servicio de juego en la nube orientado a los jugadores, y los requisitos de red oficiales para el navegador son: al menos 15 Mbps para 720p/60FPS, al menos 25 Mbps para 1080p/60FPS y al menos 35 Mbps para 1440p/120FPS, con una latencia recomendada inferior a 80 ms. Este enfoque reduce el requisito de hardware local, a cambio de una dependencia constante de la red.
4.3 Modelos de mundo de IA: el enfoque de Genie 3
Los modelos de mundo no codifican de antemano los escenarios y las reglas; en su lugar, a partir del estado actual y de la entrada del jugador, predicen y generan el siguiente fragmento de imagen. En agosto de 2025, Google DeepMind presentó Genie 3, y según lo publicado oficialmente, puede generar en tiempo real entornos explorables en 720p y hasta 24 FPS, manteniendo la coherencia de la escena durante varios minutos. Muse/WHAMM de Microsoft y Oasis de Decart también exploran esta dirección.
En enero de 2026, Project Genie, construido sobre Genie 3, abrió su fase de acceso experimental, en una primera etapa dirigida a suscriptores de Google AI Ultra mayores de 18 años en Estados Unidos, con un límite de 60 segundos por cada experiencia de generación. Este enfoque se encuentra actualmente en fase de investigación y de prototipo de producto, y no tiene relación con la tecnología que utiliza Saltline.
4.4 Comparación de las tres rutas

| Dimensión de comparación | Ejecución local en el navegador | Juego en la nube | Modelo del mundo de IA |
|---|---|---|---|
| Caso representativo | Saltline | GeForce NOW, Pixel Streaming | Genie 3 |
| Lógica del juego | Ejecución de código previamente escrito en local | Ejecución de código previamente escrito en la nube | El modelo aprende la dinámica del entorno a partir de datos |
| Generación de imágenes | Renderizado con GPU local | Renderizado con GPU en la nube | Generación por IA en tiempo real |
| Papel del navegador | Entorno de ejecución del juego | Terminal de vídeo e interacción | Punto de entrada de interacción |
| Dependencia de red | Tras la primera carga, funciona prácticamente sin conexión | Conexión continua, requiere bastante ancho de banda y baja latencia | Normalmente requiere conexión continua |
| Requisitos de hardware local | Relativamente altos | Relativamente bajos | Depende de cómo se despliega el modelo |
| Momento en que se produce el coste de IA | Concentrado en la fase de desarrollo | Sin inferencia de IA, consumo continuo de GPU en la nube | Inferencia continua en cada partida |
La estructura de costes es la diferencia más práctica entre las tres. Saltline concentra el coste de IA en un único desarrollo; después, el renderizado corre a cargo del dispositivo del jugador, y la estimación de 550 dólares no crece con el número de jugadores. Los juegos en la nube y los modelos del mundo, en cambio, consumen capacidad de cómputo del servidor de forma continua cada vez que se juega.
5 Práctica: generar y ejecutar una escena 3D web con IA
La forma más rápida de entender los fundamentos es ejecutarlo uno mismo. Esta sección se divide en tres pasos: primero ejecutar una escena procedural escrita a mano, luego usar la API para que un Modelo de Lenguaje Grande genere un juego de un solo archivo y, por último, medir su tiempo de fotograma.
5.1 Escena procedural mínima funcional en Three.js
Este archivo dibuja 400 contenedores con Instancing: las franjas corrugadas y las manchas de óxido de cada contenedor se calculan en tiempo real con un shader, sin usar ningún archivo de imagen en todo el proceso. Guárdalo como index.html, ejecuta python3 -m http.server 8000 en el mismo directorio y abre http://localhost:8000 en el navegador.
<!DOCTYPE html>
<html lang="zh">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Puerto de contenedores procedural</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);
// Material procedural: franjas corrugadas + manchas de óxido con ruido + luz direccional 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)); // franjas corrugadas
float rust = smoothstep(0.82, 1.0, hash(floor(vUv * 40.0))); // manchas de óxido
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: dibuja 400 contenedores en una sola llamada de dibujo
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);
// Bucle de juego: actualiza la cámara y renderiza en cada 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>
Este código condensa la idea central de Saltline: la geometría se construye con BoxGeometry, la apariencia se calcula mediante Shader y los objetos repetidos en masa se dibujan con Instancing. Todo el archivo ocupa solo unos pocos KB y Three.js se carga desde el CDN; Saltline, en cambio, empaqueta Three.js directamente dentro del HTML.
5.2 Generar con la API un juego 3D de un solo archivo usando un Modelo de Lenguaje Grande
El proceso de generación de Saltline es una programación agéntica prolongada y de múltiples rondas, que consumió cientos de millones de tokens. Los desarrolladores individuales pueden empezar con una sola llamada y pedir al modelo que genere un pequeño juego de Three.js de un solo archivo y ejecutable, para experimentar la división de tareas de «la IA escribe el programa y el navegador lo ejecuta». El siguiente código usa la interfaz compatible con OpenAI; sustituye el nombre del modelo por uno de la lista de modelos de la plataforma que admita salidas de código extensas.
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # Interfaz compatible con OpenAI de APIYI
)
resp = client.chat.completions.create(
model="YOUR_MODEL_NAME", # 以平台模型列表为准
messages=[{"role": "user", "content": "用 Three.js 写一个单文件 HTML 第一人称小游戏,所有模型和纹理用代码与 Shader 生成,只输出完整 HTML。"}],
)
open("game.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
Ver el código de implementación completo (incluye limpieza de bloques de código y restricciones de la indicación)
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:
"""Elimina las marcas de bloque de código ```html con las que el modelo podría envolver la respuesta"""
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",
)
El archivo generado sigue la misma lógica de ejecución que Saltline: la llamada a la API solo ocurre en el momento de la generación; después, puedes abrir game.html y jugar tantas veces como quieras sin generar más costes de modelo.
🚀 Consejo para empezar rápido: si quieres comparar cómo escriben juegos de Three.js distintos modelos, puedes usar APIYI apiyi.com con la misma clave API para cambiar entre Claude, GPT, Gemini y otros modelos. La interfaz es compatible con OpenAI y en el código anterior solo tienes que cambiar el parámetro
model. Los usuarios nuevos tienen crédito de prueba gratuito, ideal para validar la calidad de generación con una indicación breve.
5.3 Medir el rendimiento real de un juego 3D en el navegador
Los 1,4 MB solo responden a «qué tan rápido se descarga». Para determinar si un juego web puede ejecutarse o no, hay que medir estos indicadores:
| Indicador | Objetivo de la medición | Método de medición |
|---|---|---|
| Tiempo hasta la primera interacción | Experiencia de inicio | Desde que se abre la página hasta poder controlar al personaje, se puede marcar con la Performance API |
| FPS / tiempo por fotograma | Fluidez y estabilidad | 60 FPS equivalen a unos 16,67 ms por fotograma; hay que vigilar la variación del tiempo por fotograma |
| Uso de CPU | Carga de la lógica del juego | Observar el hilo principal en el panel Performance de Chrome DevTools |
| Uso de GPU y memoria de vídeo | Carga de renderizado | Administrador de tareas del sistema o herramientas de monitorización de la tarjeta gráfica |
| Memoria del sistema | Recursos en tiempo de ejecución | Observar la memoria del proceso del navegador una vez completada la inicialización de la escena |
| Tráfico de red después de la carga | Dependencias externas | Panel Network de DevTools, distinguiendo solicitudes de fuentes, programas, etc. |
Si pegas el siguiente código en la consola del navegador, puedes calcular el tiempo medio por fotograma y el fotograma más lento en un intervalo de 10 segundos:
(() => {
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);
})();
Al realizar la prueba, hay que fijar la versión del navegador, el sistema operativo, el modelo del dispositivo, la resolución y el nivel de calidad gráfica. La medición debe cubrir escenarios en los que coincidan el movimiento del jugador, la actividad de los enemigos, los disparos y los efectos de lluvia; medir solo la escena vacía justo al entrar en el juego dará resultados demasiado optimistas.
6 ¿Cuánto le falta a un juego 3A de navegador para ser un verdadero 3A comercial?
6.1 Limitaciones de hardware y plataforma a las que se enfrentan los juegos de navegador
La documentación oficial de Unity deja claras las limitaciones de la plataforma Web: el acceso al sistema de archivos es restringido, algunas funciones de caché no están disponibles, el multihilo está condicionado por el entorno del navegador, los recursos de memoria son limitados y la compatibilidad varía entre navegadores. Las compilaciones WebGL de Unity están pensadas principalmente para navegadores de escritorio, y el soporte en dispositivos móviles es limitado.
La página de experiencia de Saltline confirma estas limitaciones. La página advierte que la inicialización puede ser lenta, que la velocidad de arranque depende del rendimiento del dispositivo, que hay que comprobar WebGL 2 y la aceleración por hardware, y que, si hay tirones, conviene cambiar a la calidad Low. El umbral para abrir la página web es muy bajo, pero el umbral para que funcione con fluidez sigue dependiendo de la GPU del jugador.
6.2 1.4MB solo indica que la distribución es ligera; la carga de ejecución es otro tema
La generación procedural transforma la «descarga de recursos» en «cálculo de recursos en tiempo de ejecución». Las texturas se calculan píxel a píxel en tiempo real en la GPU, la geometría se construye en la CPU durante la inicialización, y todo ese trabajo ocurre en el dispositivo del jugador. Por ahora, los desarrolladores no han publicado el tiempo de inicio estándar de Saltline, los FPS promedio ni el consumo de VRAM o memoria; para evaluar su carga de ejecución hay que medirla por cuenta propia siguiendo el método de la sección 5.3.
6.3 La escala de ingeniería de los juegos AAA comerciales
Un juego AAA comercial normalmente implica una enorme inversión de dinero, mano de obra y recursos; esta etiqueta describe la escala de producción y no cuenta con un estándar de certificación técnica unificado. Un juego AAA comercial necesita decenas de horas de contenido, animaciones de personajes y sistemas físicos complejos, sincronización multijugador en red, adaptación multiplataforma, mantenimiento y actualizaciones durante varios años, además de pruebas y optimización continuas. La generación procedural destaca en contenidos con reglas claras, como contenedores, suelos y lluvia; cuando se trata de personajes y escenas narrativas que requieren mucho pulido artístico, la producción tradicional de recursos sigue siendo más adecuada.
6.4 Lo que Saltline realmente demostró
Saltline demuestra que un modelo de IA con sólidas capacidades de programación puede integrar el diseño de niveles, la construcción de escenarios, shaders, mecánicas de juego, lógica de controles y generación de audio en un único proceso continuo de generación, dando como resultado un prototipo de juego 3D con un estilo coherente y listo para compartir. En el flujo tradicional, los costos de traspaso entre distintas herramientas y distintos roles quedan aquí comprimidos en el contexto de un solo modelo.
Si comparamos los datos declarados por el desarrollador con los precios de modelo publicados oficialmente, podemos ver con claridad cómo se compone el costo de este experimento:
| Elemento | Dato | Fuente |
|---|---|---|
| Tiempo de desarrollo | Aprox. 8 horas | Declaración de Felix Rieseberg, 2026-11-09 |
| Costo estimado | Aprox. 550 USD (estimado según precios de API) | Declaración de Felix Rieseberg |
| Tokens de entrada | Aprox. 445 millones, en su mayoría en caché | Declaración de Felix Rieseberg |
| Tokens de salida | Aprox. 2,7 millones | Declaración de Felix Rieseberg |
| Precio de entrada / salida de Fable 5.2 | $8 / $40 por millón de tokens | Documentación oficial del modelo de Anthropic |
| Precio de lectura de caché de Fable 5.2 | $0.20 por millón de tokens | Documentación oficial del modelo de Anthropic |
| Ventana de contexto / salida máxima | 1M tokens / 128K tokens | Documentación oficial del modelo de Anthropic |
El precio de lectura de caché es muy inferior al precio de entrada normal, por lo que los 445 millones de tokens de entrada no pueden convertirse directamente en un costo total usando el precio unitario de entrada normal. El desarrollador no publicó el desglose concreto de la factura, así que los 550 USD deben entenderse como un costo estimado de un experimento de generación.
💰 Sugerencia de costos: El costo de generar un juego web con IA se concentra en la fase de desarrollo, y el contexto largo y las múltiples iteraciones son los principales gastos. Antes de embarcarse en tareas largas, puedes usar APIYI apiyi.com con indicaciones más pequeñas para comparar primero la calidad del código de varios modelos y luego decidir en cuál realizar la generación prolongada; la facturación por consumo facilita el control de los costos de prueba y error.
7 Preguntas frecuentes (FAQ)
Q1: ¿El juego AAA hecho con IA que corre en el navegador transmite los gráficos desde el servidor?
Los gráficos de Saltline se renderizan con la GPU local del jugador. Después de descargar el archivo HTML de aproximadamente 1.4 MB, el navegador ejecuta la lógica del juego con JavaScript y dibuja cada fotograma llamando a la tarjeta gráfica local mediante WebGL. Lo que transmite imágenes desde el servidor son servicios de juego en la nube como GeForce NOW, que pertenecen a otra ruta técnica.
Q2: ¿Se invoca el modelo Claude en tiempo real al jugar Saltline?
No. Claude Fable 5.2 solo genera el código del juego durante la fase de desarrollo. La copia del espejo de GitHub ya ha eliminado el script de framework de Claude Artifact, así que el juego se puede iniciar con un servidor HTTP normal y el proceso de juego no genera costes de invocación del modelo.
Q3: ¿Qué diferencia hay entre Saltline y los modelos de mundo de IA como Genie 3?
Las reglas y los escenarios de Saltline los escribe previamente la IA en forma de código, y en tiempo de ejecución los ejecuta el pipeline de renderizado tradicional. Genie 3 predice y genera los fotogramas uno a uno según la entrada del jugador, y las reglas se aprenden de los datos. En el primer caso la IA escribe programas; en el segundo la IA genera las imágenes directamente. Técnicamente, ambos enfoques son independientes entre sí.
Q4: ¿Qué configuración de PC se necesita para que un juego AAA en web de 1.4 MB funcione con fluidez?
Los desarrolladores no han publicado los requisitos mínimos ni datos de FPS. La página oficial recomienda comprobar que el navegador admite WebGL 2 y que la aceleración por hardware está activada; si hay tirones, cambiar a la calidad Low. Para saber cómo se comporta de verdad, conviene medirlo en tu propio dispositivo con el script de tiempos de fotograma de la sección 5.3 de este artículo.
Q5: ¿Cómo puedo generar por mi cuenta un juego 3D para web similar usando la API?
Regístrate en APIYI apiyi.com y obtén una clave API. En el código de la sección 5.2, establece `base_url` en `https://api.apiyi.com/v1` y elige un modelo bueno para salidas de código extensas. En la indicación, pide de forma explícita «HTML de un solo archivo, Three.js, todos los assets generados con código y Shader». Cuando esté listo, ábrelo con un servidor HTTP local y podrás probarlo.
Q6: ¿Cuáles son las limitaciones de generar juegos para navegador con IA?
La longitud de salida de una sola invocación es limitada; los juegos complejos requieren varias rondas de generación con contextos largos, y el coste sube en consecuencia. El código generado a menudo necesita depurar problemas de rendimiento y compatibilidad. El propio navegador también impone límites de memoria, hilos y soporte en móviles. Se recomienda empezar comparando a pequeña escala varios modelos mediante APIYI apiyi.com, elegir el que tenga la estabilidad de código más alta y luego ampliar el tamaño del proyecto.
8 Puntos clave de los juegos 3A con IA en la web
- Dónde se ejecuta: Saltline se ejecuta en el navegador del jugador y la GPU local se encarga del renderizado.
- División clara del trabajo: la IA escribe el código durante la fase de desarrollo y el navegador ejecuta ese código en tiempo de ejecución.
- Cadena técnica: JavaScript gestiona la lógica, Three.js monta la escena y WebGL llama a la GPU.
- El secreto del tamaño: los modelos, las texturas y los sonidos se escriben por completo como funciones; un único archivo de unos 1,4 MB.
- Un archivo pequeño no significa una ejecución ligera: los recursos procedurales convierten el coste de descarga en coste de cálculo en tiempo de ejecución.
- Tres rutas: la ejecución local en la web, el cloud gaming y los modelos del mundo con IA colocan el cálculo en lugares distintos.
- Verificación práctica: puedes invocar varios modelos a través de APIYI (apiyi.com) para generar juegos Three.js de un solo archivo y probarlos.
9 Resumen
Los juegos de estilo 3A creados con IA pueden ejecutarse en la web gracias a la capacidad de renderizado 3D que los navegadores ya tienen y a la generación procedural. Hay tres puntos clave:
- El navegador es el entorno de ejecución del motor del juego: JavaScript, Three.js y WebGL se combinan para que una página web pueda llamar directamente a la GPU local y renderizar escenas 3D.
- El coste de la IA se concentra en la fase de desarrollo: una vez generado, Saltline funciona de forma independiente, sin Claude; los aproximadamente 550 dólares mencionados por el propio desarrollador son una estimación de coste único.
- Los 1,4 MB resuelven el problema de distribución: la memoria y la carga de GPU en tiempo de ejecución siguen recayendo sobre el equipo del jugador; Saltline es un prototipo 3D jugable construido rápidamente.
Si quieres experimentar de primera mano el flujo de «la IA escribe el juego y el navegador lo ejecuta», te recomendamos usar la misma interfaz compatible con OpenAI a través de APIYI (apiyi.com) para comparar cómo distintos modelos generan código Three.js y, después, medir los resultados con el script de tiempo por fotograma de este artículo.
📚 Referencias
- Página de experiencia independiente de Saltline: punto de entrada para probar el juego, más indicaciones sobre carga, calidad gráfica y controles
- Enlace:
saltline.games -
Descripción: incluye el tiempo de inicialización y las advertencias oficiales sobre WebGL 2 y aceleración por hardware
-
Espejo del código y README de Saltline: versión de un solo archivo HTML
- Enlace:
github.com/realcodebear/saltline-fable-5.2 -
Descripción: documenta el proceso de portabilidad del Artifact, la estructura de archivos y la dependencia externa de Google Fonts
-
Repositorio de GitHub de la versión china de Jimao: edición de Saltline con envoltorio en chino
- Enlace:
github.com/Megasu/jimao-3a-game -
Descripción: detalla el tamaño de los archivos, la ejecución sin conexión y los requisitos de navegador
-
Especificaciones y precios del modelo Claude Fable 5.2: documentación oficial de Anthropic
- Enlace:
platform.claude.com/docs/en/models/fable-5-2/overview -
Descripción: precios de entrada, salida y caché, además de la ventana de contexto
-
MDN WebGL API: documentación de la interfaz de renderizado por GPU del navegador
- Enlace:
developer.mozilla.org/en-US/docs/Web/API/WebGL_API -
Descripción: material de referencia autorizado para entender cómo funciona WebGL
-
Documentación oficial de Three.js: biblioteca de gráficos 3D para Web
- Enlace:
threejs.org/docs -
Descripción: explicaciones de API como Scene, Mesh, ShaderMaterial e InstancedMesh
-
Limitaciones técnicas de Unity WebGL: restricciones de la plataforma de juegos en navegador
- Enlace:
docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html -
Descripción: limitaciones de sistema de archivos, hilos, memoria y soporte móvil
-
Requisitos de sistema de NVIDIA GeForce NOW: requisitos de red para el juego en la nube
- Enlace:
nvidia.com/en-us/geforce-now/system-reqs -
Descripción: recomendaciones de ancho de banda y latencia para distintas calidades gráficas e índices de fotogramas
-
Epic Games Pixel Streaming: transmisión de renderizado en la nube
- Enlace:
dev.epicgames.com/documentation/unreal-engine/pixel-streaming-in-unreal-engine -
Descripción: documentación oficial sobre cómo Unreal Engine envía la imagen al navegador vía WebRTC
-
Anuncio técnico de Genie 3: modelo de mundo de Google DeepMind
- Enlace:
deepmind.google/blog/genie-3-a-new-frontier-for-world-models - Descripción: capacidades y limitaciones en la generación de entornos interactivos en tiempo real
- Enlace:
Autor: equipo técnico de APIYI
Contacto técnico: puedes escribirnos desde la página principal del sitio oficial de APIYI; para más material sobre integración de modelos, visita el centro de documentación docs.apiyi.com
