Ricompilazione statica: i giochi console nel browser
La ricompilazione statica rende portabili i binari di vecchie console e PC. Ecco come WebAssembly e WebGPU fanno girare interi giochi in una scheda del browser.

La cosa migliore capitata alla conservazione dei videogiochi in un decennio non è un emulatore migliore. È un compilatore. Quando un gioco di corse completo del 2004, con free roam online, supporto ai controller e rendering widescreen a 120 fps, gira in una scheda del browser, la reazione naturale è pensare che qualcuno abbia costruito un emulatore molto ingegnoso. Non è così. Hanno fatto qualcosa di più strano e, direi, molto più importante: hanno fatto passare il codice macchina originale del gioco attraverso una specie di decompilatore al contrario, lo hanno trasformato in C e lo hanno ricostruito come modulo WebAssembly. Questa è la ricompilazione statica, e sta silenziosamente diventando il modo più pratico per far girare vecchio software ovunque.
Emulazione vs ricompilazione: una biforcazione
Gli emulatori rispondono alla domanda «come facciamo a far girare questo binario?» ricreando la macchina che il binario si aspetta. La CPU dell'host finge di essere un chip MIPS o PowerPC, istruzione per istruzione, ciclo per ciclo. Funziona — MAME, Dolphin e PCSX2 sono miracoli — ma il conto si paga per sempre. Ogni frame stai traducendo istruzioni per un hardware che ha smesso di esistere quindici anni fa, e le stranezhe di temporizzazione del silicio originale diventano bug che devi riprodurre con cura.
La ricompilazione statica fa la scommessa opposta. Invece di interpretare il binario a runtime, lo analizzi una volta, offline, e lo traduci in un linguaggio portabile, di solito C. L'output non è un simulatore dell'hardware vecchio. È un nuovo programma che calcola le stesse cose. Lo compili con clang, scegli il target che vuoi, e il risultato gira a velocità nativa. Quando il target è wasm32, il risultato gira in Chrome.
La genealogia di questo approccio merita di essere conosciuta. Progetti come N64: Recompiled e XenonRecomp hanno dimostrato il modello sui titoli console, e NFSU2Recomp ha applicato la stessa idea alla versione PC x86 di Need for Speed: Underground 2, traducendo l'eseguibile originale in C, poi forkato e collegato a WebGPU, Web Audio e alle moderne API di input. Quest'ultimo passaggio è quello a cui gli sviluppatori web dovrebbero prestare attenzione, perché è la parte che assomiglia di più al nostro lavoro quotidiano: una pipeline di asset, un backend di rendering e uno strato di rete.
Perché tradurre x86 in C è più difficile di quanto sembri
Tradurre una ROM di console è quasi civile rispetto a tradurre un eseguibile per PC. Un binario N64 è un'immagine piatta che gira su bare metal con una mappa di memoria fissa. Un gioco PC del 2004 è un file PE generato da un compilatore ottimizzante, che effettua chiamate indirette tramite vtable, salta attraverso le tabelle di import e mescola liberamente codice e dati in modi che rendono l'analisi statica davvero difficile.
Il problema centrale è che il codice macchina ha perso tutte le informazioni sui tipi. Il ricompilatore vede call eax e deve capire a cosa potrebbe mai puntare eax: quali puntatori a funzione confluiscono in quel registro, da quali tabelle, popolate dove. Se sbaglia, o perde percorsi di codice (il gioco crasha alla terza gara) oppure classifica dati come codice (il disassemblatore rovina tutto ciò che viene dopo). Per questo questi progetti si appoggiano all'analisi interattiva con strumenti come IDA o Ghidra, più annotazioni manuali e un bel po' di playtesting.
Il risultato non è un C bello da leggere. Assomiglia a questo:
// 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;
}
I registri diventano campi di struct, la memoria diventa un grande array di byte e il flusso di controllo diventa funzioni che chiamano altre funzioni. Nessuno lo scriverebbe a mano, e nessuno deve mantenerlo a mano: è un artefatto intermedio. Ciò che conta è che sia compilabile e, una volta che compila per un target, compila per tutti. Ecco il vantaggio.
WebAssembly è la parte facile
Ecco la tesi controcorrente, guadagnata sul campo: far compilare il C ricompilato come modulo .wasm è l'ingegneria meno interessante dell'intero progetto. Emscripten e il target wasm di clang sono solidi da anni. Se il codice è C portabile, senza assembly inline e senza assunzioni forti sulle dimensioni dei puntatori oltre i 32 bit, di solito compila senza problemi. Abbiamo già scritto di casi in cui WebAssembly non è più veloce di JavaScript, ma questo rientra pienamente nel campo d'azione di wasm: cicli numerici stretti, un'unica grande memoria lineare, nessun chiacchiericcio con il DOM. JavaScript, anche con il JIT già a regime, non può competere.
Il vero lavoro è tutto ciò a cui il gioco chiama. Il binario originale si aspetta Direct3D 9, DirectInput e lo stack audio di Windows. Nel browser non c'è nulla di tutto ciò. Quindi il port deve costruire uno strato di shim: ogni chiamata grafica fatta dal gioco viene intercettata e riespressa in un'API moderna che il browser capisce. Qui WebGPU si guadagna il suo posto: è la prima API grafica per il web con un livello di astrazione abbastanza basso da permettere di mappare una pipeline a funzioni fisse di inizio anni 2000 senza affogare nell'overhead. Il risultato dichiarato, fino a 120 fps in widescreen con free roam e corse online, è qualcosa che WebGL non avrebbe offerto con altrettanta comodità.
Un avvertimento importante per chi lavora sul campo: il supporto a WebGPU è ancora disomogeneo. Su Linux, gli utenti di Chromium spesso devono avviare il browser con flag come --enable-unsafe-webgpu --use-angle=vulkan per ottenere un adapter funzionante. «Gira nel browser» oggi significa «gira benissimo in Chrome e Firefox, sul sistema operativo giusto e con i driver GPU giusti». È un vero problema di distribuzione, ma non è ancora un problema universale.

Trasmettere due gigabyte in una scheda
Il codice occupa pochi megabyte. Gli asset sono il restante 95% di un gioco, ed è qui che un port nel browser diventa un problema di ingegneria web nel senso più familiare. Un racing open world di metà anni 2000 contiene gigabyte di geometrie, texture, audio e video FMV. Nessuno li scarica da una landing page. Quindi si costruisce ciò che i team di game streaming e dei grandi siti già sanno fare: una pipeline di asset pigra, con richieste a range e cache.
Di solito la struttura è questa: gli archivi originali degli asset vengono riconfezionati in bundle a chunk, un indice associa «l'asset che il motore ha appena richiesto» a «un intervallo di byte in un certo bundle», e il layer di filesystem virtuale recupera i dati via HTTP con range request, facendo cache aggressiva tramite la Cache Storage API o IndexedDB, così la seconda visita è istantanea. Il motore crede di leggere da un DVD; in realtà legge da un service worker. Se hai mai lavorato su pipeline di streaming di dati geografici, l'architettura è la stessa: chunk indirizzati dal contenuto, un indice e un client che finge che la rete sia un disco.
- Riconfeziona una volta, servi per sempre: converti gli archivi originali in chunk di dimensione fissa, così le range request HTTP e la cache CDN fanno il lavoro pesante.
- Precarica in base alle previsioni: il garage, il primo quartiere e la musica del menu servono nel primo minuto; il quartiere dell'aeroporto può aspettare.
- Transcodifica senza pietà: l'audio e il video non compressi del 2004 diventano Opus e codec moderni. Il giocatore non se ne accorge; la bolletta della banda sì.
- Fai cache sul serio: un giocatore che torna dovrebbe pagare un costo di rete quasi nullo. Bundle immutabili con hash nel nome rendono tutto banale.
Il multiplayer che l'originale non aveva mai avuto
La parte più impressionante del port nel browser non è che il gioco giri, ma che sconosciuti stiano facendo burnout uno intorno all'altro in free roam. I servizi online di Underground 2 sono morti anni fa. Il port riporta in vita il multiplayer nell'unico modo che funziona davvero per i giochi morti: sostituire il servizio morto, non il gioco. Il codice ricompilato continua a fare le sue chiamate di rete originali; lo strato di shim le reindirizza verso un backend moderno, e all'improvviso un gioco del 2004 ha crew, sessioni di free roam condivise e link per unirsi a un amico.
È un pattern che va ben oltre la nostalgia. Qualsiasi software con una dipendenza di rete morta (vecchi giochi, client SaaS dismessi, strumenti multiplayer abbandonati) è candidato alla stessa operazione: ricompilare o avvolgere il client, reimplementare il protocollo su un server che controlli. Il thread di Hacker News fantasticava su un SimCity 2000 in cui ogni città vicina è gestita da un giocatore reale. Non è un sogno irrealizzabile: è un progetto da weekend costruito proprio su questa architettura. La sincronizzazione dello stato di poche auto in un mondo condiviso è terreno battuto: i data channel WebRTC o un piccolo server WebSocket autorevole fanno entrambi il lavoro a questa scala.
Un emulatore preserva la macchina. Una ricompilazione preserva il software, ed è il software che la gente davvero rimpiange.
Dove l'affermazione controcorrente non regge
Ho detto che la ricompilazione batte l'emulazione per la conservazione, e ci credo, ma siamo onesti sui costi. Un emulatore generalizza: un solo Dolphin fa girare migliaia di giochi GameCube. Una ricompilazione è artigianale. Ogni titolo è una campagna di reverse engineering a sé, mesi di analisi per un solo binario, e il risultato gira solo quel gioco. Se l'obiettivo è archiviare un'intera libreria, gli emulatori vincono sul throughput e non c'è partita.
C'è poi l'elefante nella stanza: la legalità. Il codice ricompilato si trova in una zona che va dal grigio all'ostile a seconda della giurisdizione, e ospitare gli asset del gioco originale (le auto, la mappa, la traccia di Snoop Dogg) non è affatto grigio. Underground 2 è abandonware in senso pratico (non si può comprare da nessuna parte; le licenze musicali probabilmente lo mantengono così), ma abandonware è un concetto folkloristico, non giuridico. I commentatori che prevedono un takedown probabilmente hanno ragione, e il progetto stesso tiene pronto un indirizzo di contatto per i «titolari dei diritti», il che dice che l'autore lo sa bene. La tecnica è valida e lecita quando possiedi il binario o i diritti; questa specifica istanza vive con il tempo preso in prestito.
Un limite onesto in più: la ricompilazione brilla quando l'hardware di destinazione è molto diverso da quello di origine, cioè esattamente quando l'emulazione costa di più. Per una riproduzione fedele di comportamenti sensibili al timing (precisione da speedrun legittimo, bug hardware trattati come funzionalità), l'emulazione cycle-accurate resta l'unica risposta corretta. Questi due approcci non sono tanto rivali quanto risposte a domande diverse: «fallo girare bene ovunque» contro «fallo girare esattamente».
Cosa dovrebbero portarsi a casa gli sviluppatori web
Togliendo la nostalgia, resta uno stack che dovrebbe sembrarti familiare: wasm come target di compilazione portabile, WebGPU come vero backend di rendering, richieste range HTTP e Cache Storage come filesystem, WebSocket e WebRTC come servizio di rete resuscitato. Niente di esotico. I team distribuiscono già Python in questo modo: abbiamo raccontato come Pyodide esegue CPython reale nel browser usando la stessa toolchain Emscripten. Un gioco di corse è una dimostrazione più difficile della stessa tesi: il browser è un target di deployment per codice nativo serio, non un visualizzatore di documenti con manie di grandezza.
La scheda del browser che fa girare Underground 2 a 120 fps con amici in free roam fa qualcosa che nessuna infrastruttura di game streaming finanziata da venture capital è riuscita a fare: zero installazione, condivisione istantanea tramite URL, funziona sul telefono. Questa è la vera storia. La toolchain per resuscitare software nativo come software web esiste ora, è per lo più open source, e le parti difficili (decompilazione, strati di shim, streaming degli asset) sono problemi di ingegneria, non di ricerca. Aspettatevi di vederne molto di più, avvisi di takedown compresi.


