Des articles approfondis sur les technologies qui façonnent l'avenir.

Recompilation statique : jeux console dans le navigateur

La recompilation statique rend portables les vieux binaires console et PC. WebAssembly et WebGPU font tourner des jeux complets dans un onglet.

Illustration d'un disque de jeu transformé par un pipeline mécanique en un faisceau de lumière qui se diffuse vers l'écran d'un ordinateur portable
La recompilation statique transforme un binaire figé en code source portable : le jeu survit, peu importe la plateforme.

Le meilleur événement pour la préservation des jeux depuis une décennie n'est pas un meilleur émulateur. C'est un compilateur. Quand un jeu de course complet de 2004 (avec exploration libre en ligne, prise en charge des manettes et rendu en format large à 120 fps) apparaît en train de tourner dans un onglet de navigateur, la réaction naturelle est de supposer que quelqu'un a construit un émulateur très astucieux. Ce n'est pas le cas. Ils ont fait quelque chose de plus étrange et, selon moi, bien plus important : ils ont fait remonter le code machine original du jeu à travers une sorte de décompilateur, l'ont transformé en C et reconstruit en module WebAssembly. C'est la recompilation statique, et elle devient discrètement la façon la plus pratique de faire tourner un vieux logiciel n'importe où.

Émulation ou recompilation : une bifurcation

Les émulateurs répondent à la question « comment faire tourner ce binaire ? » en recréant la machine qu'il attendait. Le processeur de votre hôte fait semblant d'être une puce MIPS ou PowerPC, instruction par instruction, cycle par cycle. Ça marche (MAME, Dolphin et PCSX2 sont des miracles), mais on paie ce prix pour toujours. À chaque image, vous traduisez des instructions destinées à du matériel disparu depuis quinze ans, et les particularités de timing du silicium d'origine deviennent des bugs qu'il faut reproduire avec soin.

La recompilation statique fait le pari inverse. Au lieu d'interpréter le binaire à l'exécution, on l'analyse une fois, hors ligne, et on le transpose dans un langage portable, généralement du C. Le résultat n'est pas un simulateur de l'ancien matériel. C'est un nouveau programme qui calcule les mêmes choses. On le compile avec clang, pour la cible voulue, et il tourne à vitesse native. Quand la cible est wasm32, le résultat tourne dans Chrome.

L'historique mérite d'être connu. Des projets comme N64: Recompiled et XenonRecomp ont validé le principe sur des jeux console, et NFSU2Recomp a appliqué la même idée à la version PC x86 de Need for Speed: Underground 2, en traduisant l'exécutable original en C, ensuite forké et connecté à WebGPU, Web Audio et aux API d'entrée modernes. Cette dernière étape est celle que les développeurs web devraient suivre de près, car elle ressemble le plus à notre quotidien : un pipeline d'assets, un backend de rendu et une couche réseau.

Pourquoi le passage du x86 vers le C est plus difficile qu'il n'y paraît

Transposer une ROM de console est presque raisonnable comparé à un exécutable PC. Un binaire N64 est une image plate qui tourne directement sur le matériel, avec une carte mémoire fixe. Un jeu PC de 2004 est un fichier PE produit par un compilateur optimisant, qui fait des appels indirects via des vtables, saute à travers des tables d'imports et mélange librement code et données, ce qui rend l'analyse statique réellement ardue.

Le problème central, c'est que le code machine a perdu toute information de type. Le recompilateur voit call eax et doit deviner ce que eax peut bien pointer : quels pointeurs de fonction arrivent dans ce registre, depuis quelles tables, remplies où. Si l'on se trompe, on rate des chemins d'exécution (le jeu plante à la troisième course) ou on prend des données pour du code (le désassembleur fait tout dérailler en aval). C'est pourquoi ces projets s'appuient sur l'analyse interactive avec des outils comme IDA ou Ghidra, plus des annotations manuelles, plus beaucoup de tests en conditions réelles.

Le résultat n'est pas du C élégant. Il ressemble à ceci :

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

Les registres deviennent des champs de struct, la mémoire devient un grand tableau d'octets et le flux de contrôle devient des fonctions qui appellent d'autres fonctions. Personne n'écrirait ça à la main, et personne n'a à le maintenir à la main non plus : c'est un artefact intermédiaire. Ce qui compte, c'est qu'il soit compilable, et une fois qu'il compile pour une cible, il compile pour toutes les autres. C'est là le gain.

WebAssembly, c'est la partie facile

Voici le point à contre-courant, bien mérité : faire compiler le C recompilé en module .wasm est l'ingénierie la moins intéressante de tout le projet. Emscripten et la cible wasm de clang sont solides depuis des années. Si votre code est du C portable, sans assembleur inline et sans hypothèses fortes sur la taille des pointeurs au-delà du 32 bits, il se compile en général sans difficulté. Nous avons déjà écrit sur les cas où WebAssembly n'est pas plus rapide que JavaScript, mais ceci relève pleinement du domaine de wasm : des boucles numériques serrées, une grande mémoire linéaire unique, pas de bavardage avec le DOM. Un JavaScript échauffé par le JIT ne peut pas rivaliser.

Le vrai travail, c'est tout ce que le jeu appelle. Le binaire d'origine croit disposer de Direct3D 9, de DirectInput et de la pile audio de Windows. Dans le navigateur, rien de tout cela n'existe. Le portage doit donc construire une couche de shim : chaque appel graphique du jeu est intercepté et réexprimé dans une API moderne que le navigateur comprend. C'est là que WebGPU prouve son utilité. C'est la première API graphique web d'un niveau d'abstraction assez bas pour projeter un pipeline à fonctions fixes du début des années 2000 sans être noyé dans le surcoût. Le résultat annoncé (jusqu'à 120 fps en format large, avec exploration libre et courses en ligne) n'est pas quelque chose que WebGL aurait permis confortablement.

Une mise en garde à signaler aux praticiens : la prise en charge de WebGPU reste inégale. Sous Linux, les utilisateurs de Chromium doivent souvent lancer le navigateur avec des options comme --enable-unsafe-webgpu --use-angle=vulkan pour obtenir un adaptateur fonctionnel. « Ça tourne dans le navigateur » signifie aujourd'hui « ça tourne très bien dans Chrome et Firefox, sur le bon système d'exploitation, avec les bons pilotes GPU ». C'est un vrai sujet de distribution, mais pas encore un sujet universel.

Illustration abstraite en trois couches montrant des circuits emmêlés se démêlant en flux parallèles propres
Le vrai travail du portage se situe dans la couche de shim : les anciens appels Direct3D entrent, les commandes WebGPU modernes sortent.

Diffuser deux gigaoctets dans un onglet

Le code ne pèse que quelques mégaoctets. Les assets représentent les 95 % restants d'un jeu, et c'est là que le portage navigateur devient un problème d'ingénierie web au sens le plus familier. Un jeu de course en monde ouvert du milieu des années 2000 contient des gigaoctets de géométrie, de textures, d'audio et de vidéos FMV. Personne ne va télécharger tout cela depuis une page d'accueil. On construit donc ce que toutes les équipes de streaming de jeux et de gros sites savent déjà faire : un pipeline d'assets paresseux, à requêtes partielles et mis en cache.

En général, cela ressemble à ceci : les archives d'assets d'origine sont réempaquetées en lots découpés en morceaux, un index associe « l'asset que le moteur vient de demander » à « la plage d'octets dans tel lot », et la couche de système de fichiers virtuel récupère les données en HTTP avec des requêtes par plages, en les mettant en cache agressivement via l'API Cache Storage ou IndexedDB, si bien que la seconde visite est instantanée. Le moteur croit lire un DVD ; il lit en réalité depuis un service worker. Si vous avez déjà travaillé sur des pipelines de streaming de données géographiques, l'architecture est la même : des morceaux adressés par leur contenu, un index, et un client qui fait comme si le réseau était un disque.

  • Réempaqueter une fois, servir ensuite indéfiniment : convertir les archives d'origine en morceaux de taille fixe pour que les requêtes HTTP par plages et la mise en cache CDN fassent l'essentiel du travail.
  • Précharger par prédiction : le garage, le premier quartier et la musique du menu sont nécessaires dès la première minute ; le quartier de l'aéroport peut attendre.
  • Transcoder sans pitié : l'audio et la vidéo non compressés de 2004 deviennent de l'Opus et des codecs modernes. Le joueur ne voit pas la différence ; la facture de bande passante, si.
  • Mettre en cache sérieusement : un joueur qui revient doit payer un coût réseau quasi nul. Des lots immuables indexés par hash de contenu rendent cela trivial.

Le multijoueur que l'original n'a jamais eu

La partie la plus impressionnante du portage navigateur n'est pas que le jeu tourne : ce sont des inconnus qui font des dérapages les uns autour des autres en exploration libre. Les services en ligne d'Underground 2 ont disparu il y a des années. Le portage ressuscite le multijoueur de la seule façon qui fonctionne pour les jeux morts : remplacer le service mort, pas le jeu. Le code recompilé effectue toujours ses appels réseau d'origine ; la couche de shim les redirige vers un backend moderne, et soudain un jeu de 2004 possède des équipes, des sessions partagées en exploration libre et des liens pour rejoindre un ami.

C'est un schéma qui va bien au-delà de la nostalgie. Tout logiciel dont une dépendance réseau est morte (vieux jeux, clients SaaS abandonnés, outils multijoueurs à l'arrêt) est candidat à la même opération : recompiler ou encapsuler le client, puis réimplémenter le protocole sur un serveur que l'on contrôle. Le fil Hacker News rêvait d'un SimCity 2000 où chaque ville voisine serait gérée par un vrai joueur. Ce n'est pas une utopie ; c'est un projet de week-end construit exactement sur cette architecture. La synchronisation d'état pour quelques voitures dans un monde partagé est un terrain bien balisé : les canaux de données WebRTC ou un petit serveur WebSocket faisant autorité suffisent à cette échelle.

Un émulateur préserve la machine. Une recompilation préserve le logiciel, et c'est le logiciel qui manque vraiment aux gens.

Là où la thèse à contre-courant montre ses limites

J'ai dit que la recompilation l'emporte sur l'émulation pour la préservation, et j'y crois, mais soyons honnêtes sur les coûts. Un émulateur généralise : un seul Dolphin fait tourner des milliers de jeux GameCube. Une recompilation est artisanale. Chaque titre est sa propre campagne de rétro-ingénierie, avec des mois d'analyse pour un seul binaire, et le résultat ne fait tourner que ce jeu-là. Si votre objectif est d'archiver toute une bibliothèque, les émulateurs gagnent sur le débit, et ce n'est même pas serré.

Il y a aussi l'éléphant dans la pièce : la légalité. Le code recompilé se situe dans une zone grise, voire hostile, selon la juridiction, et héberger les assets du jeu d'origine (les voitures, la carte, le morceau de Snoop Dogg) n'a rien de gris du tout. Underground 2 est un abandonware au sens pratique, puisqu'on ne peut plus l'acheter nulle part et que les licences musicales risquent de le maintenir ainsi, mais l'abandonware est une notion populaire, pas juridique. Les commentateurs qui prédisent un retrait ont probablement raison, et le projet lui-même garde une adresse de contact pour les « ayants droit », ce qui montre que l'auteur le sait aussi. La technique est saine et légale quand on possède le binaire ou les droits ; cette instance précise vit sur du temps emprunté.

Et une limite de plus, en toute honnêteté : la recompilation brille lorsque le matériel cible est radicalement différent de la source, précisément là où l'émulation coûte le plus cher. Pour une reproduction fidèle d'un comportement sensible au timing (une précision digne des speedruns, des bugs matériels considérés comme des fonctionnalités), l'émulation cycle-précise reste la seule réponse correcte. Ces deux approches ne sont pas tant rivales que des réponses à des questions différentes : « le faire tourner bien partout » contre « le faire tourner exactement ».

Ce que les développeurs web doivent retenir

Une fois la nostalgie écartée, il reste une pile qui devrait vous sembler familière : wasm comme cible de compilation portable, WebGPU comme vrai backend de rendu, requêtes HTTP par plages et Cache Storage comme système de fichiers, WebSocket et WebRTC comme service réseau ressuscité. Rien de tout cela n'est exotique. Des équipes livrent déjà du Python de cette façon : nous avons présenté comment Pyodide fait tourner un vrai CPython dans le navigateur avec la même chaîne d'outils Emscripten. Un jeu de course est une démonstration plus exigeante de la même thèse : le navigateur est une cible de déploiement pour du code natif sérieux, pas un visualiseur de documents qui se prend pour autre chose.

L'onglet qui fait tourner Underground 2 à 120 fps avec des amis en exploration libre accomplit ce qu'aucune infrastructure de streaming de jeux financée par le capital-risque n'a réussi : zéro installation, partage instantané par URL, fonctionnement sur un téléphone. C'est là le vrai enjeu. La chaîne d'outils pour faire revivre un logiciel natif en logiciel web existe désormais, elle est pour l'essentiel open source, et les parties difficiles (décompilation, couches de shim, streaming d'assets) sont des problèmes d'ingénierie, pas de recherche. Attendez-vous à en voir beaucoup plus, avec retraits de droits et tout le reste.