Artículos en profundidad sobre la tecnología que da forma al futuro.

Recompilación estática: juegos de consola en el navegador

La recompilación estática convierte binarios viejos de consola y PC en código portable. Con WebAssembly y WebGPU, juegos enteros corren en una pestaña.

Ilustración de un disco de juego transformado por una cadena mecánica en luz que fluye hacia la pantalla de un portátil
La recompilación estática convierte un binario fijo en código fuente portable: el juego sobrevive, y la plataforma deja de importar.

Lo mejor que le ha pasado a la preservación de videojuegos en una década no es un emulador mejor. Es un compilador. Cuando un juego de carreras completo de 2004, con conducción libre online, soporte de mando y renderizado en widescreen a 120 fps, aparece corriendo en una pestaña del navegador, la reacción natural es suponer que alguien construyó un emulador muy ingenioso. No lo hicieron. Hicieron algo más raro y, diría yo, mucho más importante: ejecutaron el código máquina original del juego al revés a través de una especie de descompilador, lo convirtieron en C y lo reconstruyeron como un módulo WebAssembly. Eso es recompilación estática, y se está convirtiendo silenciosamente en la forma más práctica de hacer que el software antiguo funcione en cualquier parte.

Emulación frente a recompilación: una bifurcación en el camino

Los emuladores responden a la pregunta «¿cómo ejecutamos este binario?» recreando la máquina que esperaba. Tu CPU host finge ser un chip MIPS o PowerPC, instrucción por instrucción, ciclo por ciclo. Funciona (MAME, Dolphin y PCSX2 son auténticos milagros), pero lo pagas para siempre. En cada frame estás traduciendo instrucciones para un hardware que dejó de existir hace quince años, y las peculiaridades de temporización del silicio original se convierten en bugs que tienes que reproducir con mimo.

La recompilación estática apuesta en sentido contrario. En lugar de interpretar el binario en tiempo de ejecución, lo analizas una vez, sin conexión, y lo llevas a un lenguaje portable, normalmente C. El resultado no es un simulador del hardware antiguo. Es un programa nuevo que calcula exactamente lo mismo. Lo compilas con clang, apuntas al destino que quieras y el resultado corre a velocidad nativa. Cuando el destino es wasm32, el resultado corre en Chrome.

La genealogía merece conocerse. Proyectos como N64: Recompiled y XenonRecomp demostraron el patrón con títulos de consola, y NFSU2Recomp aplicó la misma idea a la versión x86 para PC de Need for Speed: Underground 2: tradujo el ejecutable original a C, que luego se bifurcó y se conectó a WebGPU, Web Audio y APIs de entrada modernas. Ese último paso es el que los desarrolladores web deberían mirar con atención, porque es el que más se parece a nuestro día a día: un pipeline de assets, un backend de renderizado y una capa de red.

Por qué pasar de x86 a C es más difícil de lo que parece

Recompilar una ROM de consola es casi civilizado comparado con recompilar un ejecutable de PC. Un binario de N64 es una imagen plana que corre sobre el metal con un mapa de memoria fijo. Un juego de PC de 2004 es un archivo PE generado por un compilador optimizador, que hace llamadas indirectas a través de vtables, salta por tablas de importación y mezcla código y datos libremente, lo que hace que el análisis estático sea realmente difícil.

El problema central es que el código máquina ha perdido toda la información de tipos. El recompilador ve call eax y tiene que averiguar a qué podría apuntar eax: qué punteros a función fluyen hacia ese registro, desde qué tablas y rellenados dónde. Si lo haces mal, o te pierdes rutas de código (el juego se cae en la tercera carrera) o clasificas datos como código (el desensamblador destroza todo lo que viene después). Por eso estos proyectos se apoyan en análisis interactivo con herramientas como IDA o Ghidra, en anotaciones manuales y en muchísimas horas de pruebas jugando.

El resultado no es C bonito. Se parece a esto:

// 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;
}

Los registros se convierten en campos de structs, la memoria en un gran array de bytes y el flujo de control en funciones que llaman a otras funciones. Nadie escribiría esto a mano, y nadie tiene que mantenerlo a mano: es un artefacto intermedio. Lo que importa es que sea compilable, y una vez que compila para un destino, compila para todos. Ahí está la recompensa.

WebAssembly es la parte fácil

Aquí va la parte contraria, ganada a pulso: conseguir que el C recompilado se construya como módulo .wasm es la ingeniería menos interesante de todo el proyecto. Emscripten y el target wasm de clang llevan años siendo sólidos. Si tu código es C portable, sin ensamblador inline y sin suposiciones fuertes sobre el tamaño de punteros más allá de 32 bits, prácticamente se compila solo. Ya escribimos sobre casos en los que WebAssembly no es más rápido que JavaScript, pero esto cae de lleno en el terreno de wasm: bucles numéricos ajustados, una única memoria lineal grande y nada de charla con el DOM. El JavaScript con JIT caliente no puede competir con eso.

El trabajo real es todo aquello a lo que el juego llama. El binario original cree que tiene Direct3D 9, DirectInput y la pila de audio de Windows. En el navegador no tiene ninguna de esas cosas. Así que el port tiene que construir una capa de shims: cada llamada gráfica que hace el juego se intercepta y se reexpresa en una API moderna que el navegador entienda. Aquí es donde WebGPU se gana el sueldo: es la primera API gráfica web con un nivel de abstracción lo bastante bajo como para mapear un pipeline de principios de los 2000, de función fija más o menos, sin ahogarte en overhead. El resultado reportado (hasta 120 fps en widescreen, con conducción libre y carreras online) no es algo que WebGL hubiera entregado con holgura.

Una advertencia importante para quien lo vaya a probar: el soporte de WebGPU sigue siendo irregular. En Linux, los usuarios de Chromium suelen necesitar arrancar con flags como --enable-unsafe-webgpu --use-angle=vulkan para obtener un adapter funcional. «Corre en el navegador» significa hoy «corre muy bien en Chrome y Firefox, en el sistema operativo adecuado y con los drivers de GPU correctos». Eso es un problema real de distribución, pero todavía no es uno universal.

Ilustración abstracta de tres capas en la que circuitos enredados se desenredan en flujos paralelos limpios
El trabajo real del port vive en la capa de shims: entran llamadas viejas de Direct3D y salen comandos modernos de WebGPU.

Streaming de dos gigabytes a una pestaña

El código ocupa unos pocos megas. Los assets son el otro 95% de un juego, y aquí es donde un port al navegador se convierte en un problema de ingeniería web en el sentido más familiar. Un juego de carreras de mundo abierto de mediados de los 2000 trae gigabytes de geometría, texturas, audio y vídeo FMV. Nadie va a descargar eso en una landing page. Así que construyes lo que ya saben construir todos los equipos de game streaming y de sitios grandes: un pipeline de assets perezoso, por rangos y con caché.

La forma suele ser esta: los archivos de assets originales se reempaquetan en bundles troceados, un índice mapea «el asset que el motor acaba de pedir» a «rango de bytes en algún bundle», y la capa de sistema de archivos virtual descarga por HTTP con range requests, cacheando agresivamente en Cache Storage o IndexedDB para que la segunda visita sea instantánea. El motor cree que está leyendo de un DVD; en realidad está leyendo de un service worker. Si alguna vez has trabajado con pipelines de datos geográficos en streaming, la arquitectura es el mismo bicho: chunks direccionados por contenido, un índice y un cliente que finge que la red es un disco.

  • Empaqueta una vez, sirve siempre: convierte los archivos originales en chunks de tamaño fijo para que las range requests de HTTP y el caché del CDN hagan el trabajo pesado.
  • Precarga por predicción: el garaje, el primer distrito y la música del menú se necesitan en el primer minuto; el distrito del aeropuerto puede esperar.
  • Transcodifica sin piedad: el audio y el vídeo sin comprimir de la era 2004 pasan a Opus y códecs modernos. El jugador no lo nota; la factura de ancho de banda sí.
  • Cachea en serio: un jugador que vuelve debería pagar un coste de red casi nulo. Los bundles inmutables con hash en el nombre hacen esto trivial.

Multijugador que el original nunca tuvo

Lo más impresionante del port no es que el juego corra, sino que desconocidos estén haciendo burnouts unos alrededor de otros en la conducción libre. Los servicios online de Underground 2 murieron hace años. El port resucita el multijugador de la única forma que funciona para los juegos muertos: reemplazar el servicio muerto, no el juego. El código recompilado sigue haciendo sus llamadas de red originales; la capa de shims las redirige a un backend moderno, y de repente un juego de 2004 tiene crews, sesiones compartidas de conducción libre y enlaces para unirte a un amigo.

Este patrón tiene recorrido mucho más allá de la nostalgia. Cualquier software con una dependencia de red muerta (juegos viejos, clientes de SaaS abandonados, herramientas multijugador olvidadas) es candidato a la misma cirugía: recompilar o envolver el cliente y reimplementar el protocolo contra un servidor que tú controles. El hilo de Hacker News fantaseaba con un SimCity 2000 donde cada ciudad vecina la maneja un jugador real. Eso no es una utopía; es un proyecto de fin de semana sobre exactamente esta arquitectura. La sincronización de estado de unos cuantos coches en un mundo compartido es terreno muy trillado: los data channels de WebRTC o un pequeño servidor WebSocket autoritativo sirven perfectamente a esa escala.

Un emulador preserva la máquina. Una recompilación preserva el software, y el software es lo que la gente realmente echa de menos.

Dónde se rompe la tesis contraria

Dije que la recompilación supera a la emulación para la preservación, y lo creo, pero seamos honestos con los costes. Un emulador generaliza: un solo Dolphin corre miles de juegos de GameCube. Una recompilación es artesanal. Cada título es su propia campaña de ingeniería inversa, meses de análisis para un único binario, y el resultado solo corre ese juego. Si tu objetivo es archivar una biblioteca entera, los emuladores ganan en rendimiento y no hay comparación.

También está el elefante en la habitación: la legalidad. El código recompilado se mueve en una zona de gris a hostil según la jurisdicción, y alojar los assets originales del juego (los coches, el mapa, el tema de Snoop Dogg) no es gris en absoluto. Underground 2 es abandonware en sentido práctico (no se puede comprar en ningún sitio, y las licencias musicales probablemente lo mantienen así), pero abandonware es un concepto popular, no legal. Los comentarios que predicen una retirada probablemente tienen razón, y el propio proyecto mantiene lista una dirección de contacto para «titulares de derechos», lo que indica que el autor también lo sabe. La técnica es sólida y lícita cuando eres dueño del binario o de los derechos; esta instancia concreta vive con tiempo prestado.

Y un límite más, con honestidad: la recompilación brilla cuando el hardware destino es muy distinto del origen, justo cuando la emulación es más cara. Para una reproducción fiel de comportamientos sensibles al tiempo (precisión apta para speedruns, bugs de hardware tratados como características), la emulación con precisión de ciclo sigue siendo la única respuesta correcta. Estos enfoques no son tanto rivales como respuestas a preguntas distintas: «ejecutarlo bien en todas partes» frente a «ejecutarlo exactamente».

Qué debería llevarse un desarrollador web de todo esto

Quitando la nostalgia, queda una pila que debería resultarte familiar: wasm como target de compilación portable, WebGPU como backend de renderizado real, range requests de HTTP y Cache Storage como sistema de archivos, WebSocket/WebRTC como servicio de red resucitado. Nada de eso es exótico. Los equipos ya distribuyen Python así; vimos cómo Pyodide ejecuta CPython real en el navegador usando la misma toolchain de Emscripten. Un juego de carreras es una demo más dura de la misma tesis: el navegador es un destino de despliegue para código nativo serio, no un visor de documentos con delirios de grandeza.

La pestaña del navegador que juega Underground 2 a 120 fps con amigos en la conducción libre está haciendo algo que ninguna cantidad de infraestructura de game streaming financiada con capital riesgo logró: cero instalación, compartir por URL al instante y funciona en el móvil. Esa es la verdadera historia. La toolchain para resucitar software nativo como software web ya existe, es mayormente open source, y las partes difíciles (la descompilación, las capas de shims, el streaming de assets) son problemas de ingeniería, no de investigación. Espera ver mucho más de esto, con avisos de retirada incluidos.