MartyPC is an emulator of early IBM PCs and compatibles. It supports Windows, Linux and macOS.
User Guide
Click here to access the MartyPC User Guide
Downloading MartyPC
Builds are available through periodic releases. Newer, automatic builds are available via the Actions tab under the Artifacts for each workflow run. (You will need to be logged in to GitHub to download Artifacts).
Building MartyPC
If you're not on Windows, or you want the latest bleeding-edge version, you'll need to build MartyPC from source.
- Last Released Version:
0.4.1
- Current Developement Version:
0.5.0
See the Building MartyPC guide on the MartyPC Wiki for build instructions.
Why another PC emulator?
MartyPC began as a hobby project to see if I could write an emulator from scratch while learning the Rust programming language. My original goals for MartyPC were modest, but it has reached a level of functionality that I could have never imagined.
MartyPC's intended niche in the emulation world is an aide for retro PC development. It is packed with debugging tools and logging facilities, with many more planned. It may not be as user-friendly to set up as other emulators, but if you are familiar with editing configuration files you shouldn't have any major problems. Programmers writing software for the Intel 8088 can see and measure the exact cycle-by-cycle execution of their code.
Accuracy
Development of MartyPC started in April 2022. I began work on making MartyPC's 8088 CPU emulation cycle-accurate in November 2022. To do so, I validated the operation of the CPU against a real 8088 CPU connected to an Arduino MEGA microcontroller. See my Arduino8088 project for more details. This allows an instruction to be simultaneously executed on the emulator and a real CPU and the execution results compared, cycle-by-cycle. More info on this process is described on my blog.
In June 2024 I updated the 8088 test suite once again to support exercising of the 8088's prefetch queue. Many more cycle inaccuracies were found and corrected. MartyPC passes the 8088 V2 Test Suite with 99.9997% cycle-accuracy.
Extensive hardware research has been performed to improve MartyPC's peripheral emulation as well, including investigating the 8253 timer chip with an Arduino, investigating DMA timings with an oscilloscope, and ultimately, building a bus sniffer using a logic analyzer.
In April 2023, MartyPC became accurate enough to run the infamous PC demo, 8088 MPH.
In May 2023, MartyPC became the first PC emulator capable of emulating every effect in the PC demo Area 5150. (See video here: https://www.youtube.com/watch?v=zADeLm9g0Zg)
Features
Currently, MartyPC can emulate the following systems:
- The IBM Model 5150 (PC)
- The IBM Model 5160 (XT)
- Generic Turbo XT
- The IBM PCjr
- The Tandy 1000
Device Support
MartyPC emulates the following devices:
CPUs:
- Intel 8088 - A cycle-accurate implementation of the Intel 8088 including the asynchronous BIU, processor instruction queue and prefetch logic. Tested for correctness and cycle-accuracy against hardware.
- NEC V20 - A preliminary implementation of the NEC V20 CPU. Cycle-based, but not fully cycle-accurate or as performant as the real thing, as timings have not been adjusted from the 8088 that was used as a base. All native-mode V20 instructions are implemented and tested for correctness against hardware.
System Hardware:
- 8255 PPI - Low-level keyboard emulation is supported via the PPI and keyboard shift register. Supports the 'turbo bit' found in TurboXT clones.
- 8259 PIC - Mostly complete, but still missing advanced features such as priority rotation and nested modes.
- 8253 PIT - Highly accurate, supporting PCM audio.
- 8237 DMAC - Mostly implemented, but DMA transfers are currently "faked". DRAM refresh DMA is simulated using a scheduling system.
- 8250 UART - Supports serial passthrough or mouse emulation.
- Game Port - Supports two analog joysticks with two buttons each.
- Parallel Port - Enough of a basic parallel port is emulated to be detected, but is not really functional for any purpose yet.
Video Devices:
- CGA - A dynamic, cycle-or-character clocked implementation of the IBM CGA including the Motorola MC6845 CRTC controller allows MartyPC to run demanding PC demos like 8088MPH and Area5150. MartyPC takes a unique approach to PC video card emulation by simulating the entire display field - including overscan. Composite output and monitor simulation is supported, via reenigne's excellent composite conversion code (also used by DOSBox and 86Box)
- TGA - A character-clocked implementation of the PCJr and Tandy Graphics Video Gate Array. Work in progress.
- MDA - A character-clocked implementation of the IBM MDA card built on the Motorola MC6845 CRTC controller.
- Hercules - The MDA device optionally supports emulation of the Hercules Graphics Adapter.
- EGA - A character-clocked implementation of the IBM EGA builds on the techniques used developing the CGA. It is structured to replicate the logical functions of each of the LSI chips on the original hardware. It supports redefinable fonts, vsync interrupts and per-scanline pel-panning for smooth scrolling.
- VGA - IBM VGA card emulation is in development, but graphics modes such as Mode 13h and Mode X are working.
Sound Devices:
- PC Speaker - Not really its own sound device, the PC speaker is driven by MartyPC's timer chip emulation. It can produce reasonable quality PWM audio in demos such as 8088MPH, Area5150, and Magic Mushroom.
- Adlib - The original Adlib Music Synthesizer is emulated, with OPL2 emulation provided by nuked-opl3, via my opl3-rs bidings. This is a bit CPU heavy, so you'll need a fast computer.
- SN76489 - The 3-voice sound chip found in the Tandy 10000 model line and the IBM PCjr is emulated - with a neat debug display that provides UV meters and oscilloscope views of each channel.
- Disney Sound Source - The Disney Sound Source was an inexpensive parallel DAC with a 16-sample FIFO and volume knob. Not a lot of games support it, but it works well in the few titles that do.
Storage Devices:
- µPD765 FDC - Currently robust enough to support both DOS and Minix operating systems. MartyPC uses my disk image library, fluxfox, which allows it to support a wide variety of PC disk image formats. MartyPC's FDC emulation is still not as accurate as I'd like it to be, but it can support a number of copy-protected titles, given a disk image of the appropriate format.
- IBM/Xebec 20MB HDC - Emulated with basic VHD support. MartyPC currently supports a single disk geometry of 20MB when using this controller.
- XT-IDE - Emulation of the XT-IDE Rev 2 board allows MartyPC to support a wide range of hard disk formats. This emulation is still in early stages, and may be a bit rough around the edges. Not all ATA commands are implemented.
- jr-IDE - Emulation of the jr-IDE provides the IBM PCjr machine with IDE hard disk support and 736K of memory backfill. Other features such as the RTC and flash are not yet implemented.
- PCjr Cartridges - PCjr cartridge ROMs are supported, in JrRipCart (.JRC) format
Memory Expansion Devices:
- LoTech 2MB EMS Card - 2MB of EMS memory is made available via the LoTech EMS board.
- Generic Memory Expansion Cards - Memory expansion cards can be defined for either the ISA bus or PCjr SideCar expansion slot.
Input Devices:
- Keyboard Support - IBM Model F, Tandy 1000, and PCjr keyboards are emulated.
- Serial Mouse - A standard Microsoft serial mouse can be connected to the COM port of your choice.
- Joystick - Game port joysticks are emulated via configurable keyboard controls.
- Light Pen - A light pen is emulated for the CGA card and the PCjr.
Dual-Head Support
MartyPC supports dual-video card and multi-monitor configurations, so you can run a secondary monitor powered by an MDA or Hercules adapter - even in the same window. Each display viewport can receive independent shader configurations.
Configuration Support
MartyPC supports custom machine configurations via base machine configuration profiles plus optional extensions called 'overlays', analagous to installing extension cards or other upgrades.
Debugging Support
MartyPC has an extensive debugging GUI with several useful displays including instruction disassembly, CPU state, memory viewer, and various peripheral states. Code and memory breakpoints are supported. MartyPC also supports instruction and cycle-based logging.
Shader support
A basic, configurable CRT shader is included with more to come (LibraShader support is planned)
Screenshots
For more, check out the Screenshot Gallery section of the Wiki!
Special Thanks
I have a long list of people to thank (See the About box!), but I would especially like to mention the contributions made by reenigne. Without his work reverse-engineering the 8088 microcode, this emulator would never have been possible. I would also like to thank Ken Shirriff and his excellent blog, covering much of the silicon logic of the 8086 (and 8088 by extension).
Thanks to Jetbrains for providing MartyPC with licenses for Jetbrains products.
Instagram Engineering
Shopify Engineering
