86Box: a low level x86 emulator for period-accurate PCs
Emulator of x86-based machines.
At a glance
- What is it?
- 86Box emulates machines from the 1981 IBM PC 5150 up to PCI-era systems, with a focus on hardware accuracy rather than speed. Here is what it does, how to build it, and where it stops being the right tool.
- Who is it for?
- Adopt 86Box when you need a specific vintage machine reproduced closely, from an IBM 5150 to a Micro Channel PS/2, and you are willing to supply BIOS ROMs yourself. Do not adopt it for fast virtualisation of modern guests or for running several heavy VMs at once, since most emulation logic runs in a single thread.
- Can I use it commercially?
- Yes, with conditions. GPL-2.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly C, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 29, 2026, and from our analysis. They are not legal advice.
Editorial analysis
What 86Box emulates, and who needs that
86Box is a low level x86 emulator that runs older operating systems and software written for IBM PC systems and compatibles, from 1981 through fairly recent designs based on the PCI bus. The README frames the target plainly: emulation of 8086-based processors up to the Mendocino-era Celeron, with a focus on accuracy rather than throughput. That word accuracy is the whole pitch. The project lists many available systems, including the first IBM PC 5150 and the Micro Channel Architecture PS/2 line, plus peripherals such as video adapters, sound cards, network adapters, hard disk controllers and SCSI adapters.
The audience is narrow and specific. If you need to run MS-DOS, older Windows versions, OS/2, many Linux distributions, BeOS or NEXTSTEP, 86Box is built for that. It is also built for the person who cares which sound card is installed and which video adapter is present, because those choices are exposed rather than abstracted away. That is a different job from running a modern guest quickly. A hypervisor hides hardware; 86Box reproduces it, and the configuration surface is large because of that.
Low level emulation and the single-thread constraint
The architectural point that shapes everything else is in the requirements section: most emulation logic is executed in a single thread. The README states that systems with greater IPC capacity should be able to emulate higher clock speeds. So the practical ceiling on a guest's speed is set by the instructions-per-clock performance of one host core, not by how many cores you have. A machine with many slow cores will do worse here than a machine with fewer fast ones.
The repository layout reflects a conventional C project built around CMake. The top level holds CMakeLists.txt, CMakePresets.json, a Makefile, vcpkg.json, a src/ directory, a tests/ directory, and platform packaging under debian/. There is also a doc/ directory. Optional integrations named in the README are munt, FluidSynth, Ghostscript and the Discord Game SDK, each under its own licence. MIDI output can go to Windows built-in MIDI support, FluidSynth, or emulated Roland synthesizers. For a program of this scope, the README's own contribution note is worth quoting: it asks for development help and points at a specific issue for details.
Building 86Box from source with CMake presets
The README does not give a step-by-step install; it points at the build guide in the documentation for instructions on building from source. What the repository does provide is a Makefile that wraps CMake presets. The Makefile defines targets named regular, optimized, debug, dev_debug and development, and a clean target that removes the build directory. The default target is regular, so running make with no arguments builds that preset. The Makefile also shows two variables that change the configuration: setting qt to 6 adds -DUSE_QT6=ON, and setting dynarec to new adds -DNEW_DYNAREC=ON. Extra CMake arguments can be passed through CMAKE_FLAGS.
The Makefile is a convenience layer, not a requirement: CMakePresets.json is the underlying source of truth, and the build guide covers platforms the Makefile does not. Expect to need the Qt development packages and the other dependencies listed there before the configure step succeeds.
A first machine, and why the ROM set matters
86Box can be used on its own, and the README gives exactly one command line option for that: --vmpath, with the short form -P. The option points the emulator at the directory holding your virtual machines. That is the entire standalone workflow the README documents. Everything else happens in the interface, which the README describes as easy to use and inspired by mainstream hypervisor software.
The step that trips up newcomers is not the interface, it is the firmware. A machine definition needs a BIOS for that specific system, and the 86Box project does not ship the ROMs. Search data around this project is dominated by people looking for a rom set, which tells you how central that requirement is. Until the right ROM is in place for the machine you selected, the guest will not boot, no matter how the rest of the configuration looks.
For multiple machines, the README points at separate manager applications rather than building management into the emulator: Avalonia 86 for Windows and Linux, 86Box Manager for Windows only, 86Box Manager X as a cross platform port of 86Box Manager, sl86 as a command-line manager written in Python, Linbox-qt5 for Linux, and MacBox for macOS.
Where 86Box is the wrong tool
The single-threaded emulation model is a real constraint, and the README is honest about the consequence: performance varies with host and guest configuration, and higher clock speeds depend on host IPC. If your goal is to run many guests concurrently on one server, this design works against you, because each instance is competing for the same kind of fast single-core execution rather than spreading across cores.
Host support has floors that exclude older machines. The minimum is a 64-bit Intel Core 2, AMD Athlon 64 or ARMv8 processor, 4 GB of RAM, Windows 7 SP1 or newer on Intel/AMD (Windows 11 or newer on ARM), Ubuntu 16.04 or Debian 9.0 or other distributions from 2016 onwards, and macOS 10.14 Mojave or newer. A 32-bit host is out. So is a machine with 2 GB of RAM.
The other boundary is legal and practical rather than technical. The emulator itself is free, but the system firmware is not part of the download, and the README does not document a bundled or sanctioned source for it. If you cannot obtain a BIOS for the machine you want to emulate, 86Box cannot help you, and no amount of configuration will change that. Anyone expecting a single installer that produces a booting Windows 98 desktop has skipped the part of the process that actually requires work.
86Box compared with PCem and with VirtualBox
The comparison people search for most is 86Box versus PCem, and the two sit in the same category: low level emulation of period PC hardware, with accuracy as the goal. The practical difference visible from this repository is project shape. 86Box is under the 86Box organisation with a documented build guide, CMake presets, CI, translation infrastructure on Weblate, and a set of third-party manager applications listed in the README. That ecosystem of external managers is a distinguishing feature: the emulator itself stays focused, and machine management is delegated to separate projects with their own release cycles. If you want one program that does both, that split is friction. If you want the emulator to stay out of the way, it is the point.
VirtualBox is the other common search, and the difference is categorical rather than a matter of degree. VirtualBox virtualises hardware to run guests quickly and presents abstracted, modern devices. 86Box emulates specific vintage chipsets and cards so that software written against those cards behaves as it did. A guest that only needs to run and does not care which sound card it sees is a VirtualBox job. A guest that probes a Sound Blaster at a fixed port, or that needs a particular Micro Channel PS/2, is not.
Licence, optional dependencies and upgrade cost
86Box is released under the GNU General Public License, version 2 or later, and the README points to the COPYING file at the repository root for the full text. That matters if you intend to redistribute a modified build: GPL-2.0-or-later carries obligations that a permissive licence does not, and the COPYING file is the place to read them rather than a summary. The emulator can optionally use munt, FluidSynth, Ghostscript and the Discord Game SDK, each distributed under its own licence, so a build with those enabled is not covered by a single licence. This is a description of what the repository states, not legal advice.
Upgrade cost is dominated by the ROM and configuration layer, not by the binary. The project ships tagged releases, with 86Box 6.0 dated 2026-05-31, a 6.0 beta dated 2026-05-18, and 5.3 dated 2025-12-22, and the last push to the master branch was on 2026-09-22. If you build from source, the Makefile's clean target deletes the whole build directory, so a rebuild starts from configure. If you use a manager application, its release cadence is separate from the emulator's, and a manager that has not caught up with a new 86Box version is a coordination problem you own.
Editorial conclusion
Adopt 86Box when you need a specific vintage machine reproduced closely, from an IBM 5150 to a Micro Channel PS/2, and you are willing to supply BIOS ROMs yourself. Do not adopt it for fast virtualisation of modern guests or for running several heavy VMs at once, since most emulation logic runs in a single thread. Verify first that you have the ROMs your chosen machine needs, that your host meets the stated minimums for your platform, and whether you want a manager such as 86Box Manager or Avalonia 86 instead of the --vmpath command line.
Frequently asked questions
Is 86Box free?
Yes. 86Box is released under the GNU General Public License, version 2 or later, and the README says the project does not charge for the emulator while still accepting donations.
What are the differences between 86Box and VirtualBox?
86Box is a low level emulator that reproduces specific vintage systems and peripherals, from the IBM PC 5150 to PCI-era designs, so software sees the hardware it was written for. VirtualBox is not discussed in the 86Box README, which describes 86Box's own approach rather than comparing the two.
Which is better, PCem or 86Box?
The README does not compare the two. What it does show is 86Box's project shape: a build guide, CMake presets, and a list of separate manager applications for handling multiple virtual machines.
How do I install 86Box?
The README does not give install steps; it points to the documentation for building from source. The repository's Makefile wraps CMake presets, so running make builds the regular preset and a clean target removes the build directory.
How do I use 86Box?
86Box can run on its own with the --vmpath option (short form -P), which points at the directory containing your virtual machines; the rest of the configuration happens in the interface. The README also lists manager applications such as 86Box Manager and Avalonia 86 for handling multiple machines.
What is 86Box?
86Box is a low level x86 emulator that runs older operating systems and software designed for IBM PC systems and compatibles, from 1981 through PCI bus based designs, with emulation of 8086-based processors up to the Mendocino-era Celeron.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/86box-86box)