Recompilação Estática: Jogos de Console no Navegador
A recompilação estática transforma binários antigos de console e PC em código portável. Veja como WebAssembly e WebGPU levam jogos inteiros ao navegador.

A melhor coisa para a preservação de jogos em uma década não é um emulador melhor. É um compilador. Quando um jogo de corrida completo de 2004, com roam livre online, suporte a controle e renderização em widescreen a 120 fps, aparece rodando em uma aba do navegador, a reação natural é achar que alguém construiu um emulador muito esperto. Não foi isso. Fizeram algo mais estranho e, na minha opinião, muito mais importante: rodaram o código de máquina original do jogo ao contrário, por meio de uma espécie de descompilador, transformaram tudo em C e reconstruíram como um módulo WebAssembly. Isso é recompilação estática, e ela está se tornando, discretamente, a forma mais prática de fazer software antigo rodar em qualquer lugar.
Emulação vs. recompilação: uma bifurcação no caminho
Emuladores respondem à pergunta “como rodamos este binário?” recriando a máquina que ele esperava. A CPU do seu host finge ser um chip MIPS ou PowerPC, instrução por instrução, ciclo por ciclo. Funciona (MAME, Dolphin e PCSX2 são verdadeiros milagres), mas você paga por isso para sempre. A cada frame, você traduz instruções para um hardware que deixou de existir há quinze anos, e as peculiaridades de temporização do silício original viram bugs que você precisa reproduzir com todo o cuidado.
A recompilação estática faz a aposta oposta. Em vez de interpretar o binário em tempo de execução, você o analisa uma vez, offline, e o traduz para uma linguagem portável, geralmente C. O resultado não é um simulador do hardware antigo. É um programa novo que calcula as mesmas coisas. Você compila isso com clang, escolhe o alvo que quiser, e o resultado roda em velocidade nativa. Quando o alvo é wasm32, o resultado roda no Chrome.
Vale conhecer a linhagem. Projetos como N64: Recompiled e XenonRecomp provaram o padrão em títulos de console, e o NFSU2Recomp aplicou a mesma ideia à versão x86 para PC de Need for Speed: Underground 2, traduzindo o executável original para C, que depois foi bifurcado e conectado a WebGPU, Web Audio e APIs modernas de entrada. Essa última etapa é a que desenvolvedores web deveriam observar com atenção, porque é a parte mais parecida com o nosso dia a dia: um pipeline de assets, um backend de renderização e uma camada de rede.
Por que x86 para C é mais difícil do que parece
Traduzir uma ROM de console é quase civilizado comparado a um executável de PC. Um binário de N64 é uma imagem linear rodando em bare metal, com um mapa de memória fixo. Um jogo de PC de 2004 é um arquivo PE gerado por um compilador otimizador, que faz chamadas indiretas através de vtables, pula por tabelas de importação e mistura código e dados livremente, o que torna a análise estática genuinamente difícil.
O problema central é que o código de máquina perdeu toda a informação de tipos. O recompilador vê call eax e precisa descobrir para onde eax poderia apontar: quais ponteiros de função chegam àquele registrador, a partir de quais tabelas, preenchidas onde. Se errar, ou você perde caminhos de código (o jogo trava na terceira corrida) ou classifica dados como código (o disassembler embaralha tudo que vem depois). Por isso esses projetos dependem de análise interativa em ferramentas como IDA ou Ghidra, anotação manual e muito playtest.
O resultado não é um C bonito. Ele se parece com algo assim:
// Simplified flavor of recompiler output
void sub_4A12C0(CPUState *cpu) {
uint32_t eax = cpu->reg[0];
uint32_t ecx = cpu->reg[1];
eax = mem_read32(cpu, ecx + 0x14);
if (eax != 0) {
cpu->reg[0] = ((FnPtr)mem_read32(cpu, eax + 0x08))(cpu);
}
cpu->reg[0] = eax;
}
Registradores viram campos de struct, a memória vira um grande array de bytes, e o fluxo de controle vira funções chamando funções. Ninguém escreveria isso à mão, e ninguém precisa mantê-lo à mão, porque é um artefato intermediário. O que importa é que ele é compilável, e, uma vez que compila para um alvo, compila para todos. Essa é a recompensa.
WebAssembly é a parte fácil
Aqui vai a parte contraintuitiva, merecida: fazer o C recompilado gerar um módulo .wasm é a engenharia menos interessante de todo o projeto. Emscripten e o alvo wasm do clang são sólidos há anos. Se o seu código é C portável, sem assembly inline e sem suposições fortes sobre tamanho de ponteiro além de 32 bits, ele basicamente compila. Já escrevemos sobre casos em que WebAssembly não é mais rápido que JavaScript, mas isso está bem no território do wasm: loops numéricos apertados, uma única memória linear grande, sem tráfego com o DOM. JavaScript aquecido por JIT não chega perto.
O trabalho real é tudo o que o jogo chama. O binário original acha que tem Direct3D 9, DirectInput e a pilha de áudio do Windows. No navegador, não tem nada disso. Então o port precisa construir uma camada de shim: cada chamada gráfica que o jogo faz é interceptada e reexpressa em uma API moderna que o navegador entende. É aqui que o WebGPU se paga. É a primeira API gráfica web com nível de abstração baixo o suficiente para mapear um pipeline de função fixa do início dos anos 2000 sem se afogar em overhead. O resultado relatado, até 120 fps em widescreen, com roam livre e corridas online, não é algo que o WebGL entregaria com conforto.
Uma ressalva importante para quem põe a mão na massa: o suporte ao WebGPU ainda é irregular. No Linux, usuários do Chromium frequentemente precisam iniciar o navegador com flags como --enable-unsafe-webgpu --use-angle=vulkan para obter um adaptador funcional. “Roda no navegador” hoje significa “roda muito bem no Chrome e no Firefox, no sistema operacional certo e com os drivers de GPU certos”. É um problema real de distribuição, mas ainda não é universal.

Transmitir dois gigabytes para uma aba
Código tem alguns megabytes. Os assets são os outros 95% de um jogo, e é aqui que um port para navegador se torna um problema de engenharia web no sentido mais familiar. Um racer de mundo aberto de meados dos anos 2000 vem com gigabytes de geometria, texturas, áudio e vídeos FMV. Ninguém vai baixar isso numa landing page. Então você constrói o que toda equipe de game streaming e de sites grandes já sabe construir: um pipeline de assets preguiçoso, com requisições por faixa e com cache.
A forma geral costuma ser assim: os arquivos de assets originais são reempacotados em bundles fragmentados, um índice mapeia “o asset que o engine acabou de pedir” para “faixa de bytes em algum bundle”, e a camada de sistema de arquivos virtual busca via HTTP com range requests, fazendo cache agressivo no Cache Storage API ou no IndexedDB para que a segunda visita seja instantânea. O engine acha que está lendo de um DVD; na prática, está lendo de um service worker. Se você já trabalhou com pipelines de streaming de dados geográficos, a arquitetura é o mesmo bicho: chunks endereçados por conteúdo, um índice e um cliente que finge que a rede é um disco.
- Empacote uma vez, busque para sempre: converta os arquivos originais em chunks de tamanho fixo para que range requests HTTP e cache em CDN façam o trabalho pesado.
- Pré-carregue por previsão: a garagem, o primeiro distrito e a música do menu são necessários no primeiro minuto; o distrito do aeroporto pode esperar.
- Transcodifique sem dó: o áudio e o vídeo sem compressão de 2004 viram Opus e codecs modernos. O jogador não percebe; a conta de banda, sim.
- Faça cache a sério: um jogador que volta deve pagar um custo de rede próximo de zero. Bundles imutáveis com hash no conteúdo tornam isso trivial.
Multiplayer que o original nunca teve
A parte mais impressionante do port não é o jogo rodar, e sim ver desconhecidos fazendo burnouts uns ao redor dos outros no roam livre. Os serviços online do Underground 2 morreram anos atrás. O port ressuscita o multiplayer do único jeito que funciona para jogos mortos: substituir o serviço morto, não o jogo. O código recompilado ainda faz as chamadas de rede originais; a camada de shim as redireciona para um backend moderno, e de repente um jogo de 2004 tem crews, sessões compartilhadas de roam livre e links para entrar no jogo de um amigo.
Esse padrão vai muito além da nostalgia. Qualquer software com uma dependência de rede morta (jogos antigos, clientes de SaaS abandonados, ferramentas de multiplayer esquecidas) é candidato à mesma cirurgia: recompilar ou envelopar o cliente e reimplementar o protocolo contra um servidor que você controla. A thread do Hacker News fantasiou com um SimCity 2000 em que cada cidade vizinha é rodada por um jogador real. Isso não é sonho; é um projeto de fim de semana em cima exatamente dessa arquitetura. Sincronizar o estado de alguns carros em um mundo compartilhado é terreno bem conhecido, e data channels do WebRTC ou um pequeno servidor WebSocket autoritativo resolvem bem nessa escala.
Um emulador preserva a máquina. Uma recompilação preserva o software, e é o software que as pessoas realmente sentem falta.
Onde a tese contraintuitiva deixa de se sustentar
Eu disse que a recompilação vence a emulação na preservação, e acredito nisso, mas vamos ser honestos sobre os custos. Um emulador generaliza: um único Dolphin roda milhares de jogos de GameCube. Uma recompilação é artesanal. Cada título é uma campanha própria de engenharia reversa, meses de análise para um único binário, e o resultado só roda aquele jogo. Se o seu objetivo é arquivar uma biblioteca inteira, emuladores ganham em volume, e nem é uma disputa.
Há também o elefante na sala: a legalidade. O código recompilado fica em uma zona cinzenta a hostil, dependendo da jurisdição, e hospedar os assets do jogo original (os carros, o mapa, a faixa do Snoop Dogg) não é cinzento de forma alguma. O Underground 2 é abandonware na prática, já que não se compra em lugar nenhum e o licenciamento musical provavelmente mantém assim, mas abandonware é um conceito folclórico, não jurídico. Quem prevê um takedown provavelmente tem razão, e o próprio projeto mantém um endereço de contato para “detentores de direitos” pronto, o que mostra que o autor também sabe disso. A técnica é sólida e legal quando você é dono do binário ou dos direitos; esta instância específica vive com tempo emprestado.
E um limite honesto a mais: a recompilação brilha quando o hardware alvo é muito diferente da origem, exatamente quando a emulação fica mais cara. Para uma reprodução fiel de comportamentos sensíveis a temporização (precisão aceitável para speedrun, bugs de hardware tratados como features), a emulação com precisão de ciclo continua sendo a única resposta correta. Essas abordagens não são tanto rivais quanto respostas a perguntas diferentes: “rodar bem em qualquer lugar” versus “rodar exatamente igual”.
O que desenvolvedores web devem levar disso
Tirando a nostalgia, sobra uma stack que deve parecer familiar: wasm como alvo de compilação portável, WebGPU como backend de renderização de verdade, range requests HTTP e Cache Storage como sistema de arquivos, WebSocket/WebRTC como um serviço de rede ressuscitado. Nada disso é exótico. Equipes já distribuem Python dessa forma: já cobrimos como o Pyodide roda CPython de verdade no navegador usando o mesmo toolchain do Emscripten. Um jogo de corrida é uma demonstração mais difícil da mesma tese: o navegador é um alvo de deploy para código nativo sério, não um visualizador de documentos com delírios de grandeza.
A aba do navegador rodando Underground 2 a 120 fps com amigos no roam livre faz algo que nenhuma quantidade de infraestrutura de game streaming financiada por venture capital conseguiu: zero instalação, compartilhamento instantâneo por URL, funciona no celular. Essa é a história de verdade. O toolchain para ressuscitar software nativo como software web já existe, é em grande parte open source, e as partes difíceis (descompilação, camadas de shim, streaming de assets) são problemas de engenharia, não de pesquisa. Espere ver cada vez mais disso, com notificações de takedown e tudo.


