Stars!VM embeds 80286 emulator and Win16 bridge to run 1995 game on modern Windows

The core technical challenge addressed is the inability of modern x64 Windows to execute 16-bit applications natively. Stars!VM solves this by embedding a custom 80286 emulator and a Win16-to-Win32 bridge within a standard 32-bit executable. This architecture allows the game to run as a native Win32 process, avoiding the overhead and compatibility issues associated with traditional emulation layers like DOSBox or Wine. The result is a single executable that behaves like a modern port, complete with a file chooser and 4k scaling, while internally managing the 16-bit guest environment.

Validation of the emulator is handled through a differential fuzzer that generates random 16-bit instructions, emulates them, and compares the results against the host's JIT execution. This method ensures the accuracy of the emulation without requiring a full reference implementation. The emulator relies on the host's x87 hardware for floating-point operations, which simplifies the implementation and ensures precision. This direct hardware dependency means the emulator requires x86 or x86-64 architecture and does not implement x87 in software.

Performance optimization focused on the game's turn generation bottleneck, which was identified through instruction tracing. The developer used an AI model to reverse-engineer hot routines, such as the game's PRNG, and rewrote them in C. These optimized routines were mapped into the instruction decoder as new 80286 instructions, allowing the emulator to patch them at load time. This technique achieved a nearly 2x speedup by exploiting local conditions of the specific program, effectively gaining JIT performance without the complexity of a full JIT compiler.

The Win16-to-Win32 bridge handles the translation of 16-bit handles to pointer-sized host handles and marshals data between different struct layouts. It also services DOS interrupts and copies data in and out of guest memory. A notable feature is the integration of the Model Context Protocol, which allows AI agents to monitor and manipulate the game's UI and memory. This enables external agents to drive the game by injecting synthetic events, a capability demonstrated by an AI model playing a complete game with minimal human assistance.

The project also addresses I/O inefficiencies by buffering the game's small read and write calls, which previously consumed a significant portion of turn generation time. Additionally, the emulator natively implements the interfaces of Microsoft's WaveMix.dll for sound effects, eliminating the need for the original DLL. These optimizations, combined with the embedded game assets, create a self-contained solution that is ready to play out-of-the-box. The approach highlights how specific knowledge of a legacy application can be leveraged to create a more efficient and maintainable emulation environment.