Running os8088 -- QEMU, 86Box and Real XT Hardware

Try it in the browser

Below is a PC emulator that runs in the browser and is configured to load os8088's disk image with many of the apps available to use. The emulator runs very fast, and doesn't have sound, but gives you a taste of how the operating system functions.

The os8088 desktop with a Note Pad, a Clock, a Bounce window, the Control Panel and the Task Manager open at once, and a dock along the bottom.

os8088 emulated IBM PC

Not started.

Run it from source

The source code comes with 86Box configurations you can use on your Mac, Linux or Windows PC to run the operating system. You can see all the available configurations in the table further down this page.

If you want to go this route, start by cloning the repo using the following command:

git clone https://github.com/jggonz/os8088.git

If you're on a Mac with an M chip, you can install the required tools (nasm, python3, and qemu-system-i386) by running tools/setup-macos.sh which leverages Homebrew behind the scenes. This script also fetches the 86Box ROM sets since those are not bundled with 86Box.

Now you can run the following make commands to run the various available configurations. Each one assembles the floppy images it needs, then launches 86Box:

XT Configurations

The 86Box XT machines and the make target that launches each
`make xt`	An IBM PC/XT, 8088 at 4.77MHz, 256KB, an Oak OTI-067 VGA card, and the two 360KB floppies in A: and B:
`make xt-640`	The same 8088 at 4.77Mhz, VGA, two 360KB floppies and 640KB of RAM
`make xt-cga`	A 256KB XT with a CGA: 640x200, monochrome
`make xt-hercules`	A 256KB XT with a Hercules: 720x348, monochrome
`make xt-multimon`	A 640KB XT with a CGA and a Hercules Plus. 86Box opens a window per card. This setup allows for Dual Display mode to be enabled in the Control Panel
`make xt-sound`	A 640KB XT with a Sound Blaster

286, 386s, 486s and Pentiums

The 86Box AT-class machines and the make target that launches each
`make 286`	AMI 286 clone board, 12.5MHz, 1MB, two 1.44MB drives
`make 286-sound`	The same board with a Sound Blaster 16 in it
`make 386sx`	Shuttle HOT-304, 386SX at 16MHz, 2MB
`make 386`	Micronics 386 board, 386DX at 25MHz, 2MB
`make 386-xms`	The same board with 4MB. Task Manager's Memory view shows the XMS line
`make 386-sound`	The 386DX/25 with a Sound Blaster 16
`make 486`	AMI 486 board with the SiS 471 chipset, 486DX2 at 66MHz, 8MB, SB16
`make pentium`	ASUS P/I-P55TP4XE with the 430FX chipset, Pentium 133MHz, 16MB, SB16

Configurations for specific programs

The following configurations spin up an emulator and let you try some of the included apps:

The 86Box machines that boot one application disk, and the make target for each
`make xt-word`	Microsoft Word 1.1a XT w/8088-4.77MHz and 640KB RAM, a 720KB disk in B: containing Word 1.1 (Assembly version)
`make 386-word`	The same Word disk on the 386DX/25, at 1.44MB.
`make 386-c-word`	CWORD, the word processor written in C, on the 386DX/25. Needs the C compiler, which `tools/setup-cc.sh` fetches and builds.
`make xt-z`	Frotz (Z-Machine emulator) on a 640KB XT with a Sound Blaster 2.0 and a 720KB story disk.
`make 386-z`	Frotz on the 386DX/25 with an SB16 and the 1.44MB story library.
`make xt-runcpm`, `286-runcpm`, `386-runcpm`	RunCPM, CP/M 2.2 on an emulated Z80 core. On an XT with an 8088 running at 4.77Mhz runs the Z80 at 0.22MHz. It's usable, but slow.
`make xt-c64`, `286-c64`, `386-c64`	The Commodore 64 emulator. It is only usable on 386 or faster PCs
`make xt-sound-1.44`	A 640KB XT with a Sound Blaster, booting the 360KB system disk with `apps-all.img` in a 1.44MB B: drive

The Frotz and RunCPM disks are assembled from files you need to get by running tools/getstories.py and tools/getruncpm.py

Writing to real media

If you have a real XT, you want the 360KB images: os8088-360.img for drive A: and apps360.img for drive B:. Write them to double-density 5.25" disks with dd, one disk at a time:

dd if=os8088-360.img of=/dev/fd0 bs=512

Check the device name before you press Return. dd writes to whatever you put after of= and asks no questions, so name the wrong device and you lose that disk. Run diskutil list on macOS or lsblk on Linux first, and unmount the drive before you write to it.

Use a genuine 360KB drive if you can. A 1.2MB drive can write these disks, but it writes thinner tracks, and period hardware often can't read them back. If your XT won't boot a disk that looks fine on your modern machine, that's usually why.

Put the boot disk in A: and the software disk in B: and switch the machine on. The software disk in B: is optional, but you'll probably want to try some of the apps.

Building from source

If you'd rather build the floppy images yourself instead of downloading them, clone the repo and run make:

git clone https://github.com/jggonz/os8088.git
cd os8088
make

That puts the four core floppy images in build/, ready to mount in an emulator or write to a real disk.

You'll need nasm, python3 and qemu-system-i386 installed first. On a Mac, tools/setup-macos.sh installs them for you. 86Box is optional, and only needed if you want to run the machine configurations above.

A few other targets worth knowing about:

Makefile targets
`make`	Build the four core floppy images into `build/`.
`make worddisk`	Build the Microsoft Word disk, in all three geometries.
`make cworddisk`	Build the CWORD disk. Needs a C compiler, which `tools/setup-cc.sh` fetches and builds.
`make allapps`	Build `apps-all.img`, the one floppy with every program on it. Needs the C compiler too.
`make run`	Boot the 1.44MB pair in QEMU with the emulated serial mouse attached.
`make test`	Boot headless with a QMP control socket at `build/qmp.sock`, for scripted clicks and screendumps.
`make debug`	Boot with QEMU halted, waiting for gdb on port 1234.
`make xt`	Boot the 360KB pair in 86Box using `vm/xt/86box.cfg`. Twenty-five more 86Box machines sit beside it -- see the tables above.
`make clean`	Remove `build/`.

The kernel is compiled with a cpu 8086 directive to make sure that we don't accidentally ship a kernel with assembly meant for newer chips and break XT compatibility. The build also passes NASM -w+error, so a newer instruction stops the build instead of slipping through as a warning.

Without that, you wouldn't find out until a real XT choked on it. So if the build works, it runs on an 8088.