DOOM en expressions régulières : quand les regexes deviennent un moteur de jeu

Imaginez un ordinateur qui ne s’appuie pas sur des circuits électroniques pour exécuter un programme, mais sur une **chaîne de 96,6 Mo** composée de règles de correspondance textuelle. Imaginez DOOM, le jeu emblématique des années 90, reconstruit pixel par pixel grâce à des expressions régulières (regex), ces outils souvent perçus comme trop simples pour faire plus que filtrer du texte. Ce n’est pas une fiction : c’est exactement ce qu’a accompli Artem Lytkin, un hacker russe, en transformant les regexes en un moteur de jeu fonctionnel – bien que très lent.

Cette prouesse technique illustre comment des outils apparemment modestes peuvent défier nos limites technologiques. Mais au-delà du côté spectaculaire, elle révèle une vérité plus profonde : **les regexes sont bien plus puissantes qu’on ne le croit**. Elles incarnent la Turing-complétude, cette capacité à simuler n’importe quel algorithme – même celui d’un jeu vidéo.

Et si un jeu vidéo culte comme DOOM pouvait fonctionner sans processeur ni GPU, uniquement grâce aux expressions régulières ?

Un "CPU" en chaîne de caractères

Pour comprendre comment Artem Lytkin a fait tourner DOOM avec des regexes, il faut d’abord saisir le principe de base : ces expressions ne se contentent pas de chercher du texte. Elles peuvent aussi **exécuter du code**. En théorie, les regexes sont classées parmi les *langages de programmation complets*, capables – à condition d’avoir assez de mémoire et de patience – de réaliser n’importe quelle tâche calculatoire.

Dans son projet, Artem a conçu un **”micro-ordinateur” virtuel** où chaque composant du jeu (mémoire, registres, affichage) est stocké et manipulé sous forme de **motifs textuels**. Résultat : tout le moteur de DOOM, y compris les graphismes et les niveaux, repose sur une structure monolithique de 96,6 Mo. Cette chaîne colossale contient :

– La **RAM virtuelle** du “processeur”, où sont stockées les variables (position du joueur, score, etc.).
– Les **registres CPU**, gérés via des marqueurs textuels comme `[X=120]`.
– Le **framebuffer**, une zone dédiée à l’affichage pixel par pixel.
– Le **code compilé** du moteur, traduit en règles de substitution complexes.

Le principe est simple : le programme en C applique des millions de règles du type *”si ce motif apparaît dans la chaîne, remplace-le par celui-ci et exécute cette opération”*. Après **plus de 10 000 substitutions successives**, le texte évolue… et DOOM progresse, cadre après cadre.

Pour visualiser l’analogie, imaginez un éditeur de texte comme Notepad++ poussé à son extrême : chaque instruction du jeu est une règle de *trouver/remplacer* appliquée en boucle. Le tout fonctionne comme un ordinateur des années 80 sous stéroïdes – mais en version textuelle pure.

Comment les regexes simulent-elles un ordinateur ?

La magie de ce projet repose sur la **Turing-complétude** des regexes, une propriété qui permet à ces outils de simuler n’importe quel algorithme. Artem a exploité cette capacité pour recréer les éléments clés d’un système informatique :

1. **Une mémoire virtuelle dans du texte**
Les données (comme la position du joueur ou le score) sont encodées sous forme de marqueurs textuels. Par exemple, un déplacement vers la droite s’opère en trouvant une ligne comme `[X=120]`, puis en modifiant dynamiquement ce motif pour écrire `[X=121]` via des regexes.

2. **Des instructions en “trouver/remplacer”**
Les opérations logiques (sauts conditionnels, chargement de valeurs) sont traduites en règles de substitution. Par exemple :
> *”Si le pointeur PC (Program Counter) pointe vers `[PC=0x123]`, remplace la suite par le code qui charge 5 dans un registre.”*

3. **Un affichage pixel par pixel**
Le *framebuffer* est une portion du texte dédiée aux couleurs et positions. Les regexes parcourent cette zone pour “peindre” chaque pixel selon les règles graphiques de DOOM. Une fois l’écran reconstitué, la chaîne est convertie en image avant que le cycle ne recommence.

Le résultat ? Un jeu qui tourne à **80 000 substitutions par seconde** – suffisant pour observer un gameplay rudimentaire, mais bien loin des performances actuelles. Pour donner une idée de la lenteur : ce rythme équivaut approximativement au frame rate d’un smartphone des années 2010.

Pourquoi ce projet est-il fascinant – et comment l’essayer ?

Bien que jouer à DOOM avec une chaîne de 96,6 Mo n’ait aucun intérêt pratique (les regexes sont bien trop lentes pour être utilisées comme moteur moderne), ce projet révèle des enseignements majeurs :

– **Les limites du texte** : Les regexes prouvent qu’un simple langage de correspondance peut devenir un *supercalculateur* si on lui donne assez de ressources. C’est comme utiliser des règles de grammaire pour simuler un ordinateur.
– **La puissance des langages minimaux** : Artem a démontré que même un outil aussi basique que les regexes peut être Turing-complet, ouvrant la porte à des applications inattendues (traitement d’images optimisé, bases de données textuelles complexes…).
– **Une source d’inspiration créative** : Ce genre de défi pousse les développeurs à repousser les limites de leurs outils. Et si demain, un logiciel utilisait des regexes pour accélérer des calculs ou organiser des données ?

Pour ceux qui souhaitent reproduire l’expérience (avec une patience de moine), le projet est disponible sur **GitHub**. Voici comment procéder :
1. Télécharger le dépôt contenant la chaîne géante et les règles précompilées.
2. Installer Python 3 et un compilateur C comme GCC.
3. Compiler le *driver* fourni avec la commande indiquée dans la documentation.
4. Lancer l’émulation… et s’armer de patience. Les premiers mouvements seront d’une lenteur insupportable, mais après quelques minutes, des pixels commenceront à bouger.

**Attention** : ne vous attendez pas à une expérience fluide. Le but n’est pas le divertissement, mais de **voir un moteur de jeu fonctionner grâce à du texte pur**. Et c’est déjà un exploit.

Pour conclure sur : " DOOM en expressions régulières : quand les regexes deviennent un moteur de jeu "

Ce projet d’Artem Lytkin dépasse largement le cadre d’un simple gag technique. Il rappelle que les outils les plus simples peuvent cacher des capacités insoupçonnées – à condition d’en exploiter toute la puissance théorique. Les regexes, souvent réduites à leur rôle de filtre basique, se révèlent ici comme un **langage universel capable de simuler une machine entière**.

Bien sûr, on ne jouera jamais à DOOM avec cette méthode dans la vie réelle. Mais grâce à des initiatives comme celle-ci, nous réalisons que la technologie n’a pas de limites… seulement celles de notre imagination – et de nos disques durs.

Source : https://hackaday.com/2026/07/28/doom-using-regular-expressions/