Retro PC emulation has quietly become one of the busiest corners of the emulation scene in 2026. While headlines chase Nintendo’s latest DMCA sweep against Switch emulator forks, a smaller but fiercely technical community keeps building tools to resurrect MS-DOS games, Windows 95/98 desktops, and even individual IBM PC/XT motherboards from the early 1980s. Three projects sit at the center of that work: 86Box, PCem, and the newer Rust-built MartyPC. Each takes a different bet on what “accurate” retro computing should mean, and each has a very different GitHub footprint to show for it. As of this week, 86Box carries 4,842 GitHub stars, PCem sits at 1,936, and MartyPC has climbed to 938 despite being the youngest of the three. This comparison breaks down the specs, the benchmarks, the pricing and licensing fine print, and the real use cases where each tool actually wins.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Why Retro PC Emulation Is Having a Moment in 2026
Console emulation gets most of the attention because Nintendo keeps suing people over it, but PC hardware emulation has grown for quieter reasons. DOSBox and its forks (DOSBox-X and DOSBox Staging) solved software-level DOS compatibility years ago, letting most classic DOS games run on modern machines with minimal fuss. What DOSBox does not do well is reproduce the actual hardware: the specific BIOS quirks of a Compaq Deskpro, the timing behavior of a Cyrix 6×86 chip, or the exact way a Sound Blaster 16 handled DMA transfers on a period motherboard. That gap is what 86Box, PCem, and MartyPC exist to close.
Demand comes from three overlapping groups: gamers chasing bit-perfect Windows 98 nostalgia runs, software preservationists trying to keep abandonware and shareware runnable on hardware nobody owns anymore, and developers testing legacy tooling against period-accurate BIOS and chipset behavior. All three groups search for the same starting question, “86box vs pcem,” before landing on whichever tool matches their patience for configuration. Search interest in 86Box alone runs at roughly 2,400 monthly searches in the US, a sign this is no longer a niche forum topic. Readers who just want a quick 86Box installation walkthrough rather than a full comparison can jump straight to a dedicated setup guide.
The three tools compared here sit at a different layer of the emulation stack than the console-focused projects that usually dominate this site’s coverage. Where a Switch or PS3 emulator has to reverse-engineer a single, fixed piece of proprietary hardware, a PC hardware emulator has to model an entire ecosystem of competing chipsets, BIOS vendors, and expansion cards that all had to interoperate through open standards. That is a fundamentally harder and more open-ended engineering problem, and it is part of why 86Box, PCem, and MartyPC each take such different approaches to solving it rather than converging on one dominant tool the way GBA emulation converged around mGBA.
How Each Project Started: A Brief History
Understanding why these three tools differ requires a bit of lineage. PCem is the elder of the group, built by Sarah Walker as one of the earliest widely used low-level x86 hardware emulators aimed specifically at gaming-era PC configurations rather than DOS compatibility alone. It built a loyal following through the 2010s among users who wanted period-accurate Voodoo graphics cards and Sound Blaster AWE32 setups without the shortcuts that software-level DOS emulators took.
86Box split off from that codebase in 2016 with a specific goal: broaden the machine catalog while tightening timing accuracy on the earliest 8088 and 8086 systems, an era PCem’s original scope treated as a lower priority than its 486 and Pentium-class machine list. Over roughly a decade, that decision compounded. 86Box’s contributor base grew, its machine list expanded well past PCem’s, and its release cadence became far more consistent, culminating in the steady string of point releases that brought it to version 6.0 in May 2026.
MartyPC arrived far more recently and for a narrower reason. Developer David Balsom wanted to run 8088 MPH, a demoscene production famous for exploiting extremely precise 8088 CPU and CGA video timing that most emulators of the era could not reproduce. At the time, as Balsom has explained, 86Box was the only emulator capable of running it correctly. Rather than contribute directly to 86Box’s C codebase, Balsom built a new project from scratch in Rust, explicitly optimized around cycle-level timing accuracy for that narrow hardware target rather than broad machine coverage. That decision explains both MartyPC’s strength (best-in-class accuracy for 8088/XT systems) and its limitation (no path yet to Pentium-class or Windows 98 emulation).
What Is 86Box? A Fork That Outgrew Its Parent
86Box began in 2016 as a fork of PCem, built specifically to widen machine and peripheral support while tightening accuracy for early 8088 and 8086-based systems. According to the project’s own documentation, “86Box originally started out as a fork of PCem in 2016,” and the two projects have diverged sharply since. The 86Box FAQ puts the split plainly: “In general, 86Box focuses more on the accuracy of emulation, especially for older 8088/8086 based systems.”
The project ships under a GPL-2.0-or-later license and is written in C, with source and release binaries hosted on its GitHub repository. Its current stable release is 86Box 6.0, published May 31, 2026, following 86Box 5.1 in September 2025, as logged on the project’s official release blog. Development has stayed active straight through September 2026, with commits landing as recently as September 15. The emulator covers IBM-compatible systems from 1981 through PCI-era machines of the late 1990s, including brands like IBM, Compaq, Dell, Packard Bell, AMI, Award, and Phoenix, across Socket 7, Super Socket 7, and Slot 1 motherboard families. Official builds exist for Windows 7 SP1 and newer, Linux distributions from roughly 2016 onward, and macOS 10.14 Mojave or later, with a recommended baseline of a 64-bit Core 2, Athlon 64, or ARMv8-class processor and 4GB of RAM.
What Is PCem? The Original That Still Has a Following
PCem predates 86Box and remains the project 86Box branched from. It is also GPL v2 licensed and written in C, maintained by Sarah Walker and contributors, with releases and documentation published on the official PCem project page. PCem’s latest official version is still v17, dated December 2020, which added new machine profiles including the Amstrad PC5086, Compaq Deskpro, Samsung SPC-6033P, Samsung SPC-6000A, Intel VS440FX, and Gigabyte GA-686BX. Its official release cadence has slowed considerably compared to 86Box’s near-monthly blog updates, and the main repository’s release history stretches back to that December 2020 baseline, though community-maintained builds such as davidebreso/pcem-dev continue shipping newer compiled versions for macOS and Linux users.
Where 86Box chose accuracy-first emulation, PCem’s own documentation trail, as summarized in 86Box’s FAQ, acknowledges a different trade-off: “PCem often takes various shortcuts to improve performance at the cost of accuracy, which does end up limiting the selection of software it can run.” That is not necessarily a dealbreaker. For users running well-documented, popular machine configurations, PCem is still fast, stable, and has a large enough historical user base that troubleshooting threads and pre-built configs are easy to find.
Building PCem from source on non-Windows platforms takes more manual setup than 86Box’s official binaries. On macOS, the community documentation for building PCem lists Xcode command-line tools and Homebrew as prerequisites, followed by dependencies including SDL2, wxWidgets (or wxmac), OpenAL, and optionally libpcap for networking support. On Linux, PCem can be compiled with networking enabled through a dedicated build flag, USE_PCAP_NETWORKING, which requires libpcap to be present on the build machine. None of this is difficult for anyone comfortable with a terminal, but it is a meaningfully higher bar than downloading a signed 86Box installer, and it is one reason 86Box has pulled ahead in casual adoption even though PCem’s underlying emulation quality remains respected.
What Is MartyPC? The Cycle-Accurate Newcomer
MartyPC is the outlier in this comparison. Built in Rust by developer David Balsom, it does not attempt to cover the same ground as 86Box or PCem. Instead, it focuses narrowly on early IBM PC-compatible systems: the original IBM 5150 PC, the IBM 5160 XT, generic XT clones, and related Tandy 1000-family machines. Its own README describes it simply: “MartyPC is a cross-platform emulator of early PCs written in Rust.” The project’s most recent tagged stable release is v0.4.1 from May 31, 2025, with a 0.5.0 development build reported active in September 2026 coverage.
MartyPC’s pitch is cycle accuracy, not breadth. A September 2026 report on the project credited it with 99.9997% cycle accuracy and the ability to run timing-sensitive demoscene productions that other PC emulators reportedly cannot execute correctly. In an interview describing the project’s origin, Balsom explained why he started building it: “At the time there was only one emulator, 86box, that could do it,” referring to running an extremely timing-strict 8088 demo called 8088 MPH. That single sentence sums up MartyPC’s reason for existing: 86Box got close to perfect 8088 accuracy, and Balsom wanted to push further.
86Box vs PCem vs MartyPC: Full Specs Comparison
| Spec | 86Box | PCem | MartyPC |
|---|---|---|---|
| Latest stable version | 6.0 | v17 | 0.4.1 (0.5.0 in dev) |
| Release date | May 31, 2026 | 2020 baseline, community builds newer | May 31, 2025 |
| GitHub stars | 4,842 | 1,936 | 938 |
| GitHub forks | 605 | 251 | 50 |
| Open issues | 15 | 133 | 14 |
| Primary language | C | C | Rust |
| License | GPL-2.0-or-later | GPL v2 | MIT |
| Era covered | 1981 through PCI-era (late 1990s) | Early PC through late-1990s Socket 7/Slot 1 | 8088/8086 IBM PC and XT era only |
| Windows support | Windows 7 SP1+ | Yes, official builds | Yes |
| macOS support | 10.14 Mojave+ | Source build via Homebrew | Yes |
| Linux support | ~2016-era distros and newer | Yes, official builds | Yes |
| Networking emulation | Yes, multiple adapters | Optional, via libpcap | Not established as mature |
| Sound card emulation | Broad Sound Blaster-era support | Broad Sound Blaster-era support | Early PC speaker/period-limited |
| Best suited for | DOS-to-Windows 98 gaming and preservation | Established Socket 7/Pentium-era configs | Cycle-accurate 8088/XT research |
The star gap between 86Box and PCem is not just a vanity metric. It roughly tracks with development velocity: 86Box’s official GitHub organization shows repository activity through October 21, 2026, while PCem’s official tree has moved far slower, leaning on community forks like pcem-dev to keep macOS and Linux builds current. MartyPC, despite trailing both on stars, has the highest ratio of open issues resolved relative to its size, a pattern typical of a smaller, tightly scoped codebase.
Benchmarks: Accuracy, Performance, and Compatibility
Cycle Accuracy Claims
No independent lab has published a single controlled benchmark running identical software across all three emulators on the same host hardware, and this article will not invent one. What does exist are three separate, source-backed data points. First, 86Box’s own FAQ frames PCem’s speed-over-accuracy trade-off as a limiting factor for certain software compatibility. Second, MartyPC’s developers reported 99.9997% cycle accuracy against reference 8088 timing in September 2026 testing, specifically citing successful playback of 8088 MPH, a demo notorious for exposing timing bugs in lesser emulators. Third, 86Box was previously the only emulator capable of running that same demo correctly before MartyPC arrived, according to Balsom’s own account of why he started the project.
Performance and Host Requirements
All three tools use low-level hardware emulation rather than the higher-level API translation DOSBox relies on, which means CPU demand scales with the complexity of the emulated system rather than staying flat. 86Box’s documented minimum is a 64-bit Core 2, Athlon 64, or ARMv8-class chip with 4GB RAM, and 86Box explicitly recommends faster hosts for later Pentium-class configurations. PCem’s requirements are not published as a single figure and vary by selected machine; running a late-1990s Socket 7 profile demands considerably more than an early 386 config. MartyPC’s scope keeps demands lower in practice, since it targets 8088/XT-class systems that are computationally simple by comparison, though cycle-accurate emulation is inherently more expensive per clock than “good enough” emulation.
In practice, this means a modern laptop from the last five years can comfortably run any of the three for their intended era. The bottleneck rarely shows up as choppy emulated video or audio; it shows up as host fan noise, since cycle-accurate emulation of period hardware, ironically, can spin up a 2026 laptop’s cooling system harder than many modern games do, particularly when 86Box is running a full Pentium II configuration with period networking and sound card emulation active simultaneously.
Compatibility Footprint
86Box’s machine list is the broadest of the three by a wide margin, spanning 1981-era IBM PCs through PCI-bus late-1990s systems. PCem v17 covers a similarly wide range but with fewer motherboard variants per era and a smaller total machine catalog based on its release notes. MartyPC is intentionally narrow: IBM 5150, IBM 5160 XT, generic XT clones, and Tandy 1000-family systems only. Anyone who needs a functioning Windows 98 desktop should rule out MartyPC immediately; anyone chasing perfect 8088 timing should treat 86Box and PCem as close-but-not-quite alternatives.
Pricing and Licensing: All Free, but Not All Equal
None of these three projects charge for the emulator itself, but “free” hides real differences in what you are allowed to do with the code and what it costs to actually use each tool for period-accurate software.
| Cost factor | 86Box | PCem | MartyPC |
|---|---|---|---|
| Software license fee | $0 | $0 | $0 |
| License type | GPL-2.0-or-later (copyleft) | GPL v2 (copyleft) | MIT (permissive) |
| Redistribution of modified forks | Must stay open source | Must stay open source | Can be closed-sourced by third parties |
| Required BIOS/ROM files | User-supplied, not distributed by the project | User-supplied, not distributed by the project | User-supplied, not distributed by the project |
| Windows 98 license (if used for OS testing) | Separate cost, not included | Separate cost, not included | Not applicable, pre-Windows era focus |
| Donation/sponsorship model | Community donations accepted | Community-maintained, informal | GitHub Sponsors listed on repo |
| Commercial use restrictions | None beyond GPL obligations | None beyond GPL obligations | None, MIT permits commercial forks |
The practical cost of any of these tools is not the download, it is the BIOS ROM sourcing. None of the three projects distribute copyrighted BIOS images, so users must dump their own from period hardware or source them through the same gray-market channels retro-computing hobbyists have used for years. That single requirement is often the real barrier to entry, not the emulator itself.
The copyleft-versus-permissive license split also matters more than most users realize once a project starts drawing commercial or institutional interest. Because 86Box and PCem both carry GPL v2-family licenses, any company or archive that wants to build a closed-source product on top of either codebase would need to keep that derivative work open source too, or negotiate separately with contributors. MartyPC’s MIT license removes that friction entirely, which is one reason a museum, library, or commercial preservation vendor might lean toward building on MartyPC’s codebase for a bespoke internal tool, even though its current machine coverage is far narrower than the other two.
Five Real-World Use Cases
1. Windows 98 gaming rigs for DirectX-era titles. Players chasing period-correct performance in games like early Quake ports, Diablo, or Age of Empires use 86Box to recreate specific Pentium II or Socket 7 configurations, matching original 3dfx Voodoo behavior in a way that native Windows compatibility layers cannot replicate.
2. Demoscene preservation and playback. Timing-sensitive demos like 8088 MPH require cycle-accurate CPU and video timing. This is where MartyPC’s narrow focus pays off, since it was purpose-built after 86Box became the first tool capable of running that demo correctly, and MartyPC’s developer pushed accuracy further from there.
3. Legacy enterprise software validation. Developers maintaining industrial control systems, point-of-sale software, or manufacturing tools originally written for DOS or Windows 95 use 86Box or PCem to validate that old binaries still boot and run correctly on period-accurate virtual hardware before migrating to modern systems.
4. Digital preservation and archival research. University and museum archivists reconstructing “period rooms” of computing history rely on the machine variety in 86Box’s catalog, particularly for reproducing specific vendor BIOS quirks in Compaq, Packard Bell, or Dell machines from the 1990s.
5. Retro LAN party recreation. Communities that host recurring “retro LAN” events use 86Box’s built-in network adapter emulation, sometimes paired with PCem’s optional libpcap networking support, to bridge emulated machines onto a shared virtual network for multiplayer DOS and Windows 95 games like Duke Nukem 3D or Warcraft II. Handheld retro-gaming enthusiasts running console cores through custom firmware, covered in our ROCKNIX vs muOS vs ArkOS comparison, occasionally add a PC-emulation layer through Batocera-style front ends for the same LAN sessions.
Common Setup Mistakes and How to Avoid Them
Most first-time frustration with all three emulators traces back to a handful of repeatable mistakes rather than genuine software bugs. Knowing them in advance saves hours of troubleshooting.
Mismatched BIOS and machine profile. Selecting a machine profile in 86Box or PCem without the exact matching BIOS ROM file for that specific board revision is the single most common cause of a black screen or boot failure. Machine profiles are tied to specific ROM dumps, not generic “IBM PC” or “Pentium” categories, and a ROM from a slightly different board revision will often fail silently rather than produce a clear error.
Wrong CPU-to-chipset pairing. Both 86Box and PCem allow selecting a CPU independently from the motherboard chipset in some configurations, but not every CPU is valid on every board. Installing a CPU model the selected chipset never actually supported in period hardware produces the same kind of instability a real 1990s PC builder would have hit mismatching a socket, and it is a frequent source of confusing crash reports on both projects’ issue trackers.
Skipping storage controller matching for period operating systems. Windows 95 and 98 installers expect specific IDE or SCSI controller behavior. Choosing a controller model that did not exist during a given OS release’s support window, or one lacking the right driver in the guest OS install media, is a common cause of installation failures that look like emulator bugs but are really period-accurate driver gaps, exactly as they would have been on real 1990s hardware.
Assuming MartyPC configs will import into 86Box or PCem. Because MartyPC’s scope and configuration model differ so fundamentally from the other two, users occasionally assume any 8088-era setup can move freely between all three tools. It cannot. MartyPC targets a narrower, more specific set of reference machines, and its configuration format was never designed for interchange with 86Box or PCem’s broader catalog.
What the Developers and Documentation Actually Say
Rather than paraphrase secondhand, it is worth reading how the projects describe themselves and each other directly. The 86Box FAQ states plainly that “86Box originally started out as a fork of PCem in 2016,” and goes on to explain the philosophical split: “In general, 86Box focuses more on the accuracy of emulation, especially for older 8088/8086 based systems.” The same FAQ entry is candid about the trade-off on the other side, noting that “PCem often takes various shortcuts to improve performance at the cost of accuracy, which does end up limiting the selection of software it can run.”
MartyPC’s own project description keeps things simple: “MartyPC is a cross-platform emulator of early PCs written in Rust,” according to the project’s GitHub README. And in an interview covered by The Register about the project’s origins, developer David Balsom explained the gap that motivated him to start building it in the first place: “At the time there was only one emulator, 86box, that could do it,” referring to running the technically demanding 8088 MPH demo. That comment, more than any marketing copy, explains why three separate projects now compete in what looks like a narrow niche: each one exists because the last one left a specific gap unfilled.
Who Should Use Which Emulator: Five Recommendations
Choose 86Box if you want the widest machine catalog, active monthly development, and a single tool that can plausibly cover everything from an early 1980s IBM PC to a late-1990s Pentium II Windows 98 box. It is the default recommendation for most new users in 2026, and the project’s near-monthly release blog makes it the easiest to keep current.
Choose PCem if you already have a working configuration from an older PCem setup, or you specifically need one of its historical machine profiles, such as the Amstrad PC5086, Samsung SPC-6033P, or Intel VS440FX, that has not been fully replicated elsewhere. It remains a reasonable choice for users who prioritize a lighter, more established codebase over 86Box’s broader but heavier feature set.
Choose MartyPC if your entire interest is the 8088/XT era and you need the highest possible timing accuracy, whether for demoscene playback, academic research into original IBM PC hardware behavior, or homebrew development targeting period-accurate 8088 timing constraints.
Choose DOSBox-X or DOSBox Staging instead if you just want a DOS game to run well without caring about hardware accuracy. All three emulators in this comparison are overkill for someone who only wants Doom or Commander Keen running quickly on a modern laptop.
Run more than one if your use case spans eras. A common pattern among preservationists is MartyPC for pre-1985 8088 work, 86Box for the 1986-1999 window, and a DOSBox variant for quick, low-friction DOS gaming that does not require hardware-level fidelity.
Migration Guide: Moving Between 86Box, PCem, and MartyPC
Because 86Box originated as a PCem fork, migrating a working setup between the two is more approachable than moving to or from MartyPC, which uses an entirely different configuration model. Here is a practical path.
Step 1: Inventory Your Current Setup
Document your current machine profile (CPU, chipset, RAM, video card, sound card) and locate your BIOS ROM files, hard disk images, and any saved configuration files before touching anything.
Step 2: Match the Closest Machine Profile
86Box and PCem do not share configuration file formats directly, so search each project’s machine list for the closest equivalent motherboard and chipset to your source setup. 86Box’s broader catalog usually has a matching or near-matching profile even for PCem-exclusive machines.
Step 3: Reattach Disk Images and ROMs
Hard disk images in standard formats (typically raw .img or .vhd) generally transfer between 86Box and PCem without conversion, since both emulate IDE controllers using standard sector layouts. BIOS ROM files are not interchangeable between projects and must be sourced separately for each tool’s supported machine list.
# Typical 86Box directory layout after migration
86box/
├── roms/
│ ├── machines/
│ └── video/
├── 86box.cfg
└── nvr/
# Typical PCem directory layout for comparison
pcem/
├── roms/
├── pcem.cfg
└── nvr/Step 4: Moving Into or Out of MartyPC
MartyPC does not target the same machine range as 86Box or PCem, so there is no direct configuration migration for anything beyond an 8088/XT system. Users moving an XT-class configuration into MartyPC should expect to rebuild the setup from scratch using MartyPC’s own configuration format rather than importing a PCem or 86Box profile. Since MartyPC is written in Rust, building from source requires a working Rust toolchain:
# Building MartyPC from source
git clone https://github.com/dbalsom/martypc.git
cd martypc
cargo build --release
./target/release/martypcStep 5: Validate Against Known-Good Software
After migration, boot a known-stable piece of software, ideally something CPU-timing sensitive, to confirm the new setup behaves correctly. Demoscene productions like 8088 MPH are a genuinely useful stress test precisely because they expose timing bugs that simpler software will not reveal.
Pros and Cons of Each Emulator
86Box
Pros: broadest machine catalog of the three, active near-monthly development, strong networking and sound card support, official builds for Windows, macOS, and Linux, large enough community that configuration help is easy to find. Cons: heavier host requirements for late-era Pentium configurations, steeper learning curve than DOSBox for newcomers who do not need hardware-level accuracy.
PCem
Pros: mature, well-documented historical machine list, lighter resource footprint in many configurations, large archive of existing community configs from years of prior use. Cons: slower official release cadence than 86Box, some accuracy shortcuts limit compatibility with timing-sensitive software, macOS support depends more heavily on community-maintained builds.
MartyPC
Pros: the most cycle-accurate option for 8088/XT-class systems, permissive MIT license allows broader reuse, modern Rust codebase, actively developed with 2026 progress toward a 0.5.0 release. Cons: narrow machine scope excludes anything past the early PC/XT era, smaller community than 86Box or PCem, not a realistic option for Windows 95/98 gaming.
Sound, Networking, and Peripheral Support Compared
Peripheral fidelity is where 86Box separates itself most clearly from the other two. Its documentation lists broad support for period sound cards, video adapters, network adapters, disk controllers, and SCSI adapters, making it the practical choice for anyone who wants a fully working Sound Blaster 16 setup alongside period-accurate networking. PCem supports a comparable range of sound and peripheral combinations and can be compiled with optional networking through libpcap, though this requires a source build rather than shipping by default in every release. MartyPC’s verified scope does not extend to Sound Blaster-era or PCI-era peripherals, since its target hardware predates most of that ecosystem; early PC speaker audio is the realistic ceiling for its current development state.
For anyone planning a retro LAN party or trying to reproduce networked DOS gaming from the 1990s, 86Box’s built-in network adapter emulation combined with its broad NIC catalog makes it the only one of the three genuinely built for that use case out of the box.
Where to Find Help and Community Support
All three projects are volunteer-maintained, and support quality tracks fairly closely with each project’s size. 86Box’s GitHub repository has only 15 open issues against 4,842 stars, a ratio that suggests an actively triaged tracker rather than a backlog nobody is managing, and its official blog publishes detailed changelogs with every release that double as informal documentation for new machine profiles and bug fixes. PCem’s repository carries 133 open issues against a smaller 1,936-star base, a heavier backlog that reflects its slower maintenance cadence, though its long history means many common problems already have answers scattered across older forum threads and community wikis. MartyPC’s tracker sits at 14 open issues against 938 stars, proportionally close to 86Box’s ratio despite the much smaller community, which is typical of a young, tightly scoped project where the core maintainer is still directly engaged with most reported bugs.
For configuration help specifically, the practical reality is that 86Box’s larger, more current user base makes it easiest to get a fast answer to a specific machine-profile question in 2026. PCem’s community skews toward longtime retro-computing hobbyists who often have deep expertise but less frequent activity. MartyPC’s smaller audience is more specialized, but the project’s narrow focus means questions tend to be answered by people working on genuinely similar 8088/XT problems rather than general troubleshooting. Users who prefer a broader multi-system tool with an active community behind it may also want to compare BizHawk’s 45-plus system coverage, though it trades period hardware accuracy for breadth.
The Verdict: Which Retro PC Emulator Wins in 2026
There is no single winner across every use case, but the data points in one clear direction for most readers. 86Box combines the broadest machine catalog, the most active development pace (a 6.0 release in May 2026 following 5.1 in September 2025), the largest GitHub community at 4,842 stars, and the most complete peripheral support of the three. For anyone building a general-purpose DOS-to-Windows-98 retro PC in 2026, it is the sensible default.
PCem still earns its place for users with existing configurations or a specific need for one of its historical machine profiles, but its slower release cadence and narrower official platform support make it a secondary pick rather than a first choice for new users starting from scratch in 2026.
MartyPC is not competing for the same audience at all. Its 99.9997% cycle accuracy claim on 8088-era hardware and its ability to run notoriously timing-sensitive demoscene software make it the correct tool for a narrow but important job: anyone who needs the most accurate possible reproduction of an original IBM PC or XT should use MartyPC, regardless of how much smaller its community is next to 86Box or PCem.
The three-way star count, 4,842 for 86Box, 1,936 for PCem, and 938 for MartyPC, roughly mirrors this verdict without being the whole story. A bigger community means faster bug fixes and a wider machine catalog, but it does not automatically mean the “best” tool for every job. MartyPC’s smaller number reflects a deliberately narrow scope, not a weaker project, and PCem’s slower recent growth reflects a mature codebase that already solved most of the problems its users care about years ago. Read the star counts as a proxy for momentum and community size, not as a direct ranking of engineering quality. For broader coverage of emulation frontends and handheld operating systems that can bundle any of these cores into a single library, see our roundup of the wider mobile and handheld gaming ecosystem and the dedicated EmuDeck vs RetroDECK vs Lakka comparison.
Frequently Asked Questions
Is 86Box better than PCem?
For most 2026 use cases, yes. 86Box has a broader machine catalog, more active development, and a larger GitHub community (4,842 stars versus 1,936 for PCem). PCem remains a valid choice for users with existing configurations or specific historical machine profiles it supports that 86Box does not replicate exactly.
What is MartyPC used for?
MartyPC specializes in cycle-accurate emulation of early IBM PC and XT-compatible systems from the 8088/8086 era. It is built for accuracy research, demoscene playback, and preservation work rather than general DOS or Windows gaming.
Can I run Windows 98 games on MartyPC?
No. MartyPC’s verified machine support covers the IBM 5150, 5160 XT, generic XT clones, and Tandy 1000-family systems, none of which are capable of running Windows 98. Use 86Box or PCem for Windows 95/98-era gaming.
Are 86Box, PCem, and MartyPC free to use?
Yes, all three are open source and free to download. 86Box and PCem are licensed under GPL v2 variants, while MartyPC uses the more permissive MIT license. None of the three distribute copyrighted BIOS ROM files, which users must source separately.
Do I need to own the original hardware to use these emulators?
Not technically, but you do need BIOS ROM files that match your chosen machine profile, and none of these projects distribute those files due to copyright. Most users either dump ROMs from hardware they own or source them through established retro-computing archives.
How is 86Box related to PCem?
86Box began as a direct fork of PCem in 2016. The two have since diverged, with 86Box prioritizing broader machine coverage and stronger 8088/8086-era accuracy, while PCem has kept a more conservative, performance-leaning approach on some configurations.
Which emulator has the most active development in 2026?
86Box, based on release cadence and commit activity. It shipped version 6.0 in May 2026 after 5.1 in September 2025, with commits as recent as September 15, 2026. MartyPC is also actively developed, working toward a 0.5.0 release. PCem’s official repository shows a notably slower release history by comparison.
Should I use DOSBox instead of these three emulators?
If you just want to play a DOS game quickly without hardware-accurate emulation, DOSBox-X or DOSBox Staging is faster to set up and requires no BIOS ROM sourcing. See our full DOSBox vs DOSBox-X vs DOSBox Staging comparison for that path. 86Box, PCem, and MartyPC exist for users who specifically need period-accurate hardware behavior, not just software compatibility.
