Play-DOS : Le retrogaming des 90s au service de l'IA

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).

—

Architecture de Play-dos : Quand le mode réel 16 bits rencontre le Deep RL

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 times 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 times 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.

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 times 200$ ou $640 times 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.

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.

« `python
import gymnasium as gym
from gymnasium import spaces
import numpy as np
import mmap
import os
import struct

class PlayDosEnvironment(gym.Env):
« » »
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}

def __init__(self, ipc_handle: str, memory_map_file: str):
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)

def step(self, action: int):
# 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

def reset(self, seed=None, options=None):
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, {}

def close(self):
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.

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 times 200$) sont agrandies en $1280 times 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.

« `json
{
« 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.

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).

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 :

« `assembly
; 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

Prêt à propulser votre infrastructure digitale ?

Ne laissez pas les freins techniques ralentir votre croissance. Discutez de votre projet autour de Play-dos Revives 90s Gaming Gold for Modern Ai Experimentation directement avec nos experts seniors chez Low Cost Web Agency.

💬 Contactez-nous sur WhatsApp (Message uniquement : +919786495150)