Play-dos Revives 90s Gaming Gold for Modern Ai Experimentation

The evaluation of general artificial intelligence and autonomous reinforcement learning agents faces a compute bottleneck. Modern synthetic benchmarks—built on engines such as Unreal Engine 5, Unity, or high-fidelity robotics simulators—demand massive GPU allocations simply to render visual geometry and compute Newtonian physics. While photorealism is mandatory for field robotics, it introduces unneeded overhead when training agents on core cognitive capabilities: spatial navigation, long-horizon resource management, tactical coordination, and abstract deduction.

Enter Play-dos, an open virtualization framework engineered to repurpose 1990s MS-DOS software into high-throughput, deterministic sandboxes for machine learning research. By transforming x86 real-mode and 32-bit protected-mode applications into headless, vectorized execution pipelines, Play-dos strips away the visual bloat of contemporary gaming environments. In their place, it exposes pure, raw game logic, direct memory states, and low-latency framebuffers to contemporary reinforcement learning (RL) algorithms and Vision-Language Models (VLMs).

“`
+——————————————————————-+

+———————————+———————————+
| Zero-Copy IPC / POSIX Shared Mem
+———————————v———————————+

+———————————+———————————+
| Register & Video Memory Hook
+———————————v———————————+

+——————————————————————-+
“`

—

The Architecture of Play-dos: 16-Bit Real Mode Meets Deep Reinforcement Learning

Modern operating systems discard legacy x86 interrupt architectures and segmented memory models. Play-dos resurrects them within an instrumented, isolated hypervisor layer derived from modular DOS emulation, stripped of audio mixing, real-time audio sync, and display hardware handshakes.

Headless Emulation and the Virtualization Layer

At its foundation, Play-dos runs as a standalone C++ daemon that interfaces directly with host memory via POSIX shared memory primitives (`shm_open`, `mmap`). Unlike consumer DOS emulators built for audio-visual fidelity on desktop monitors, Play-dos runs entirely headless. The execution loop removes dynamic cycle throttles that historically synchronized games to 4.77 MHz, 33 MHz, or 66 MHz clock speeds.

Freed from host-display vertical refresh locks (60 Hz VSync) and audio DAC interrupts, the emulation engine ticks forward at pure CPU compute speed. A standard AMD EPYC or Intel Xeon core can execute thousands of virtual DOS CPU cycles per millisecond, allowing game instances to run at speeds exceeding 15,000 frames per second (FPS).

Framebuffer Extraction and Direct Memory Injection

Play-dos hooks directly into the virtualized VGA/EGA memory map. For standard VGA Mode 13h—the graphical standard for 1990s titles—the physical display buffer resides at linear address `0x000A0000`.

Rather than passing this buffer through an OpenGL or Vulkan compositing pipeline to generate host windows, Play-dos intercepts the $320 times 200$ byte matrix. Each byte maps to a dynamic 8-bit palette indexed across RGB color registers. The framework executes three primary steps:

1. Palette Dereferencing: Converts the $320 times 200$ 8-bit index array into an interleaved `uint8` array of shape `(200, 320, 3)` using SIMD vector instructions.
2. Zero-Copy IPC Transfer: Places the raw tensor into a circular shared-memory ring buffer accessible by external Python processes.
3. Interrupt Emulation: Bypasses the vertical blank interrupt (INT 0x0A / IRQ 2), allowing game rendering loops to commit screen updates instantly without blocking CPU instructions.

Simultaneously, agent inputs bypass physical OS event queues. Play-dos captures keystrokes and mouse movements by directly writing scancodes to the circular keyboard buffer in the BIOS Data Area (BDA) at `0x0040:0x001E` through `0x0040:0x003D`, or by firing software interrupt `INT 0x16` directly inside the virtual CPU core.

“`
+————————————————————————-+

+————————————————————————-+
“`

—

Why 1990s DOS Environments Outperform Modern 3D Engines for AI Training

Machine learning laboratories spend hundreds of thousands of dollars on cloud computing instances to run modern simulation environments. A single instance of an Unreal Engine environment often demands an entire dedicated Nvidia RTX 4090 or A100 to yield a few hundred frames per second. Play-dos fundamentally alters the compute profile of reinforcement learning.

Determinism, Memory Footprint, and Compute Efficiency

Modern operating systems and complex game engines rely heavily on multi-threaded physics calculations, asynchronous asset loading, and non-deterministic floating-point math. These processes introduce subtle variations across training runs, which complicates debugging and destabilizes reinforcement learning policies.

DOS operates as a single-threaded, real-address environment. Every instruction executes in an explicit sequence of cycles. In Play-dos:
* Random number generation within games relies on simple linear congruential generators driven by deterministic tick counts (such as the DOS timer tick at memory location `0x0040:0x006C`).
* The complete runtime state of an environment—including the entire memory footprint of MS-DOS, loaded drivers, and game heap—rarely exceeds 16 MB.
* State serialization is fast: creating a snapshot (`checkpoint`) requires a simple `memcpy` of the allocated virtual RAM, rather than the deep object serialization required by modern game engines.

State Space Granularity vs. Perceptual Complexity

Atari 2600 games (popularized by the Arcade Learning Environment) provide low-overhead execution, but their tactical depth is limited. Titles like *Pong*, *Breakout*, or *Space Invaders* test immediate reflexes and short reward horizons, but they fall short for evaluating multi-step reasoning.

DOS software from the 1990s represents a high point for algorithmic, systems-driven game design:
* Complex State Machines: Titles like *Civilization*, *SimCity 2000*, *Master of Orion*, and *X-COM: UFO Defense* feature complex mathematical engines covering economic management, spatial routing, technology trees, and tactical positioning.
* Balanced Perceptual Complexity: The visual input ($320 times 200$ or $640 times 480$) avoids the perceptual noise of modern ray-traced reflections and geometric anti-aliasing. This allows convolutional networks (CNNs) and visual transformers (ViTs) to process key gameplay details without wasting capacity on visual artifacts.

—

Technical Implementation: Building an RL Environment Around Play-dos

To construct a performant reinforcement learning pipeline, engineers wrap the Play-dos C++ core inside a Python interface compliant with the Farama Foundation Gymnasium API.

“`
+—————————————————-+

+—————————————————-+
|
[agent.step(action_vector)]
|
v
[Translate action_vector to DOS Scancodes via IPC]
|
v
[Execute N CPU Cycles in Play-dos Core Engine]
|
v
+——————-+——————-+

v v
[Read Framebuffer 0xA0000] [Read RAM Target Offsets]

v v
[Assemble RGB Observation] [Compute Reward & Done Flag]

+——————-+——————-+
|
v
Return: (obs, reward, terminated, info)
“`

Hooking Interrupt 0x10 and 0x16: Automating Inputs and Frame Captures

The core of the Play-dos virtualization loop overrides internal DOS register pointers during step executions. When an agent calls `step(action)`:

1. The environment decodes the action integer into an emulated hardware event (e.g., standard Set 1 keyboard scancodes: `0x1E` for ‘A’, `0x11` for ‘W’, `0x39` for Space).
2. The scancode is written to the keyboard controller port `0x60`, and an IRQ 1 line assert signals the emulated CPU.
3. The virtual CPU runs for a fixed budget of cycles (equivalent to one frame, typically $sim 70,000$ to $100,000$ cycles).
4. Memory inspection routines read the target metrics (e.g., player health, ammunition, score, or resource stock) directly from fixed RAM addresses identified via static binary analysis.

Python API Bindings and Gymnasium Wrappers

Below is a complete, deployable wrapper illustrating the integration of Play-dos with a standardized Gymnasium environment.

“`python
“””
Gymnasium interface for the Play-dos virtualization runtime.
Exposes VGA Mode 13h video memory and injects scancodes via POSIX IPC.
“””
metadata = {“render_modes”: [“rgb_array”], “render_fps”: 35}

super().__init__()

# VGA Mode 13h: 320×200 8-bit indexed converted to 24-bit RGB
self.observation_space = spaces.Box(
low=0, high=255, shape=(200, 320, 3), dtype=np.uint8
)

# Discrete keyboard action set (Idle, Up, Down, Left, Right, Action 1, Action 2)
self.action_space = spaces.Discrete(7)
self.action_map = {
0: 0x00, # No-op
1: 0x48, # Arrow Up
2: 0x50, # Arrow Down
3: 0x4B, # Arrow Left
4: 0x4D, # Arrow Right
5: 0x39, # Space (Fire/Interact)
6: 0x1D # Left Ctrl
}

# Link to shared memory segment exposed by the Play-dos C++ core
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. Translate and write input scancode to control shared memory
scancode = self.action_map.get(action, 0x00)
self.shm_ctrl.seek(0)
self.shm_ctrl.write(struct.pack(“=II”, scancode, 1)) # Code, Strobe flag

# 2. Block until Play-dos processes cycles and resets strobe flag
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 hypervisor to restore base memory snapshot
self.shm_ctrl.seek(8)
self.shm_ctrl.write(struct.pack(“=I”, 1)) # Trigger reset command

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)
“`

—

Vision-Language Models and Autonomous Planning in Play-dos

The emergence of multimodal models—such as GPT-4o, Claude 3.5 Sonnet, and open-weights models like Qwen2-VL—presents an opportunity to test autonomous agents using Play-dos. While reinforcement learning models rely on millions of trials to learn basic behaviors, Vision-Language Models (VLMs) can evaluate game screens directly using pre-trained visual common sense.

“`
+——————————————————————-+

+——————————————————————-+
|
[Raw Framebuffer Extraction (320×200)]
|
v
[Resolution Upscale & High-Contrast Overlay]
|
v
+———————————————+

+———————————————+
|
[Structured JSON Action Plan]
|
v
[Action Translator & Timed Scancode Macro]
|
v
[Play-dos Hardware Injection (INT 16h)]
“`

Visual Grounding and Tactical Prompting

In classic strategy games such as *Warcraft II: Tides of Darkness* or *SimCity 2000*, the game state is dense with data:
* Status panels show numerical balances for gold, lumber, oil, tax rates, and power levels.
* The main game view contains isometric buildings, geographic obstacles, and dynamic sprite movements.
* Minimap components establish broader spatial context.

To deploy a VLM successfully inside Play-dos:
1. Frame Upscaling: Modern vision models are optimized for high-resolution images. Input frames ($320 times 200$) are upscaled using nearest-neighbor interpolation to $1280 times 800$, preserving pixel crispness while avoiding blurry interpolation artifacts.
2. Text Parsing via System Prompts: Agents are instructed to parse game text overlays before determining actions.
3. Structured JSON Output: Models return actions as structured commands, avoiding freeform text and eliminating unpredictable parser failures.

“`json
{
“observed_state”: {
“cash_reserves”: 4520,
“rci_demand”: {“residential”: “high”, “commercial”: “moderate”, “industrial”: “low”},
“power_grid_alert”: true
},
“tactical_deduction”: “Residential zones are power-starved. Need to route power lines from the primary coal plant to the newly zoned northern sector.”,
“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}
]
}
“`

Through this setup, Play-dos serves as a rigorous testing suite for evaluating long-term autonomous planning, error handling, and spatial deduction over hundreds of simulated game days.

—

Benchmarking Play-dos Across Iconic 1990s Game Architectures

The MS-DOS gaming catalog spans diverse computing paradigms, each challenging artificial intelligence frameworks in distinct ways.

“`
+———————————————————————+

+———————————————————————+

+———————————————————————+
“`

First-Person Spatial Navigation: DOOM and Wolfenstein 3D

Before the advent of hardware-accelerated 3D graphics, id Software relied on Binary Space Partitioning (BSP) trees to render pseudo-3D environments in software. DOOM running inside Play-dos provides an optimal testbed for:
* Visual Odometry and Depth Perception: The agent must infer distance and depth directly from 2.5D projection frames.
* Partial Observability: Enemies and supplies outside the player’s immediate field of view demand internal spatial mapping.
* Fast Exploration: Because Play-dos bypasses engine framerate caps (such as DOOM’s native 35 FPS cap), training algorithms like Proximal Policy Optimization (PPO) can complete millions of steps within minutes.

Complex Systems and Resource Allocation: SimCity 2000 and Civilization

Turn-based and real-time management simulations shift the focus from quick reflexes to systemic planning:
* SimCity 2000: Exposes interconnected variables spanning subterranean water networks, electrical distribution, variable taxation rates, transit infrastructure, and zoning configurations. Agents that rely solely on reactive visual feedback struggle here; success demands long-term operational planning.
* Civilization: Challenges agents with turn horizons that extend across hundreds of turns. The state space encompasses technological progression, diplomatic exchanges, military deployment, and municipal development—offering an open testbed for strategic reasoning architectures.

—

Engineering Considerations: State Serialization and Non-Volatile Memory

Training deep neural networks on legacy applications introduces distinct virtualization challenges that must be addressed at the systems level.

Heap Volatility and DPMI Protected Mode

Earlier real-mode DOS games run entirely within the classic 640 KB memory limit. However, mid-to-late 1990s titles utilize DOS Protected Mode Interface (DPMI) extenders (e.g., DOS/4GW) to access 32-bit linear addresses and allocate up to 32 MB or 64 MB of extended memory (XMS).

“`
Real Mode Memory Protected Mode (DOS/4GW Extender)
[0x00000000 – 0x000FFFFF] [0x00100000 – 0x03FFFFFF]
+————————-+ +————————-+

+————————-+ +————————-+
“`

When building checkpoint systems for DPMI-extended software:
* Emulators cannot simply snapshot conventional base memory; they must capture the entire linear descriptor table (GDT/LDT) along with high memory segments.
* Failing to serialize the complete protected-mode runtime state will trigger page faults (such as classic `General Protection Fault` or `Interrupt 0Dh` errors) upon resuming execution.
* Play-dos maintains a shadow register state across all 32-bit extended registers (`EAX`, `EBX`, `ECX`, `EDX`, `ESI`, `EDI`, `ESP`, `EBP`, `CR0`, `CR3`), guaranteeing deterministic state restoration down to the individual clock cycle.

Audio IRQ Emulation Bypass

Many legacy game executables block execution loops indefinitely if their Sound Blaster or Gravis UltraSound hardware handshakes fail to return valid status updates. A common issue is checking for an interrupt return signal from the Sound Blaster DSP (Digital Signal Processor):

“`assembly
; Typical DOS Sound Blaster Acknowledgment Loop
check_dsp:
mov dx, 0x22C ; DSP Read Buffer Status Port
in al, dx
test al, 0x80 ; Test bit 7 (data available)
jz check_dsp ; Spinlock if audio hardware is absent
mov dx, 0x22A ; DSP Read Data Port
in al, dx
“`

Play-dos prevents these CPU lockups by