Nota del autor: Saltline describe con código las reglas de generación de geometría, texturas y sonido, así que el tamaño de distribución es muy pequeño, pero parte del trabajo se traslada al cálculo en tiempo de ejecución en el dispositivo del jugador.
Saltline pesa solo unos 1.4MB porque su único archivo HTML contiene las reglas para generar modelos, texturas y sonido, no modelos ya creados, texturas ya pintadas ni efectos de sonido ya producidos. Cuando el navegador abre el archivo, JavaScript y los shaders construyen en local, en tiempo real, el puerto nocturno bajo la lluvia, los contenedores y los drones. La generación procedural cambia la forma en que se representan y distribuyen los recursos de un juego: el volumen de descarga se reduce drásticamente y, al mismo tiempo, aumenta proporcionalmente el trabajo de la CPU para construir geometría y el de la GPU para calcular píxeles. El tamaño del archivo, la memoria en tiempo de ejecución y la carga de la GPU son tres costos que se contabilizan por separado.
A continuación, primero desgloso la composición de este archivo de 1.4MB; después la comparo con la forma tradicional de producir recursos para videojuegos; luego, con tres ejemplos —contenedores, materiales metálicos y lluvia—, explico cómo funcionan la geometría procedural, las texturas procedurales, los shaders y los efectos de sonido procedurales; a continuación analizo el costo en tiempo de ejecución que se esconde detrás del tamaño reducido; y, por último, incluyo un fragmento de código ejecutable que muestra cómo hacer que un Modelo de Lenguaje Grande genere escenas procedurales similares mediante API.

Para saber: nociones básicas de terminología de juegos 3D procedurales
| Término | Explicación |
|---|---|
| Geometría procedural | Crear vértices y formas de modelos a partir de parámetros y reglas; por ejemplo, generar una caja usando largo, ancho y alto |
| Textura procedural | Calcular colores y patrones de superficie mediante funciones matemáticas, como el ruido |
| Shader | Pequeño programa que se ejecuta en la GPU y determina la posición de cada vértice y el color de cada píxel |
| Función de ruido | Algoritmos como Perlin o Simplex que generan patrones aleatorios naturales e irregulares |
| Renderizado por instancias | Dibujar una gran cantidad de objetos similares en una sola llamada de dibujo; en Three.js equivale a InstancedMesh |
| WebGL | Interfaz gráfica para GPU que ofrecen los navegadores y permite que las páginas web rendericen escenas 3D |
| Three.js | Biblioteca de gráficos 3D para web basada en JavaScript que abstrae conceptos como escena, cámara y materiales |
| HTML | Formato de archivo que organiza el contenido y el código de una página web; todo el código central de Saltline está en un único archivo HTML |
| Tamaño de distribución | Cantidad de datos que el jugador debe descargar |
| Memoria en ejecución | Memoria que ocupa el programa mientras se ejecuta, incluidos la geometría y las texturas generadas en tiempo de ejecución |
| Carga de GPU | Cantidad de cálculo que la tarjeta gráfica debe completar en cada fotograma |
| Token | Unidad básica con la que los Modelos de Lenguaje Grande procesan texto y también la unidad de facturación de la API |
1 Qué hay dentro de un HTML de 1.4MB: la arquitectura de archivo único de Saltline
1.1 Qué tipo de juego 3D generado por IA es Saltline
El 9 de noviembre de 2026, el ingeniero de Anthropic Felix Rieseberg publicó un experimento de programación con Claude Fable 5.2: con una sola indicación, pidió al modelo crear un juego de disparos en primera persona a pequeña escala cuyo aspecto visual se acercara lo máximo posible a un juego AAA, sin proporcionar retroalimentación humana durante el proceso. El resultado es Saltline.
El juego transcurre en un puerto de contenedores durante una noche de lluvia; el jugador debe apagar tres estaciones de retransmisión de señales y retirarse. Los enemigos son drones de patrulla aérea y perros robóticos terrestres. Permite movimiento en primera persona, disparos, interacción y objetivos de misión; incluye lluvia, iluminación, sonido ambiental y efectos de armas, y ofrece ajustes de calidad gráfica. Es un prototipo jugable para un solo jugador y un solo nivel; «3A» es la meta del experimento y una analogía visual. La «几猫·国产3A大作» que circula en redes sociales chinas es una versión china o un reempaquetado de Saltline, y el nombre surgió durante el proceso de difusión.
Los datos que el propio desarrollador declara son los siguientes; todas son estimaciones que él mismo publicó en X y que no han sido auditadas por terceros:
- Tiempo de desarrollo: aproximadamente 8 horas.
- Coste estimado según los precios de la API: aproximadamente 550 dólares.
- Tokens de entrada: aproximadamente 445 millones, con un uso intensivo de la caché.
- Tokens de salida: aproximadamente 2.7 millones.
Dado que una gran parte de los tokens de entrada acertó en la caché, no se puede recalcular esta cuenta simplemente multiplicando el precio unitario estándar de entrada por el total; además, la estructura exacta de la factura tampoco se ha publicado. Esos 550 dólares corresponden a un coste de generación único: cuando los jugadores juegan en el navegador, no se vuelve a invocar el modelo.
1.2 Composición de index.html: Three.js, código generado y fuentes externas
El repositorio espejo de GitHub ofrece datos precisos: el archivo principal index.html pesa 1,425,707 bytes, aproximadamente 1.43MB (1.36MiB). Su composición se puede resumir en cuatro partes:
- Código de ejecución de Three.js: toda la biblioteca 3D está empaquetada dentro del HTML y se encarga de la escena, la cámara, los materiales y el renderizado WebGL;
- Código de generación de escena y recursos: las geometrías, texturas y materiales se construyen mediante funciones JavaScript y shaders;
- Código de audio procedural: el sonido también se sintetiza por código; no hay archivos de audio independientes en el repositorio;
- Lógica del juego: control de entrada, comportamiento de los enemigos y flujo de misiones.
En el repositorio no hay archivos independientes de imágenes, videos ni audio. La única dependencia externa clara es Google Fonts. El 10 de noviembre, el desarrollador añadió una aclaración: todo el contenido del juego es código; las texturas y los modelos son funciones.
1.3 Qué ocurre al abrir Saltline en el navegador
El proceso de ejecución sigue una secuencia local clara: el navegador lee el HTML → JavaScript empieza a ejecutarse → se inicializa el entorno de renderizado de Three.js y WebGL → el código genera la geometría, los materiales, las texturas y el sonido de la escena → la GPU renderiza cada fotograma → el jugador opera con teclado y mouse, y la lógica del juego se actualiza continuamente.
En este flujo, el paso de «generar recursos» ocurre en el dispositivo del jugador. La página oficial de experiencia de Saltline también advierte: la inicialización de la página puede tardar bastante y el rendimiento del dispositivo influye en la velocidad de inicio; si se queda atascado en la pantalla de espera, conviene comprobar WebGL 2 y la aceleración por hardware del navegador; si va a tirones, se puede cambiar a la calidad Low. Estos avisos por sí solos demuestran el peso del cálculo en tiempo de ejecución.

2 Cómo se crean modelos, texturas y sonido en los juegos tradicionales
2.1 Los tres tipos de recursos fundamentales de los juegos 3D tradicionales
La imagen y el sonido de un juego 3D tradicional provienen principalmente de archivos de recursos creados de antemano:
- Archivos de modelo: los artistas los crean en software de modelado y los guardan como datos de vértices, caras, coordenadas UV, etc.;
- Texturas: varias imágenes —mapas difusos, de normales, de rugosidad, de metalicidad, etc.— que se aplican sobre la superficie del modelo para aportar detalle;
- Archivos de sonido: audio grabado o sintetizado y exportado, que se reproduce cuando se dispara un evento específico.
Estos recursos se distribuyen junto con el juego después de crearlos, optimizarlos, comprimirlos y empaquetarlos. El motor los carga en tiempo de ejecución; su trabajo principal es «leerlos y mostrarlos».
2.2 Por qué los recursos tradicionales ocupan tanto espacio
Los recursos prefabricados guardan resultados. Una textura de alta resolución tiene que registrar el valor de color de cada píxel; un modelo detallado debe registrar la posición de cada vértice; un fragmento de audio debe registrar cada punto de muestreo. Cuanto más rico es el escenario y mayor la resolución, más datos de resultado hay que registrar, y el tamaño crece de forma lineal.
El enfoque procedural guarda procesos. Una función de ruido solo necesita unas decenas de líneas de código, pero puede generar patrones de óxido a cualquier resolución; una función paramétrica de caja puede generar contenedores de cualquier tamaño. Esa es la razón fundamental por la que 1.4MB pueden contener una escena de puerto completa.
| Dimensión de comparación | Recursos prefabricados tradicionales | Recursos generados proceduralmente |
|---|---|---|
| Contenido guardado en el archivo | Datos del resultado final (vértices, píxeles, muestras) | Reglas de generación (funciones, parámetros, shaders) |
| Método de producción | Los artistas los crean uno por uno en herramientas profesionales | Se escriben código y parámetros; se calculan en tiempo de ejecución |
| Volumen de distribución | Crece con la cantidad y la precisión de los recursos | Depende principalmente de la cantidad de código; suele ser pequeño |
| Trabajo principal en tiempo de ejecución | Cargar, decodificar, mostrar | Construir geometría, calcular texturas, sintetizar sonido |
| Control del detalle | El artista puede controlar con precisión cada detalle | Depende de la capacidad expresiva del algoritmo; ajustar parámetros cuesta |
| Objetos típicos de aplicación | Personajes, objetos clave, escenarios realistas | Estructuras repetitivas, superficies naturales, efectos climáticos |
3 Cómo la IA genera activos de juego con código: cuatro técnicas procedurales
La generación procedural es una técnica que la industria de los videojuegos lleva usando desde hace mucho tiempo: el terreno de Minecraft y los niveles de muchos roguelikes dependen de ella. La novedad de Saltline es que un modelo de IA escribe, en un único proceso de generación continuo, todo el código de geometría, texturas, shaders, audio y lógica de juego, reduciendo los traspasos de trabajo entre modelado, materiales, efectos de sonido y programación.
| Nivel | Objeto generado | Enfoque técnico | Ejemplo correspondiente en Saltline |
|---|---|---|---|
| Generación de geometría | Formas de modelos | Vértices, caras, geometría paramétrica | Contenedores, almacenes, estructuras de muelle |
| Generación de materiales | Propiedades de superficie | Parámetros de color, rugosidad y metalicidad | Revestimiento metálico de contenedores |
| Generación de texturas | Detalles de superficie | Ruido, fractales, Voronoi | Óxido, manchas, desgaste |
| Generación de entorno | Disposición del escenario | Reglas, números aleatorios, relaciones espaciales | Disposición del apilamiento de contenedores |
| Generación de animaciones | Movimiento de objetos | Funciones matemáticas, cambios de estado | Patrullaje de drones, caída de gotas de lluvia |
| Generación de sonido | Efectos de sonido | Osciladores, filtros, ruido | Sonido de lluvia, disparos, ambiente sonoro |
3.1 Geometría procedural: construir un contenedor con parámetros
Un contenedor no es más que una caja rectangular con paneles laterales corrugados. El enfoque de la geometría procedural consiste en generar un hexaedro a partir de los parámetros de largo, ancho y alto, y luego desplazar los vértices de los laterales según una función sinusoidal para simular las ondulaciones del acero corrugado. En Three.js, BufferGeometry permite escribir directamente en el array de vértices, mientras que BoxGeometry ya nos ofrece una caja parametrizada lista para usar.
En un puerto hay cientos o miles de contenedores, y todos comparten los mismos datos de geometría. En ese caso se recurre al renderizado instanciado con InstancedMesh: basta con guardar por instancia una matriz de transformación (posición, rotación, escala) y un color para dibujar todo el patio de contenedores en una sola llamada de dibujado.
3.2 Texturas procedurales: pintar el óxido con funciones de ruido
Las texturas procedurales generan sus datos mediante algoritmos. Los más habituales son Perlin Noise, Simplex Noise, Voronoi y el ruido fractal: superponiendo varias capas de ruido con frecuencias distintas se consigue una distribución natural de manchas de óxido, y con Voronoi se obtienen bordes en bloque, como de pintura desconchada.
En Three.js, este tipo de texturas se calculan normalmente una sola vez durante la fase de inicialización y se escriben en un DataTexture (rellenando directamente el array de píxeles) o en un CanvasTexture (dibujando con Canvas 2D); después se pasan al material igual que cualquier otro mapa. Una vez generada, la textura queda residente en la memoria de la GPU, así que el coste adicional en tiempo de ejecución es, sobre todo, ese consumo de VRAM.
3.3 Shader: metal y lluvia calculados píxel a píxel en la GPU
Un Shader se ejecuta en la GPU y calcula en tiempo real el color de cada píxel a partir de entradas como las coordenadas, el tiempo y la iluminación. Su diferencia con las texturas procedimentales radica en el momento en que se realiza el cálculo: una textura procedimental puede calcularse de antemano como una imagen completa; un Shader, en cambio, puede recalcular cada fotograma sobre la marcha, sin necesidad de generar una imagen entera.
El puerto en una noche de lluvia es el terreno ideal para un Shader. El reflejo sobre una superficie metálica húmeda, las ondulaciones del agua acumulada en el suelo que se agitan con el paso del tiempo, la caída de las hebras de lluvia: todo puede escribirse como funciones cuya entrada es el tiempo y recalcularse fotograma a fotograma. La ShaderMaterial de Three.js permite escribir directamente el shader de vértices y el shader de fragmentos para conseguir estos efectos. El equilibrio entre ambas vías es directo: una textura pregenerada ocupará memoria y ahorrará potencia de cálculo; un Shader calculado en tiempo real ahorrará memoria y consumirá potencia de cálculo.
3.4 Audio procedimental: sintetizar el sonido de la lluvia con osciladores y filtros
La Web Audio API del navegador ofrece osciladores, búferes de ruido y nodos de filtro. El ruido blanco pasado por un filtro paso bajo se acerca bastante al sonido de la lluvia; una ráfaga breve de ruido con una envolvente de volumen de caída rápida da como resultado un disparo; un oscilador de baja frecuencia que modula el tono puede imitar el zumbido de un dron. En el repositorio de Saltline no hay ningún archivo de audio: todos los sonidos se sintetizan en tiempo real mediante este tipo de código.

4 ¿Archivos más pequeños implican una ejecución más ligera? Análisis de costos de la generación procedural
4.1 Distinguir entre tamaño de distribución, memoria de ejecución y carga de GPU
Para medir el “peso” de un videojuego 3D, hay que fijarse al menos en tres dimensiones:
- Tamaño de distribución: qué cantidad de datos descarga el jugador. Saltline tiene una ventaja enorme en este aspecto;
- Memoria de ejecución: los búferes de vértices, las texturas y los búferes de audio generados en tiempo de ejecución ocuparán memoria RAM y VRAM. Un programa de 1.4 MB puede crear perfectamente cientos de MB de datos durante la ejecución;
- Carga computacional: la cantidad de trabajo que CPU y GPU deben completar en cada fotograma. Los shaders complejos elevan directamente esta cifra.
Por el contrario, un juego de gran tamaño también puede lograr una muy buena eficiencia de ejecución mediante compresión, carga por bloques y streaming de recursos. Juzgar las ventajas y desventajas de un enfoque técnico solo por el tamaño de los archivos conduce a conclusiones sesgadas.
4.2 Dónde traslada el coste la generación procedural
| Técnica | Coste que puede reducirse | Coste que puede aumentar |
|---|---|---|
| Modelo procedural | Descarga y almacenamiento del modelo | Tiempo de construcción geométrica en CPU |
| Texturas de shader | Archivos de imagen y transferencia de texturas | Cálculo en tiempo real por fotograma en GPU |
| Texturas procedurales (pre-generadas) | Descarga de archivos de imagen | Cálculo de inicialización y占用 de memoria de video |
| Renderizado por instancias | Llamadas de dibujado repetidas | Gestión de escena y mantenimiento de datos de instancias |
| Escena generada dinámicamente | Cantidad de assets prefabricados | Cálculo de inicialización y en tiempo de ejecución |
| Efectos de sonido procedurales | Almacenamiento de archivos de audio | Coste de síntesis de audio en tiempo real |
Que Saltline tarde en inicializar y necesite ofrecer una opción de calidad Low es precisamente el reflejo real de esta tabla: el trabajo que te ahorras durante la fase de descarga lo vuelves a pagar durante el arranque y en cada fotograma renderizado.
4.3 El compromiso entre shader, renderizado por instancias y geometría dinámica
Las tres técnicas resuelven problemas distintos, y la combinación de todas funciona mejor:
- El renderizado por instancias reduce el número de llamadas de dibujado que la CPU envía a la GPU, y encaja especialmente bien con grandes cantidades de objetos repetidos, como patios de contenedores, farolas o partículas de gotas de lluvia.
- El shader traslada el cálculo de detalles a la GPU, lo que resulta adecuado para efectos que cambian con el tiempo (lluvia, acumulación de agua, luces parpadeantes). El precio es que cuanto más complejo es el fragment shader, más pesada resulta la carga de GPU a alta resolución.
- La geometría dinámica encaja con estructuras que cambian según parámetros o que tienen una cantidad limitada; el coste de construcción se concentra en la fase de inicialización, y una vez terminada queda como una malla normal.
La dirección de optimización habitual en ingeniería es esta: todo lo que se pueda precalcular se calcula una vez en la inicialización y se guarda en caché; solo lo que realmente debe cambiar con el tiempo entra en el shader de cada fotograma.
4.4 El enfoque de Saltline frente a los juegos en la nube y los modelos de mundo de IA
“La IA aplicada a los juegos” corresponde hoy al menos a tres rutas técnicas, y Saltline se sitúa en la primera.
| Dimensión de comparación | Juegos web locales | Juegos en la nube | Modelos de mundo de IA |
|---|---|---|---|
| Casos representativos | Saltline | GeForce NOW, Pixel Streaming | Genie 3, Muse/WHAMM, Oasis |
| Etapa en la que interviene la IA | Generación de código durante el desarrollo | Normalmente no interviene | Generación de imágenes fotograma a fotograma en tiempo de ejecución |
| Generación de gráficos | Renderizado con GPU local | Renderizado en GPU en la nube y transmisión por flujo de video | Generación predictiva en tiempo real mediante el modelo |
| Requisitos de red | Puede funcionar sin conexión tras la carga inicial | Conexión a internet continua | Normalmente requiere conexión continua |
| Momento en que se incurre en costos | Costo de desarrollo único; después lo asume el dispositivo del jugador | Costos de servidor en cada partida | Costos de inferencia en cada partida |
| Principales limitaciones | Navegador y hardware local | Latencia de red y ancho de banda | Consistencia, latencia y controlabilidad |
Saltline concentra los costos de IA en la fase de desarrollo. Una vez completada la generación, las reglas del juego quedan definidas por el código y la ejecución no depende del modelo. Esto determina que pueda funcionar sin conexión y que el rendimiento del dispositivo del jugador marque el techo de la experiencia.
5 Inicio rápido con juegos 3D procedurales: usar la API para que un Modelo de Lenguaje Grande genere código de escena
5.1 Ejemplo mínimo: generar una escena procedural con una sola invocación
El siguiente script invoca a un Modelo de Lenguaje Grande mediante la interfaz compatible con OpenAI para que genere un archivo HTML único que contenga contenedores procedurales, óxido con ruido y lluvia con Shader. El nombre del modelo debe coincidir con el nombre real que aparece en la lista de modelos de la plataforma:
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # Interfaz unificada de APIYI: una sola clave API para invocar varios modelos
)
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", # Reemplazar por el nombre real del modelo en la plataforma
messages=[{"role": "user", "content": prompt}],
)
open("procedural_port.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
Después de ejecutarlo, abra procedural_port.html en el navegador para ver el resultado. Saltline es un proceso de generación prolongado, de 8 horas y cientos de millones de tokens; este ejemplo solo muestra el ciclo mínimo de esa misma idea.
Ver la implementación completa: código de referencia escrito a mano para contenedores procedurales, óxido con ruido, lluvia con Shader y sonido de lluvia sintetizado
A continuación se muestra una implementación de referencia escrita a mano, para comparar y entender la estructura del código generado por el modelo. Reúne las cuatro técnicas del capítulo 3 en un mismo archivo:
<!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. Textura procedural: ruido de valor multicapa para generar óxido, volcado en un 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. Geometría procedural + renderizado instanciado: 200 contenedores comparten una sola geometría
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 posición de las gotas de lluvia se calcula en la GPU a lo largo del tiempo
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. Sonido procedural: ruido blanco filtrado con paso bajo para simular la lluvia (se activa al hacer clic en la página)
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>
El archivo completo no contiene ni una sola imagen, ni un archivo de modelo, ni un fragmento de audio. La textura de óxido se calcula una vez durante la inicialización (coste de CPU + memoria de video), las posiciones de la lluvia se calculan en cada fotograma en el vertex shader (coste de GPU), y los contenedores se resuelven con una sola llamada de dibujo (reduciendo la sobrecarga de llamadas de CPU).
Consejo para empezar rápido: al generar código de escenas procedurales, los distintos modelos marcan diferencias claras en la precisión de la API de Three.js y en cómo escriben los shaders. Con APIYI apiyi.com puedes cambiar entre varios modelos usando la misma Key y comparar la calidad de salida lado a lado; la cuota de pruebas gratuitas para nuevos usuarios alcanza de sobra para completar varias rondas de comparación.
5.2 Tres trucos prácticos para generar indicaciones
Escribir la indicación como si fuera una especificación técnica funciona mejor que escribirla como una simple declaración de intenciones:
- Especificar los puntos técnicos: exige explícitamente APIs concretas como InstancedMesh, DataTexture, ShaderMaterial, etc. Así el modelo implementará la ruta procedural en lugar de asumir que existen recursos externos;
- Declarar las restricciones: indica «no usar ningún archivo de imagen, modelo o audio» y «HTML de un solo archivo», en línea con las restricciones de Saltline;
- Pedir niveles de rendimiento: haz que el modelo ofrezca conmutación entre calidad baja, media y alta (por ejemplo, reduciendo el número de gotas de lluvia o desactivando las sombras), igual que Saltline ofrece la opción de calidad Low.
5.3 Método de estimación del costo de generación
Tomando como referencia los precios oficiales de Claude Fable 5.2 publicados por Anthropic: entrada 8 USD por millón de tokens, salida 40 USD por millón de tokens, lectura de caché 0.20 USD por millón de tokens, escritura de caché de 5 minutos 10 USD por millón de tokens; ventana de contexto de 1M tokens, salida máxima de 128K tokens. En una generación única como la de la sección 5.1, el uso de tokens suele situarse entre unos pocos miles y decenas de miles. Una iteración autónoma prolongada de 8 horas como la de Saltline relee una y otra vez el código existente, y la diferencia de precio que aporta el acierto de caché influye de forma notable en el costo total; por eso, en tareas largas conviene aprovechar primero la caché de indicaciones.
Consejo sobre costos: Al hacer experimentos de generación de código de larga duración, primero puedes medir el consumo de tokens por ronda con indicaciones de pequeña escala en APIYI apiyi.com, y luego estimar el presupuesto total según el número de iteraciones. La plataforma cobra según el consumo, lo que la hace adecuada para validar el enfoque primero a pequeña escala y después a mayor escala.
6 Preguntas frecuentes (FAQ)
Q1: ¿Qué es un asset 3D de juego generado proceduralmente?
Un asset generado proceduralmente es aquel en el que el código y los parámetros describen las reglas de generación de modelos, texturas y sonido, y el resultado se calcula en tiempo de ejecución. Lo que se guarda en el archivo es «cómo dibujar»; un archivo de asset tradicional guarda «el resultado ya dibujado». Los contenedores, el óxido y el sonido de la lluvia de Saltline pertenecen a esta categoría.
Q2: ¿Cuál es la diferencia entre una textura procedural y un shader?
Una textura procedural genera los datos de textura mediante algoritmos y se puede precalcular como una imagen para colocarla en la memoria de video; un shader es un programa que se ejecuta en la GPU y puede calcular directamente el color de cada píxel en cada fotograma. La primera consume más memoria y menos capacidad de cómputo; el segundo, al contrario. A menudo se combinan ambos enfoques.
Q3: ¿Cuándo se publicó Saltline y qué modelo usó?
Se publicó el 9 de noviembre de 2026 por el ingeniero de Anthropic Felix Rieseberg, usando Claude Fable 5.2, con una sola indicación y sin retroalimentación humana. Las cifras de unas 8 horas, unos 550 dólares, unos 445 millones de tokens de entrada y 2,7 millones de tokens de salida son estimaciones del propio desarrollador. El 10 de noviembre añadió sendas aclaraciones: tanto el modelo como las texturas se generaron íntegramente mediante código.
Q4: ¿Para qué escenarios de juego encaja mejor la generación procedural?
– **Estructuras muy repetitivas**: patios de contenedores, conjuntos de edificios, vegetación; funcionan mejor con renderizado instanciado;
– **Superficies naturales**: materiales como óxido, rocas y vetas de madera que se expresan bien mediante ruido;
– **Clima dinámico y efectos**: efectos que cambian con el tiempo, como lluvia, ondas de agua acumulada o parpadeo de luces;
– **Escenarios de distribución sensibles al tamaño**: minijuegos web, anuncios interactivos, prototipos jugables al instante.
Para protagonistas y objetos clave de la trama que requieren un control artístico preciso, los assets prefabricados siguen siendo más adecuados; lo habitual en proyectos comerciales es adoptar soluciones híbridas.
Q5: ¿Cómo hacer que un Modelo de Lenguaje Grande genere código de escenas 3D procedurales mediante la API?
1. Regístrate en APIYI apiyi.com y obtén una clave API y crédito de prueba gratuito;
2. Con el script de la sección 5.1 de este artículo, configura `base_url` como `https://api.apiyi.com/v1`;
3. En la indicación, especifica restricciones como la API de Three.js, un único archivo y ningún recurso externo; tras generar el código, ábrelo en el navegador para verificarlo.
Como la interfaz es compatible con el formato de OpenAI, para cambiar entre modelos como Claude, GPT o Gemini solo hay que modificar el parámetro `model`.
Q6: ¿Qué limitaciones conocidas tiene la generación procedural?
– **Costo en tiempo de ejecución**: el cálculo de inicialización, el uso de memoria de video y la carga de GPU de los shaders complejos recaen sobre el dispositivo del jugador; Saltline también necesita una opción de calidad Low y un tiempo de inicialización considerable;
– **Restricciones del navegador**: la documentación oficial de Unity señala que la plataforma web está limitada en sistema de archivos, hilos y memoria, y que el soporte móvil es limitado;
– **Control artístico**: la capacidad expresiva de los algoritmos tiene límites; los personajes realistas y los objetos detallados son difíciles de generar solo con código;
– **Madurez de ingeniería**: la IA puede producir rápidamente prototipos jugables, pero la optimización a largo plazo, las pruebas y la ampliación de contenido que exige un juego comercial siguen requiriendo una gran inversión de ingeniería.
7 Juego 3D de 1.4MB y generación procedural: puntos clave
- Origen del tamaño: Saltline ocupa aproximadamente 1.4MB y lo que guarda son reglas de generación; no contiene archivos de imagen, modelos ni audio.
- Cuatro técnicas: geometría procedural, texturas procedurales, shaders y efectos de sonido procedurales; cada una se encarga de una capa, con una división clara.
- Transferencia de costos: se reduce el tamaño de descarga, mientras aumentan la construcción en CPU, el uso de memoria de video y el cálculo por fotograma en GPU.
- Dimensiones de evaluación: hay que considerar a la vez el tamaño de distribución, el tiempo de inicialización, la memoria en ejecución y el costo de GPU por fotograma.
- El papel de la IA: la IA se encarga de escribir el código de generación; las técnicas procedurales en sí llevan mucho tiempo usándose ampliamente en el desarrollo de juegos.
- Cómo empezar: con una sola clave API, compara en APIYI apiyi.com el código de escenas Three.js que generan varios modelos.
8 Conclusión: el desarrollo de juegos pasa de crear assets a escribir reglas para generarlos
Saltline muestra un cambio en la forma de concebir los assets: los juegos tradicionales entregan «assets ya creados», mientras que los juegos procedurales entregan «reglas para generar assets». La generación de código por IA reduce mucho la barrera de entrada de esta ruta: un modelo puede escribir geometría, texturas, shaders, audio y lógica de juego a la vez en una generación continua, eliminando el traspaso entre distintos especialistas.
Esta ruta tiene límites claros de aplicación. Destaca por el tamaño de distribución y la facilidad de despliegue, al tiempo que traslada la carga computacional al dispositivo del jugador; funciona bien con estructuras repetitivas, superficies naturales y efectos dinámicos, mientras que los assets artísticos detallados siguen dependiendo de la producción tradicional. La producción tradicional de assets y la producción procedural seguirán complementándose a largo plazo; el valor de Saltline está en demostrar que un programa de pequeño tamaño también puede construir escenas interactivas ricas.
Si quieres comprobar esta ruta de primera mano, puedes empezar con el script de la sección 5.1. Te recomendamos invocar distintos modelos a través de APIYI apiyi.com para generar escenas procedurales y comparar su dominio de Three.js y los shaders.
📚 Referencias
- Repositorio espejo del código de Saltline y README: estructura de archivo único, tamaño en bytes y atribución de datos del desarrollador
- Enlace:
github.com/realcodebear/saltline-fable-5.2 -
Descripción: permite consultar directamente el código de generación programática de index.html
-
Página de experiencia independiente de Saltline: prueba en línea, inicialización y ajustes de calidad gráfica
- Enlace:
saltline.games -
Descripción: la versión en chino está en
saltline.games/zh -
Repositorio de GitHub de la versión china de Jimao: archivo de la versión distribuida localmente
- Enlace:
github.com/Megasu/jimao-3a-game -
Descripción: incluye instrucciones para ejecución offline y datos de tamaño de archivo
-
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 las especificaciones de la ventana de contexto
-
Documentación oficial y ejemplos de Three.js: InstancedMesh, ShaderMaterial, BufferGeometry, DataTexture
- Enlace:
threejs.org/docsythreejs.org/examples -
Descripción: referencia autorizada de las API utilizadas en el código de este artículo
-
MDN WebGL API: interfaz de renderizado GPU del navegador
- Enlace:
developer.mozilla.org/en-US/docs/Web/API/WebGL_API -
Descripción: para comprender el mecanismo de renderizado subyacente de Three.js
-
Descripción general de la tecnología Unity WebGL: limitaciones de hilos, memoria y móviles en la plataforma web
- Enlace:
docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html - Descripción: referencia para evaluar los límites de un proyecto de juego en navegador
Autor: equipo técnico de APIYI
Contacto técnico: puede ponerse en contacto con nosotros en la página principal de APIYI apiyi.com; para más material de integración, visite el centro de documentación docs.apiyi.com
