L’évaluation de l’intelligence artificielle générale et des agents autonomes d’apprentissage par renforcement se heurte à un goulot d’étranglement matériel majeur. Les bancs d’essai synthétiques modernes — conçus sur des moteurs comme Unreal Engine 5, Unity ou des simulateurs robotiques haute fidélité — mobilisent des ressources GPU colossales dans le seul but de restituer de la géométrie visuelle et de calculer une physique newtonienne. Si le photoréalisme s’avère indispensable pour la robotique de terrain, il génère une surcharge de calcul superflue lorsqu’il s’agit d’entraîner des agents sur des facultés cognitives fondamentales : navigation spatiale, gestion de ressources à long horizon, coordination tactique et déduction abstraite.

C’est ici qu’intervient Play-dos, un framework de virtualisation ouvert conçu pour transformer les logiciels MS-DOS des années 1990 en bacs à sable d’exécution déterministes et à très haut débit pour la recherche en apprentissage automatique. En convertissant les applications x86 en mode réel et en mode protégé 32 bits en pipelines d’exécution vectorisés et headless, Play-dos s’affranchit de la lourdeur visuelle des environnements contemporains. À la place, il expose la logique pure du jeu, ses états mémoire bruts et des framebuffers à très faible latence aux algorithmes d’apprentissage par renforcement (RL) et aux modèles vision-langage (VLM).

Agent ML Python
(Gymnasium / PyTorch / PettingZoo / Agent VLM)
                                  | IPC Zero-Copy / Mémoire partagée POSIX
+-----------v-----------+
Noyau C++ Play-dos
Machine DOS Headless  |  Introspection RAM  |  Hooks Système
(16-bit / 32-bit DPMI  |  (Scan mémoire)  |  (INT 10/16h)
                                  | Hooks registres et mémoire vidéo
+-----------v-----------+
Binaires de jeux DOS historiques
(Doom, SimCity 2000, Civilization, X-COM)

Architecture de Play-DOS : quand le mode réel 16 bits rencontre le deep RL

Écran rétro affichant un jeu vidéo DOS des années 90 connecté à un modèle d'intelligence artificielle via Play-dos.
Un jeu vidéo classique des années 90 exécuté sur MS-DOS grâce à Play-dos pour tester et entraîner de nouveaux modèles d’intelligence artificielle.

Les systèmes d’exploitation modernes ont depuis longtemps abandonné l’architecture d’interruptions x86 historique et les modèles de mémoire segmentée. Play-dos les réimplémente au sein d’une couche d’hyperviseur instrumentée et isolée, dérivée d’une émulation DOS modulaire, expurgée de tout mixage audio, de synchronisation sonore en temps réel et d’échanges protocolaires avec les puces d’affichage physique.

Émulation headless et couche de virtualisation

Le socle de Play-dos repose sur un démon C++ autonome qui communique directement avec la mémoire de l’hôte via les primitives de mémoire partagée POSIX (shm_open, mmap). À l’opposé des émulateurs DOS grand public conçus pour garantir un rendu audiovisuel fidèle sur moniteur, Play-dos tourne intégralement en mode headless. Sa boucle d’exécution supprime le bridage dynamique des cycles qui synchronisait autrefois les jeux sur des fréquences de 4,77 MHz, 33 MHz ou 66 MHz.

Délivré des verrous de rafraîchissement vertical de l’affichage (VSync à 60 Hz) et des interruptions DAC audio, le moteur d’émulation cadence ses cycles à la vitesse brute du processeur hôte. Un cœur standard AMD EPYC ou Intel Xeon peut exécuter plusieurs milliers de cycles CPU DOS virtuels par milliseconde, permettant aux instances de jeu de franchir le cap des 15 000 images par seconde (FPS).

Extraction du framebuffer et injection directe en mémoire

Play-dos s’accroche directement au plan d’adressage mémoire VGA/EGA virtualisé. Pour le mode standard VGA 13h — la référence graphique des productions des années 90 — le tampon d’affichage physique réside à l’adresse linéaire 0x000A0000.

Au lieu de faire transiter ce tampon par un pipeline de composition OpenGL ou Vulkan pour générer une fenêtre utilisateur, Play-dos intercepte directement la matrice d’octets 320 × 200. Chaque octet correspond à un index dans une palette dynamique 8 bits mappée sur des registres de couleurs RGB. Le framework opère en trois étapes :

  1. Déréférencement de palette : conversion du tableau d’index 8 bits 320 × 200 en un tableau entrelacé uint8 de dimension (200, 320, 3) via des instructions vectorielles SIMD.
  2. Transfert IPC Zero-Copy : écriture du tenseur brut dans un tampon circulaire partagé, directement accessible aux processus Python externes.
  3. Émulation d’interruption : contournement de l’interruption de synchronisation verticale (INT 0x0A / IRQ 2), permettant aux boucles de rendu du jeu de valider les mises à jour d’écran instantanément, sans bloquer l’exécution des instructions CPU.

Parallèlement, les entrées de l’agent contournent la file d’attente d’événements de l’OS hôte. Play-dos intercepte les frappes de clavier et les mouvements de souris en écrivant directement les scancodes dans le tampon circulaire du clavier situé dans la zone de données du BIOS (BDA) entre 0x0040:0x001E et 0x0040:0x003D, ou en déclenchant directement l’interruption logicielle INT 0x16 au cœur du CPU virtuel.

Pipeline d'ingestion directe Mode 13h
[VRAM 0xA0000] ---> [Conversion SIMD Palette] --> [Tampon partagé]
(320×200 @ 8-bit)     (Indexé -> RGB packé)          (NumPy Zero-Copy)

Pourquoi les environnements DOS surpassent les moteurs 3d pour l’apprentissage de l’IA

Les laboratoires de recherche engloutissent des budgets colossaux en instances cloud pour faire tourner des simulations modernes. Une unique instance propulsée par l’Unreal Engine monopolise fréquemment un GPU Nvidia RTX 4090 ou A100 complet pour générer à peine quelques centaines d’images par seconde. Play-dos redistribue totalement l’allocation des ressources de calcul.

Caractéristique / Métrique Moteurs 3D récents (Unreal / Unity) RL Arcade standard (Atari 2600 via ALE) Environnement virtualisé Play-dos
RAM par instance 4 Go – 16 Go ~15 Mo 8 Mo – 32 Mo
Dépendance GPU Obligatoire (Pipeline de rendu 3D) Nulle (CPU natif) Nulle (Émulation CPU pure)
Débit d’exécution 100 – 600 FPS par GPU 3 000 – 6 000 FPS par cœur 10 000 – 25 000 FPS par cœur
Complexité de la tâche Forte charge visuelle, logique basique Rendu minimal, logique réactive simple Rendu sobre, profondeur tactique/stratégique extrême
Inspection de l’état APIs de réflexion lourdes, télémétrie dense Triviale (128 octets de RAM) Directe (Mémoire plate de 640 Ko à 32 Mo)
Workers parallèles (Nœud 64 cœurs) 2 à 4 workers (saturation VRAM) 64+ workers 64 à 128 workers simultanés

Déterminisme, empreinte mémoire et rendement calculatoire

Les systèmes d’exploitation actuels et les moteurs de jeu complexes reposent lourdement sur des calculs physiques multithreads, des chargements asynchrones de ressources et des opérations en virgule flottante non déterministes. Ces mécanismes introduisent des dérives d’une session d’entraînement à l’autre, compliquant le débogage et déstabilisant la convergence des politiques d’apprentissage.

À l’inverse, l’environnement DOS s’exécute en monothread au sein d’un espace d’adressage réel. Chaque instruction est exécutée selon une séquence d’horloge stricte. Dans Play-dos :

  • La génération de nombres pseudo-aléatoires s’appuie sur des générateurs congruentiels linéaires simples, indexés sur le compteur de ticks DOS (comme l’adresse 0x0040:0x006C).
  • L’état d’exécution complet — englobant l’intégralité de l’espace mémoire MS-DOS, les pilotes chargés et le tas du jeu — dépasse rarement 16 Mo.
  • La sérialisation d’état est instantanée : générer un point de contrôle complet (checkpoint) se résume à un simple memcpy de la mémoire vive virtuelle allouée, sans nécessiter la sérialisation d’arborescences d’objets complexes requise par les moteurs récents.

Granularité de l’espace d’états versus complexité perceptive

Si les jeux Atari 2600 (popularisés par l’Arcade Learning Environment) offrent une exécution légère, leur complexité décisionnelle demeure limitée. Des titres comme Pong, Breakout ou Space Invaders évaluent des réflexes immédiats sur des horizons de récompense courts, mais se révèlent inadaptés pour tester le raisonnement séquentiel à long terme.

La logithèque DOS des années 1990 constitue un modèle d’équilibre pour la conception de systèmes complexes :

  • Machines à états interconnectées : Des jeux tels que Civilization, SimCity 2000, Master of Orion et X-COM: UFO Defense intègrent des moteurs mathématiques sophistiqués régissant l’économie, la planification spatiale, les arbres de technologies et le positionnement tactique.
  • Complexité perceptive équilibrée : La résolution d’affichage (320 × 200 ou 640 × 480) élimine le bruit perceptif propre aux moteurs modernes (reflets avec ray tracing, anticrénelage géométrique). Les réseaux de neurones à convolution (CNN) et les transformeurs visuels (ViT) se focalisent ainsi directement sur les éléments de gameplay signifiants sans épuiser leurs paramètres sur des artéfacts cosmétiques.

Implémentation technique : concevoir un environnement RL sur Play-DOS

Pour bâtir un pipeline d’apprentissage par renforcement performant, le noyau C++ de Play-dos est encapsulé dans une interface Python conforme aux spécifications de l’API Gymnasium de la Farama Foundation.

Flux de travail Gymnasium Step
                                 |
                     [agent.step(action_vector)]
                                 |
                                 v
        [Conversion action_vector vers Scancodes DOS via IPC]
                                 |
                                 v
         [Exécution de N cycles CPU dans le noyau Play-dos]
                                 |
                                 v
             v                                       v
   [Lecture Framebuffer 0xA0000]          [Lecture Offsets cibles RAM]
             v                                       v
  [Assemblage observation RGB]            [Calcul récompense & indicateur fin]
                                 |
                                 v
                   Retour: (obs, reward, terminated, info)

Détournement des interruptions 0x10 et 0x16 : automatisation des entrées et capture de trames

Au cœur de la boucle de virtualisation de Play-dos, les pointeurs de registres internes du DOS sont interceptés à chaque pas de simulation. Lorsqu’un agent appelle step(action) :

  1. L’environnement décode l’entier d’action en un événement matériel émulé (par exemple, les scancodes Set 1 du clavier : 0x1E pour ‘A’, 0x11 pour ‘W’, 0x39 pour Espace).
  2. Le scancode est écrit sur le port 0x60 du contrôleur clavier, et un signal IRQ 1 est envoyé au CPU virtuel.
  3. Le CPU virtuel exécute un volume défini d’instructions (l’équivalent d’une trame, généralement de l’ordre de 70,000 à 100,000 cycles).
  4. Les routines d’inspection mémoire extraient les indicateurs cibles (points de vie du joueur, munitions, score ou réserves de matières premières) directement depuis des adresses RAM fixes, identifiées au préalable par rétro-ingénierie binaire.

Liaisons de l’API Python et wrappers Gymnasium

Le code suivant présente un wrapper complet intégrant le runtime de virtualisation Play-dos dans un environnement Gymnasium standard.

    """
    Interface Gymnasium pour le runtime de virtualisation Play-dos.
    Expose la mémoire vidéo VGA Mode 13h et injecte des scancodes via IPC POSIX.
    """
    metadata = {"render_modes": ["rgb_array"], "render_fps": 35}
        super().__init__()
        # Mode VGA 13h : 320×200 indexé 8 bits converti en RGB 24 bits
        self.observation_space = spaces.Box(
            low=0, high=255, shape=(200, 320, 3), dtype=np.uint8
        )
        # Espace d'actions clavier discrètes (Neutre, Haut, Bas, Gauche, Droite, Action 1, Action 2)
        self.action_space = spaces.Discrete(7)
        self.action_map = {
            0: 0x00,  # Aucun appui
            1: 0x48,  # Flèche Haut
            2: 0x50,  # Flèche Bas
            3: 0x4B,  # Flèche Gauche
            4: 0x4D,  # Flèche Droite
            5: 0x39,  # Espace (Tir/Action)
            6: 0x1D   # Ctrl Gauche
        }
        # Liaison avec le segment de mémoire partagée exposé par le cœur C++
        self.ipc_handle = ipc_handle
        self.shm_fd = os.open(f"/dev/shm/{ipc_handle}_frame", os.O_RDWR)
        self.shm_frame = mmap.mmap(self.shm_fd, 200 * 320 * 3, mmap.MAP_SHARED, mmap.PROT_READ)
        self.ctrl_fd = os.open(f"/dev/shm/{ipc_handle}_ctrl", os.O_RDWR)
        self.shm_ctrl = mmap.mmap(self.ctrl_fd, 64, mmap.MAP_SHARED, mmap.PROT_WRITE)
        # 1. Encodage et injection du scancode dans le segment de contrôle
        scancode = self.action_map.get(action, 0x00)
        self.shm_ctrl.seek(0)
        self.shm_ctrl.write(struct.pack("=II", scancode, 1)) # Code, Flag d'activation
        # 2. Attente de la consommation des cycles par Play-dos
        while True:
            self.shm_ctrl.seek(4)
            if struct.unpack("=I", self.shm_ctrl.read(4))[0] == 0:
                break
return observation, reward, terminated, truncated, info
        super().reset(seed=seed)
        # Signal envoyé à l'hyperviseur pour restaurer l'état mémoire initial
        self.shm_ctrl.seek(8)
        self.shm_ctrl.write(struct.pack("=I", 1)) # Commande de réinitialisation
        while True:
            self.shm_ctrl.seek(8)
            if struct.unpack("=I", self.shm_ctrl.read(4))[0] == 0:
                break
        self.previous_score = 0
        self.shm_frame.seek(0)
        obs = np.frombuffer(self.shm_frame.read(200 * 320 * 3), dtype=np.uint8).reshape((200, 320, 3))
        return obs, {}
        self.shm_frame.close()
        self.shm_ctrl.close()
        self.shm_ram.close()
        os.close(self.shm_fd)
        os.close(self.ctrl_fd)
        os.close(self.ram_fd)

Modèles vision-langage et planification autonome Dans Play-dos

L’émergence de modèles multimodaux tels que GPT-4o, Claude 3.5 Sonnet ou de modèles open-weights comme Qwen2-VL ouvre la voie à de nouveaux protocoles d’évaluation pour agents autonomes via Play-dos. Alors que les algorithmes de renforcement classiques nécessitent des millions d’itérations pour assimiler les règles de base, les modèles vision-langage (VLM) sont capables d’interpréter un écran de jeu dès la première seconde grâce à leurs représentations visuelles pré-entraînées.

Boucle Perception-Action pour Agent Multimodal
                                  |
              [Extraction brute du Framebuffer (320×200)]
                                  |
                                  v
              [Mise à l'échelle & Rehaussement de contraste]
                                  |
                                  v
Moteur d'inférence multimodal
(Prompt Engineering & Token Parsing)
                                  |
                     [Plan d'action JSON structuré]
                                  |
                                  v
              [Traducteur d'actions & Macros temporelles]
                                  |
                                  v
                [Injection matérielle Play-dos (INT 16h)]

Ancrage visuel et guidage tactique par invites

Dans les titres de stratégie classiques tels que Warcraft II: Tides of Darkness ou SimCity 2000, la densité informationnelle de l’interface est particulièrement forte :

  • Les bandeaux d’état indiquent les données chiffrées : or, bois, pétrole, taux d’imposition et niveau du réseau électrique.
  • La zone centrale affiche des structures isométriques, le relief du terrain et le déplacement des unités.
  • La minicarte fournit le contexte spatial à l’échelle macroscopique.

Pour intégrer efficacement un VLM au sein de Play-dos :

  1. Mise à l’échelle de l’image : Les modèles de vision actuels sont calibrés pour de hautes résolutions. Les trames natives (320 × 200) sont agrandies en 1280 × 800 par interpolation au plus proche voisin, préservant la netteté des pixels sans introduire de flou de lissage.
  2. Extraction textuelle via le System Prompt : L’agent reçoit pour consigne de lire et de transcrire les données textuelles de l’interface avant de sélectionner une action.
  3. Format de sortie JSON contraint : Les réponses sont générées sous forme de commandes structurées, évitant les formats libres pour éliminer tout risque d’erreur d’analyse syntaxique.
{
  "observed_state": {
    "cash_reserves": 4520,
    "rci_demand": {"residential": "high", "commercial": "moderate", "industrial": "low"},
    "power_grid_alert": true
  },
  "tactical_deduction": "Les zones résidentielles sont privées d'électricité. Raccordement requis depuis la centrale à charbon vers le nouveau secteur nord.",
  "action_sequence": [
    {"command": "KEY_PRESS", "key": "P", "duration_ms": 100},
    {"command": "MOUSE_MOVE", "x": 128, "y": 84},
    {"command": "MOUSE_CLICK", "button": "LEFT"},
    {"command": "MOUSE_DRAG", "x_end": 145, "y_end": 84}
  ]
}

Grâce à cette infrastructure, Play-dos devient une plateforme de référence pour évaluer la planification autonome à long terme, la résilience aux erreurs et le raisonnement spatial sur plusieurs centaines de cycles de jeu simulés.

Évaluation comparative de Play-DOS sur les architectures logicielles des années 90

Le catalogue applicatif de MS-DOS regroupe des paradigmes de développement variés, chacun soumettant les modèles d’intelligence artificielle à des contraintes spécifiques.

Typologie des environnements DOS
Moteurs 2.5D en vue subjective      Moteurs isométriques de gestion
(DOOM / Wolfenstein 3D)              (SimCity 2000 / X-COM)
- Navigation continue  |  - Micro/macro-économie
- Réaction temps réel  |  - Espaces d'action XXL
- Observabilité partiel  |  - Pathfinding sur graphe

Navigation spatiale à la première personne : DOOM et wolfenstein 3d

Avant l’avènement des accélérateurs graphiques dédiés, id Software exploitait des arbres de partitionnement spatial binaire (BSP) pour assurer le rendu d’environnements pseudo-3D par le processeur. Exécuter DOOM dans Play-dos offre un environnement idéal pour étudier :

  • L’odométrie visuelle et l’évaluation de profondeur : L’agent doit déduire les distances et la géométrie des pièces uniquement à partir de projections 2.5D.
  • L’observabilité partielle : Les ennemis et les bonus dissimulés hors du champ de vision requièrent la construction d’une mémoire spatiale interne.
  • L’exploration à haute vitesse : Play-dos levant la limite native du moteur (35 FPS pour DOOM), les algorithmes de type PPO (Proximal Policy Optimization) peuvent ingérer des millions de pas d’expérience en quelques minutes.

Systèmes complexes et allocation de ressources : SimCity 2000 et civilization

Les jeux de stratégie au tour par tour et de gestion temps réel délaissent les réflexes purs au profit d’une logique d’optimisation systémique :

  • SimCity 2000 : Le système articule de multiples variables interdépendantes : réseaux d’aqueducs sous-terrains, distribution électrique, fiscalité sectorielle, infrastructures de transport et équilibre de zonage. Une approche visuelle purement réactive conduit à l’échec ; la survie de la ville impose une planification à moyen et long terme.
  • Civilization : Ce cadre confronte l’agent à des arbres de décision s’étendant sur plusieurs centaines de tours. L’espace d’états englobe avancées technologiques, accords diplomatiques, manœuvres tactiques et gestion démographique, constituant un terrain d’essai idéal pour les architectures de raisonnement logique.

Contraintes d’ingénierie : sérialisation d’état et persistance mémoire

L’entraînement de réseaux neuronaux profonds sur des applications historiques pose des problèmes de virtualisation spécifiques qui doivent être traités au niveau le plus bas du système.

Volatilité du tas et mode protégé DPMI

Les premiers jeux DOS en mode réel fonctionnaient strictement dans la limite des 640 Ko de mémoire conventionnelle. En revanche, les titres parus à partir du milieu des années 90 exploitent des extensions DPMI (DOS Protected Mode Interface, telles que DOS/4GW) pour adresser la mémoire linéaire 32 bits et allouer 32 Mo, voire 64 Mo de mémoire étendue (XMS).

   Mémoire en Mode Réel            Mode Protégé (Extenseur DOS/4GW)
 [0x00000000 – 0x000FFFFF]           [0x00100000 – 0x03FFFFFF]
Vecteurs d'interruption  |  Tas dynamique du jeu
Zone de données BIOS  |  Tampons son et sprites
RAM conventionnelle 640K  |  Géométrie et caches
VRAM VGA (A0000h)  |  Exécution en High Memory

Lors de l’implémentation de sauvegardes d’états (checkpoints) sur des exécutables sous DPMI :

  • L’émulateur ne peut pas se contenter de copier la mémoire de base ; il doit figer la table globale des descripteurs (GDT), la table locale (LDT) ainsi que l’ensemble des segments de mémoire haute.
  • Toute omission dans la sérialisation de l’état du mode protégé génère des erreurs de pagination irrécupérables (les classiques erreurs General Protection Fault ou interruptions 0Dh) dès la reprise de l’exécution.
  • Play-dos maintient un miroir complet de l’ensemble des registres 32 bits étendus (EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP, CR0, CR3), assurant une restauration déterministe du contexte au cycle d’horloge près.

Contournement des interruptions matérielles audio

De nombreux exécutables DOS entrent dans des boucles d’attente infinies lorsque les liaisons avec les cartes son Sound Blaster ou Gravis UltraSound ne renvoient pas les accusés de réception attendus. Le cas classique réside dans l’attente active d’une réponse du DSP (Digital Signal Processor) de la Sound Blaster :

; Boucle classique d'attente Sound Blaster sous DOS
check_dsp:
    mov dx, 0x22C        ; Port d'état du tampon de lecture DSP
    in  al, dx
    test al, 0x80        ; Vérification du bit 7 (donnée disponible)
    jz  check_dsp        ; Boucle bloquante si le matériel est absent
    mov dx, 0x22A        ; Port de lecture des données DSP
    in  al, dx

Play-DOS élimine ces blocages CPU en interceptant directement les ports d’entrée/sortie (0x220–0x22F) et en répondant de façon synchrone par des états « prêt » simulés (dummy acknowledges), ce qui permet à la boucle principale de l’application de poursuivre son exécution sans latence et sans dépendre d’un matériel audio physique.

Pris ensemble, ces mécanismes — sérialisation exacte de l’état et contournements au niveau matériel comme l’émulation des IRQ audio — font de Play-DOS un bac à sable stable et reproductible, tel que l’exigent l’entraînement et l’évaluation d’agents d’apprentissage par renforcement et de modèles vision-langage sur les architectures de jeux des années 1990.

Dites-le. C’est fait.

Un projet autour de Play-DOS fait revivre les classiques des années 90 pour expérimenter avec l’IA moderne ? Dites à Nova ce qu’il vous faut, à la voix ou par écrit, 24 h/24. Elle en fait un brief clair et un prix en crédits, et notre équipe livre.

Composer mon packParler à Nova