Por que um jogo AAA feito por IA consegue rodar no navegador? Desvendando o Saltline de 1,4 MB e 3 caminhos para jogos em navegador

Por que um jogo AAA feito por IA consegue rodar no navegador? Desvendando o Saltline de 1,4 MB e 3 caminhos para jogos em navegador

Nota do autor: o Saltline executa o código do jogo no navegador e usa a GPU local do jogador para renderizar. Assets programáticos somados ao WebGL explicam por que um arquivo web de cerca de 1.4MB consegue exibir uma cena completa de tiro em 3D.

O “jogo AAA” feito por IA roda na web por três motivos. Primeiro, o navegador moderno é, por si só, um ambiente completo de execução de programas 3D: o JavaScript roda a lógica do jogo, o Three.js organiza a cena e o WebGL entrega o trabalho de desenho à GPU do computador do jogador. Segundo, o que a IA produz na fase de desenvolvimento é um programa de jogo; depois de pronto, toda a execução fica por conta do navegador, e o jogador não chama mais o modelo de IA enquanto joga. Terceiro, os modelos, texturas e sons do Saltline são todos gerados por código; um único arquivo HTML de cerca de 1.4MB e, ao abrir a página, você já entra no jogo.

O “AAA” aqui é a meta visual que o desenvolvedor definiu para a IA, usada como analogia de estilo gráfico. O próprio Saltline é um protótipo jogável de pequeno porte, com apenas uma fase.

A seguir, partimos do caso do Saltline para entender onde o jogo realmente roda. Depois, destrinchamos a cadeia técnica de renderização de cenas 3D no navegador, explicamos por que a geração programática consegue reduzir o arquivo para 1.4MB e colocamos lado a lado três caminhos: execução local na web, cloud gaming e modelos de mundo de IA. Por fim, trazemos um trecho de código pronto para rodar, que te leva a gerar e medir uma cena 3D web com IA, além de discutir a distância real entre jogos de navegador e jogos AAA comerciais.

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

Table of Contents

Para saber: entendendo os termos dos jogos AAA na web com IA

Termo Explicação
JavaScript Linguagem de programação executada pelo navegador; a lógica de jogo de Saltline é escrita com ela
Three.js Biblioteca de gráficos 3D em JavaScript, usada para montar cenas, câmeras, luzes e objetos
WebGL Interface gráfica fornecida pelo navegador que permite à página web chamar a GPU do dispositivo para desenhar imagens 3D
WebGPU Nova geração de interface gráfica e de computação do navegador, com recursos mais modernos; Saltline não depende dela
WebAssembly (Wasm) Bytecode de baixo nível executável no navegador, que faz programas em C++, Rust e outros rodarem em alta velocidade na web
GPU Unidade de processamento gráfico, boa em cálculos paralelos como processar muitos pixels e vértices ao mesmo tempo
Shader Pequeno programa executado na GPU que calcula a posição de cada vértice ou a cor de cada pixel
Geração procedural Construir conteúdo de jogo com regras e funções matemáticas, em vez de imagens e arquivos de modelo pré-produzidos
Instancing (renderização por instância) Desenhar muitos objetos de mesma forma com uma única chamada de desenho, como fileiras de contêineres
Tempo de quadro Tempo necessário para renderizar um quadro; 60 FPS corresponde a cerca de 16,67 ms por quadro
Cloud gaming Jogos executados em servidores remotos, que enviam a imagem aos jogadores como fluxo de vídeo
WebRTC Tecnologia de transmissão de áudio e vídeo em tempo real do navegador, muito usada em cloud gaming para enviar imagem e entrada
Modelo de mundo Modelo de IA que aprende as regras de mudança do ambiente e prevê/gera as cenas seguintes com base na entrada do jogador

1 Por que um jogo AAA feito por IA só precisa ser aberto no navegador: começando por Saltline

1.1 Que tipo de jogo web de IA é Saltline

Em 9 de novembro de 2026, o engenheiro da Anthropic Felix Rieseberg tornou público um experimento de programação com Claude Fable 5.2. Ele deu ao modelo apenas um comando, pedindo um jogo de tiro em primeira pessoa de pequena escala com visual o mais próximo possível de um jogo AAA, sem fornecer feedback humano durante todo o processo. O resultado final foi Saltline.

A cena do jogo se passa em um porto de contêineres em uma noite chuvosa, com armazéns, cais e contêineres empilhados. O jogador precisa desligar três estações de retransmissão de sinal e evacuar; os inimigos incluem drones de patrulha aérea e cães mecânicos terrestres. O jogo oferece movimentação em primeira pessoa, controle de câmera, tiro, interação e objetivos de missão, além de chuva, iluminação, som ambiente e efeitos de armas. A página tem configurações de qualidade gráfica, incluindo uma opção de qualidade baixa.

Segundo o próprio desenvolvedor no X, o experimento levou cerca de 8 horas e, estimando pelo preço da API, custou aproximadamente US$ 550, consumindo cerca de 445 milhões de tokens de entrada (grande parte em cache) e cerca de 2,7 milhões de tokens de saída. Esses números são estimativas relatadas pelo desenvolvedor, não uma fatura auditada por terceiros.

O que mais tarde circulou nas redes sociais chinesas como “Jimao · grande produção AAA nacional” é a versão chinesa, ou uma versão reembalada, de Saltline; o nome “grande produção AAA nacional” surgiu no processo de divulgação.

1.2 Um único arquivo de 1,4 MB contém todo o jogo com estilo AAA

A versão HTML autônoma de Saltline é apenas um index.html; o tamanho registrado no repositório do GitHub é 1.425.707 bytes, cerca de 1,43 MB (1,36 MiB). Esse arquivo contém o código central necessário para o jogo rodar, e o código de execução do Three.js também foi empacotado junto. O jogo não tem arquivos separados de modelos 3D, texturas e efeitos sonoros.

Como comparação, os instaladores de jogos 3D tradicionais costumam trazer muitos modelos, texturas de alta resolução, animações, efeitos sonoros e dados de cena. Saltline substitui todos esses recursos por “código que gera recursos”, e essa é a razão central do tamanho reduzido; a seção 3 detalha isso.

1.3 O jogo Saltline roda de fato no dispositivo do próprio jogador

A IA só entra na fase de desenvolvimento. O espelho do Saltline no GitHub mostra isso: a versão original era um Claude Artifact; ao portar, removeram os scripts de execução do framework Artifact, mantiveram o código do jogo, adicionaram declarações de DOCTYPE, conjunto de caracteres e viewport, e então basta iniciar um servidor HTTP local.

Isso mostra que a lógica do jogo e a interface de conversa do Claude já estão completamente separadas. Quando o jogador abre a página, o navegador lê o HTML, executa o JavaScript, inicializa o WebGL, e a GPU local desenha cada frame; nenhum modelo de IA participa da inferência ao longo de todo o processo.

Vale acrescentar um detalhe: as notas da versão espelhada mencionam que as fontes ainda são carregadas do Google Fonts. A descrição precisa é: o programa central de Saltline roda localmente, e cena, texturas e som são gerados por código local; as fontes têm uma dependência externa de carregamento.


2 Como o navegador se tornou o ambiente de execução 3D dos jogos 3A de IA

Os navegadores modernos conseguem interpretar HTML, mas também chamar interfaces gráficas, executar código de alto desempenho, gerenciar memória e lidar com áudio e vídeo. O Saltline usa uma das combinações mais comuns entre essas opções: JavaScript + Three.js + WebGL.

2.1 O JavaScript cuida da lógica do jogo web

O JavaScript é o “cérebro” do jogo. Onde os inimigos patrulham, se o tiro acertou, se a estação de retransmissão foi desligada, se o jogador consegue evacuar — todas essas regras são escritas em código JavaScript e executadas na CPU pelo motor JavaScript do navegador.

Para tarefas computacionais mais pesadas, o navegador também oferece o WebAssembly. Quando engines como a Unity exportam versões web, elas compilam parte do programa para WebAssembly a fim de aumentar a velocidade de execução. O WebAssembly fica responsável pela execução do programa, enquanto a renderização da imagem continua sendo feita pelo WebGL — os dois trabalham em conjunto. No Saltline, a lógica é feita principalmente com JavaScript.

2.2 Three.js organiza a cena 3D

Escrever uma cena 3D diretamente em WebGL exige lidar com uma enorme quantidade de detalhes de baixo nível. O Three.js encapsula esses detalhes em objetos intuitivos:

  • Scene: contêiner da cena, que abriga todos os objetos e luzes
  • Camera: a câmera, que em um jogo em primeira pessoa é os olhos do jogador
  • Geometry: a estrutura geométrica, que define as formas dos contêineres e do armazém
  • Material: o material, que decide se a superfície parece metal ou concreto
  • Mesh: o objeto visível que surge da combinação de geometria e material
  • Light: as luzes, os postes e as luzes de advertência do porto em uma noite de chuva
  • Renderer: o renderizador, que entrega todo esse conteúdo à GPU para desenhar

A biblioteca oficial de exemplos do Three.js também demonstra recursos como animação esqueletal, mapeamento de sombras, efeitos de pós-processamento e renderização instanciada. Entre eles, o Instancing é especialmente útil para a cena do porto: centenas ou milhares de contêineres parecidos podem compartilhar uma única estrutura geométrica, mudando apenas os parâmetros de posição e cor, tudo concluído em uma única chamada de desenho, o que alivia bastante a carga do navegador.

2.3 WebGL entrega o trabalho de desenho à GPU local

WebGL é a interface gráfica que o navegador oferece ao JavaScript, construída sobre tecnologias relacionadas ao OpenGL ES. Seu fluxo de trabalho é bem direto: o código do jogo chama o WebGL por meio de JavaScript, o WebGL envia as instruções de desenho para a GPU, a GPU calcula a imagem e o navegador exibe essa imagem na página.

O ponto crucial é que essa GPU é a placa de vídeo no computador do jogador. Cada frame de Saltline é calculado no dispositivo do jogador, e a rede só é responsável por entregar os arquivos de 1.4MB ao navegador no início. É por isso que a página oficial do Saltline recomenda que os jogadores presos na tela de carregamento verifiquem o WebGL 2 e a aceleração de hardware do navegador.

2.4 Shader, materiais e iluminação compõem a aparência de uma cena 3D

A aparência de uma cena 3D é determinada por quatro partes: o modelo define a forma, o material define as propriedades da superfície, a iluminação define luz e sombra, e o Shader calcula todos esses fatores para chegar à cor final de cada pixel.

O Shader roda na GPU e se divide em dois tipos. O Shader de vértice calcula a posição de cada vértice na tela; o Shader de fragmento calcula a cor de cada pixel. Usando o contêiner numa noite chuvosa como exemplo, o Shader de fragmento pode usar funções matemáticas para gerar as listras da chapa ondulada, as manchas de ferrugem e o brilho da superfície molhada, sem precisar de uma textura desenhada previamente.

2.5 Loop do jogo no navegador: processar entradas e atualizar a tela continuamente

A diferença entre um jogo e uma página estática é que o jogo precisa redesenhar a tela dezenas de vezes por segundo. O navegador oferece a interface requestAnimationFrame, que executa um callback no código do jogo antes de cada atualização da tela, formando o loop do jogo:

  1. Ler entradas de teclado, mouse ou toque na tela (o Saltline precisa que você clique na área do jogo para capturar o controle do mouse)
  2. Atualizar o estado do jogo: posição do jogador, comportamento dos inimigos, trajetória das balas
  3. Chamar o renderizador Three.js; via WebGL, ele faz a GPU desenhar um novo quadro
  4. O navegador exibe a imagem e espera pela próxima atualização

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

3 Por que 1,4 MB consegue gerar uma cena completa no estilo AAA: geração procedural

3.1 Modelos, texturas e sons são escritos como funções

Felix Rieseberg explicou em 10 de novembro que todo o conteúdo do jogo é código: texturas e modelos são funções, e não há arquivos de imagem ou de modelo 3D separados. O Claude gera o código e os shaders que constroem esses conteúdos.

Comparando com a abordagem tradicional, a diferença fica evidente:

  • Texturas: no método tradicional, você baixa uma imagem de textura de contêiner e a aplica; no método procedural, funções de ruído, variação de cor e shaders calculam a superfície metálica em tempo real
  • Modelos: no método tradicional, importa-se um arquivo de modelo feito em software de modelagem; no procedural, a geometria é construída em tempo de execução com vértices e parâmetros geométricos
  • Sons: no método tradicional, carregam-se arquivos de áudio gravados; no procedural, o som é sintetizado em tempo real com as APIs de áudio do navegador

O que fica salvo no arquivo são as “regras de geração”; a imagem final só é calculada em tempo de execução. As regras costumam ser muito menores que o resultado — um shader de algumas dezenas de linhas já cobre a textura do chão de um porto inteiro.

3.2 Distinguir tamanho do arquivo, memória de execução e carga computacional

A chave para entender os 1,4 MB é separar três conceitos:

Conceito O que mede Situação no Saltline
Tamanho do arquivo Quanto código e quantos recursos precisam ser baixados Cerca de 1,4 MB, distribuição muito leve
Memória de execução Quanta memória RAM e VRAM é ocupada durante a execução A cena é gerada em tempo de execução; os dados oficiais não foram divulgados
Carga computacional Quanto trabalho a CPU e a GPU realizam por frame Depende das configurações de qualidade e do dispositivo; os dados oficiais não foram divulgados
Tempo de inicialização O tempo entre abrir a página e poder interagir A documentação oficial explica que é preciso construir o porto, os armazéns, a iluminação e os sons, e a duração depende do dispositivo

A geração procedural troca “cálculo em tempo de execução” por “tamanho de download”. Um programa de 1,4 MB pode criar uma grande quantidade de geometrias, materiais e texturas em tempo de execução, e a GPU ainda precisa realizar muito cálculo de shader a cada frame. A página oficial do Saltline também avisa claramente que o momento em que o botão START aparece depende do dispositivo do jogador e que, em caso de travamentos, é possível mudar para a qualidade Low.

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

3.3 A arquitetura de arquivo único torna a distribuição extremamente leve

O valor do HTML em arquivo único está na distribuição. Ele pode ficar em qualquer serviço de hospedagem estática, ou ser baixado para o computador e aberto com um servidor HTTP; para compartilhar, basta um link. O repositório no GitHub da versão chinesa do “几猫” já oferece uma demonstração online e uma entrada para download, e informa que dá para rodar offline (exceto o carregamento de fontes).

Esse formato é especialmente amigável para protótipos gerados por IA. O modelo gera um arquivo completo de uma vez, o desenvolvedor não precisa lidar com pipeline de assets, ferramentas de empacotamento nem configuração de servidor, e logo depois de gerar já dá para enviar a outra pessoa testar.


4 Três rotas diferentes para rodar jogos AAA na web

Por trás de “jogar na web” existem três rotas tecnológicas com modos de computação completamente diferentes. Só entendendo bem cada uma delas é possível compreender o Saltline com precisão.

4.1 Execução local na web: a rota do Saltline

A IA gera o código, o código é enviado ao jogador e o navegador executa a lógica localmente, com a GPU local renderizando as imagens. O dispositivo do jogador assume a maior parte da computação; durante a execução do jogo não é preciso se conectar ao modelo de IA, e depois de baixar os arquivos há chance de rodar offline. O preço é que o desempenho depende inteiramente do dispositivo e do navegador do jogador.

4.2 Cloud gaming: as rotas do GeForce NOW e do Pixel Streaming

O jogo roda em servidores remotos, o GPU na nuvem renderiza os frames e depois transmite tudo como vídeo para o navegador. O navegador só cuida de exibir o vídeo, reproduzir o áudio e mandar de volta ao servidor o que o jogador faz.

O Pixel Streaming da Epic Games permite que aplicações do Unreal Engine rodem na nuvem ou em um computador remoto, transmitindo imagem e áudio ao navegador via WebRTC. Já o NVIDIA GeForce NOW é um serviço de cloud gaming voltado ao jogador, e os requisitos de rede oficiais para o navegador são: pelo menos 15 Mbps em 720p/60FPS, pelo menos 25 Mbps em 1080p/60FPS, e pelo menos 35 Mbps em 1440p/120FPS, com latência recomendada abaixo de 80ms. Essa rota reduz a barreira do hardware local, mas em troca cria uma dependência contínua da rede.

4.3 Mundos de IA: a rota do Genie 3

Os world models não pré-programam cenários e regras: eles predizem e geram o próximo trecho de imagem a partir do estado atual e das entradas do jogador. Em agosto de 2025, o Google DeepMind lançou o Genie 3, e segundo o anúncio oficial ele é capaz de gerar em tempo real ambientes exploráveis em 720p, com até 24FPS, mantendo a consistência da cena por vários minutos. O Muse/WHAMM da Microsoft e o Oasis da Decart também estão explorando essa direção.

Em janeiro de 2026, o Project Genie, baseado no Genie 3, abriu para testes, inicialmente para assinantes do Google AI Ultra nos Estados Unidos com 18 anos ou mais, com limite de 60 segundos por sessão de geração. Essa rota ainda está na fase de pesquisa e protótipo de produto, e não tem relação com a tecnologia usada pelo Saltline.

4.4 Comparação das três abordagens

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

Dimensão de comparação Execução local no navegador Cloud gaming Modelo de mundo de IA
Caso representativo Saltline GeForce NOW, Pixel Streaming Genie 3
Lógica do jogo Execução de código previamente escrito localmente Execução de código previamente escrito na nuvem O modelo aprende a dinâmica do ambiente a partir dos dados
Geração de imagens Renderização pela GPU local Renderização pela GPU na nuvem Geração em tempo real por IA
Papel do navegador Ambiente de execução do jogo Terminal de vídeo e interação Ponto de entrada para interação
Dependência de rede Praticamente offline após o primeiro carregamento Conexão contínua à internet, exigindo banda larga e baixa latência Normalmente requer conexão contínua à internet
Requisitos de hardware local Relativamente altos Relativamente baixos Depende da forma de implantação do modelo
Momento em que o custo de IA ocorre Concentrado na fase de desenvolvimento Sem inferência de IA, consumo contínuo de GPU na nuvem Inferência contínua a cada sessão de jogo

A estrutura de custos é a diferença mais concreta entre as três. O Saltline concentra o custo de IA em um único desenvolvimento, e depois a renderização fica a cargo do dispositivo do jogador; a estimativa de 550 dólares não cresce com o número de jogadores. Já o cloud gaming e os modelos de mundo consomem continuamente poder computacional dos servidores a cada sessão de jogo.


5 Mão na massa: gerar e executar uma cena 3D na web com IA

A maneira mais rápida de entender os fundamentos é executar tudo você mesmo. Esta seção tem três etapas: primeiro, rodar uma cena procedural escrita à mão; depois, usar a API para pedir a um Modelo de Linguagem Grande que gere um jogo em arquivo único; por fim, medir o tempo de frame.

5.1 Cena procedural mínima e funcional em Three.js

O arquivo abaixo desenha 400 contêineres usando Instancing: as listras onduladas e as manchas de ferrugem de cada contêiner são calculadas em tempo real pelo Shader, sem nenhum arquivo de imagem em todo o processo. Salve como index.html, execute python3 -m http.server 8000 no mesmo diretório e abra http://localhost:8000 no navegador.

<!DOCTYPE html>
<html lang="zh">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Porto de contêineres 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: listras onduladas + manchas de ferrugem com ruído + luz direcional simples
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));   // listras onduladas
      float rust = smoothstep(0.82, 1.0, hash(floor(vUv * 40.0)));  // manchas de ferrugem
      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: desenha 400 contêineres em uma única chamada de desenho
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);

// Loop do jogo: atualiza a câmera e renderiza a 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 a ideia central do Saltline: a geometria é construída com BoxGeometry, a aparência visual é calculada pelo Shader, e grandes quantidades de objetos repetidos são renderizadas com Instancing. O arquivo inteiro tem apenas alguns KB, e o Three.js é carregado via CDN; já o Saltline empacota o Three.js diretamente no HTML.

5.2 Gerar um jogo 3D de arquivo único com um Modelo de Linguagem Grande via API

O processo de geração da Saltline foi uma programação agêntica longa, de múltiplas rodadas, que consumiu centenas de milhões de tokens. Desenvolvedores individuais podem começar com uma única chamada, pedindo ao modelo que produza um pequeno jogo Three.js de arquivo único e executável, para vivenciar a divisão de trabalho de “a IA escreve o programa, o navegador roda o programa”. O código abaixo usa uma interface compatível com OpenAI; substitua o nome do modelo por um da lista de modelos da plataforma que ofereça suporte a saídas longas de código.

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Interface compatível com OpenAI da APIYI
)

resp = client.chat.completions.create(
    model="YOUR_MODEL_NAME",  # Consulte a lista de modelos da plataforma
    messages=[{"role": "user", "content": "用 Three.js 写一个单文件 HTML 第一人称小游戏,所有模型和纹理用代码与 Shader 生成,只输出完整 HTML。"}],
)
open("game.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
Ver o código de implementação completo (incluindo limpeza de blocos de código e restrições do comando)
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:
    """Remove as marcações de bloco de código ```html que o modelo pode ter envolvido"""
    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",
    )

O arquivo gerado segue a mesma lógica de execução da Saltline: a chamada à API acontece apenas uma vez, na geração; depois, abrir o game.html e jogar quantas vezes quiser não gera mais custos de modelo.

🚀 Dica para começar rápido: se quiser comparar o resultado de diferentes modelos escrevendo jogos Three.js, você pode usar a APIYI apiyi.com para alternar entre modelos como Claude, GPT e Gemini com a mesma chave API. A interface é compatível com OpenAI e basta alterar o parâmetro model no código acima. Novos usuários recebem créditos de teste gratuitos, ideais para validar a qualidade da geração primeiro com um comando curto.

5.3 Medir o desempenho real de jogos 3D no navegador

Os 1,4 MB só respondem a “quão rápido é o download”. Para determinar se um jogo web roda ou não, é preciso medir estas métricas:

Métrica Objetivo da medição Método de medição
Tempo até a primeira interação Experiência de inicialização Do momento em que a página abre até ser possível controlar o personagem; pode usar a Performance API para marcar pontos
FPS / tempo de quadro Fluidez e estabilidade 60 FPS corresponde a cerca de 16,67 ms/quadro; observe a variação do tempo de quadro
Uso de CPU Carga da lógica do jogo Observe a thread principal no painel Performance do Chrome DevTools
Uso de GPU e memória de vídeo Carga de renderização Gerenciador de tarefas do sistema ou ferramentas de monitoramento da placa de vídeo
Memória do sistema Recursos em tempo de execução Observe a memória do processo do navegador após a conclusão da inicialização da cena
Tráfego de rede após o carregamento Dependências externas Painel Network do DevTools, diferenciando requisições de fontes, programas etc.

Cole o trecho de código abaixo no console do navegador para calcular o tempo médio de quadro e o quadro mais lento em 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);
})();

Ao testar, mantenha fixos a versão do navegador, o sistema operacional, o modelo do dispositivo, a resolução e o nível de qualidade gráfica. A medição deve cobrir cenas em que o jogador se move, inimigos estão ativos, tiros e efeitos de chuva aparecem ao mesmo tempo. Medir apenas a cena vazia logo após entrar no jogo produz resultados excessivamente otimistas.


6 Até onde um jogo 3A para navegador está de um verdadeiro 3A comercial

6.1 Limitações de hardware e plataforma dos jogos no navegador

A documentação oficial da Unity é bem clara sobre as limitações da plataforma Web: acesso restrito ao sistema de arquivos, algumas funções de cache indisponíveis, multithreading limitado pelo ambiente do navegador, recursos de memória limitados e compatibilidade variável entre navegadores. As builds WebGL da Unity são voltadas principalmente para navegadores de desktop, com suporte limitado em dispositivos móveis.

A página de experiência da Saltline confirma essas limitações. A página avisa que a inicialização pode ser mais lenta, que a velocidade de inicialização depende do desempenho do dispositivo, que é preciso verificar o WebGL 2 e a aceleração de hardware e que, em caso de engasgos, vale alternar para a qualidade Low. A barreira para abrir a página é baixa, mas rodar de forma fluida ainda depende da GPU do jogador.

6.2 1,4MB explica o download leve; a carga de execução é outra história

A geração procedural transforma “assets para download” em “assets calculados em tempo de execução”. As texturas são calculadas pixel a pixel em tempo real na GPU, e a geometria é construída pela CPU durante a inicialização — todo esse trabalho acontece no dispositivo do jogador. Até agora, os desenvolvedores não divulgaram o tempo de inicialização padrão, o FPS médio, nem o consumo de VRAM ou memória do Saltline. Para avaliar sua carga de execução, é preciso medir por conta própria seguindo o método da seção 5.3.

6.3 A escala de engenharia de um jogo AAA comercial

Um jogo AAA comercial normalmente significa um investimento massivo de dinheiro, mão de obra e recursos. Esse rótulo descreve a escala de produção — não existe um padrão técnico de certificação unificado. Um jogo AAA comercial precisa de dezenas de horas de conteúdo, animação de personagens e sistemas físicos complexos, sincronização em rede multiplayer, adaptação multiplataforma, além de anos de atualizações, manutenção e otimização de testes. A geração procedural se sai bem com conteúdos de regras bem definidas, como contêineres, terreno e chuva; já diante de personagens e cenas narrativas que exigem muito polimento artístico, a produção tradicional de assets continua sendo mais adequada.

6.4 O que o Saltline realmente prova

O Saltline prova que um modelo de IA com forte capacidade de programação consegue, em um único processo contínuo de geração, integrar design de níveis, construção de cenários, shaders, mecânicas de jogo, lógica de controles e geração de áudio, produzindo um protótipo de jogo 3D com estilo coeso e pronto para ser compartilhado. No fluxo tradicional, o custo de transição entre ferramentas e funções diferentes fica comprimido dentro do contexto de um único modelo.

Comparando os dados declarados pelo próprio desenvolvedor com os preços oficiais publicados para o modelo, dá para entender a composição de custo desse experimento:

Item Dados Fonte
Tempo de desenvolvimento cerca de 8 horas Declaração de Felix Rieseberg, 2026-11-09
Custo estimado cerca de US$ 550 (estimativa com base nos preços da API) Declaração de Felix Rieseberg
Tokens de entrada cerca de 445 milhões, grande parte em cache Declaração de Felix Rieseberg
Tokens de saída cerca de 2,7 milhões Declaração de Felix Rieseberg
Preço de entrada / saída do Fable 5.2 US$ 8 / US$ 40 por milhão de tokens Documentação oficial de modelos da Anthropic
Preço de leitura de cache do Fable 5.2 US$ 0,20 por milhão de tokens Documentação oficial de modelos da Anthropic
Janela de contexto / saída máxima 1M tokens / 128K tokens Documentação oficial de modelos da Anthropic

O preço de leitura de cache é bem menor que o preço normal de entrada, então os 445 milhões de tokens de entrada não podem ser convertidos diretamente em custo total usando o valor unitário padrão de entrada. O desenvolvedor não divulgou a divisão detalhada da fatura, e os US$ 550 devem ser entendidos como uma estimativa de custo de um experimento de geração.

💰 Sugestão de custo: O custo de gerar jogos web com IA se concentra na fase de desenvolvimento, e contexto longo e muitas rodadas de iteração são as principais despesas. Antes de investir em tarefas longas, você pode usar o APIYI apiyi.com para comparar a qualidade de código de vários modelos com comandos menores e depois decidir em qual modelo fazer a geração longa. O pagamento por uso facilita controlar o custo de tentativa e erro.


7 Perguntas frequentes (FAQ)

Q1: Um jogo AAA feito por IA rodando no navegador — será que as imagens do jogo vêm do servidor?

A imagem do Saltline é renderizada pela GPU local do jogador. Depois que o navegador baixa um arquivo HTML de cerca de 1,4 MB, o JavaScript executa a lógica do jogo e, via WebGL, chama a placa de vídeo local para desenhar cada quadro. Quem transmite imagem pelo servidor é o cloud gaming do tipo GeForce NOW, que segue outra linha técnica.

Q2: Ao jogar Saltline, o modelo Claude é invocado em tempo real?

Não. O Claude Fable 5.2 só gera o código do jogo durante a fase de desenvolvimento. A versão espelhada no GitHub já removeu o script de framework do Claude Artifact, então o jogo sobe com um servidor HTTP comum, e o processo de jogar não gera custos de invocação do modelo.

Q3: Qual é a diferença entre o Saltline e modelos de mundo de IA como o Genie 3?

As regras e cenários do Saltline são previamente escritos em código pela IA, e em tempo de execução são executados pelo fluxo de renderização tradicional. O Genie 3 prevê e gera quadros a quadro com base na entrada do jogador, e as regras são aprendidas a partir dos dados. O primeiro é a IA escrevendo um programa; o segundo é a IA gerando imagem diretamente — tecnicamente, são caminhos independentes.

Q4: Um jogo AAA de navegador de 1,4 MB — que configuração de computador consegue rodá-lo de forma fluida?

Os desenvolvedores não divulgaram os requisitos mínimos nem dados de FPS. A página oficial recomenda verificar se o navegador suporta WebGL 2 e ativar a aceleração de hardware; se houver travamentos, mude para a qualidade Low. Para o desempenho concreto, recomendo medir na sua própria máquina com o script de tempo de quadro da seção 5.3 deste artigo.

Q5: Como usar a API para gerar por conta própria um jogo 3D de navegador parecido?

Cadastre-se na APIYI apiyi.com e obtenha uma chave API, defina o `base_url` no código da seção 5.2 como `https://api.apiyi.com/v1`, escolha um modelo bom em saídas de código longo e deixe claro no comando: “HTML em arquivo único, Three.js, todos os assets gerados com código e Shader”. Depois de gerado, basta abrir com um servidor HTTP local para testar.

Q6: Quais são as limitações de gerar jogos de navegador com IA?

O comprimento da saída de uma única invocação é limitado; jogos complexos exigem várias rodadas de geração com janelas de contexto longas, e o custo sobe junto. O código gerado costuma precisar de ajustes de desempenho e compatibilidade. O navegador em si também tem limitações de memória, threads e suporte a dispositivos móveis. A sugestão é começar com uma comparação em pequena escala entre vários modelos via APIYI apiyi.com, escolher o modelo com código mais estável e só então ampliar o escopo do projeto.


8 Pontos-chave dos jogos 3A de IA na web

  • Onde roda: o Saltline roda no navegador do jogador, e a GPU local é quem renderiza
  • Divisão de trabalho clara: a IA escreve o código na fase de desenvolvimento; o navegador executa o código na fase de execução
  • Cadeia técnica: JavaScript cuida da lógica, Three.js monta a cena, WebGL chama a GPU
  • O segredo do tamanho: modelos, texturas e sons viram funções — arquivo único de cerca de 1,4MB
  • Arquivo pequeno não significa execução leve: ativos procedurais trocam o custo de download por custo de computação em tempo de execução
  • Três caminhos: execução local no navegador, cloud gaming e modelos de mundo de IA têm posições de computação diferentes
  • Validação na prática: dá para chamar vários modelos via APIYI apiyi.com para gerar jogos Three.js em arquivo único e testar de verdade

9 Conclusão

Jogos com estilo 3A feitos por IA conseguem rodar na web porque o navegador já traz a capacidade 3D de execução, e a isso se soma a geração procedural. São três os pontos centrais:

  1. O navegador é o ambiente de execução da engine do jogo: JavaScript, Three.js e WebGL juntos permitem que a página chame diretamente a GPU local para renderizar cenas 3D.
  2. O custo da IA se concentra na fase de desenvolvimento: depois de gerado, o Saltline roda sozinho, sem depender do Claude; os cerca de 550 dólares citados pelo próprio desenvolvedor são uma estimativa de custo único.
  3. Os 1,4MB resolvem o problema de distribuição: memória e carga de GPU em tempo de execução continuam por conta do dispositivo do jogador. O Saltline é, na prática, um protótipo 3D jogável construído rapidamente.

Se você quiser sentir na prática o fluxo de “IA escreve o jogo, navegador roda o jogo”, a recomendação é usar o APIYI apiyi.com para comparar, com a mesma interface compatível com OpenAI, os resultados de modelos diferentes ao gerar código Three.js — e depois medir com o script de tempo de frame deste artigo.


📚 Referências

  1. Página independente de demonstração do Saltline: entrada para o test-drive do jogo, com instruções de carregamento, qualidade gráfica e controles
  2. Link: saltline.games
  3. Descrição: inclui avisos oficiais sobre tempo de inicialização, WebGL 2 e aceleração de hardware

  4. Espelho de código e README do Saltline: versão em HTML de arquivo único

  5. Link: github.com/realcodebear/saltline-fable-5.2
  6. Descrição: documenta o processo de portabilidade do Artifact, a estrutura de arquivos e a dependência externa do Google Fonts

  7. Repositório GitHub da versão chinesa do Jimao: versão empacotada em chinês do Saltline

  8. Link: github.com/Megasu/jimao-3a-game
  9. Descrição: traz informações sobre tamanho do arquivo, execução offline e requisitos de navegador

  10. Especificações e preços do modelo Claude Fable 5.2: documentação oficial da Anthropic

  11. Link: platform.claude.com/docs/en/models/fable-5-2/overview
  12. Descrição: preços de entrada, saída e cache, além da janela de contexto

  13. MDN WebGL API: documentação da interface de renderização por GPU no navegador

  14. Link: developer.mozilla.org/en-US/docs/Web/API/WebGL_API
  15. Descrição: material autoritativo para entender como o WebGL funciona

  16. Documentação oficial do Three.js: biblioteca de gráficos 3D para Web

  17. Link: threejs.org/docs
  18. Descrição: descrições das APIs Scene, Mesh, ShaderMaterial, InstancedMesh, entre outras

  19. Limitações técnicas do Unity WebGL: restrições da plataforma de jogos no navegador

  20. Link: docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html
  21. Descrição: explicações sobre limitações de sistema de arquivos, threads, memória e suporte a dispositivos móveis

  22. Requisitos de sistema do NVIDIA GeForce NOW: requisitos de rede para cloud gaming

  23. Link: nvidia.com/en-us/geforce-now/system-reqs
  24. Descrição: recomendações de largura de banda e latência para diferentes qualidades gráficas e taxas de quadros

  25. Epic Games Pixel Streaming: transmissão de renderização na nuvem

  26. Link: dev.epicgames.com/documentation/unreal-engine/pixel-streaming-in-unreal-engine
  27. Descrição: documentação oficial do Unreal Engine para transmitir quadros ao navegador via WebRTC

  28. Lançamento técnico do Genie 3: modelo de mundo do Google DeepMind

    • Link: deepmind.google/blog/genie-3-a-new-frontier-for-world-models
    • Descrição: capacidades e limitações da geração de ambientes interativos em tempo real

Autor: Equipe técnica da APIYI
Contato técnico: fique à vontade para nos contatar pela página inicial do site oficial da APIYI; mais materiais sobre integração de modelos estão disponíveis no centro de documentação docs.apiyi.com

Artigos relacionados

Similar Posts