Os8088.com: IBM XT OS now has a Browser, CP/M 2.2 with Z80 core and MS Word 1.1a

Introduction

The project Os8088.com started as a curiosity: can a machine built around the 8088 CPU from 1982 run modern web browsers, legacy CP/M software, and even a vintage word processor? The answer turned out to be a full‑stack emulation layer that squeezes a browser, CP/M 2.2 with a Z80 core, and MS Word 1.1a into the 640 KB address space of an IBM XT. The code is open, the design is modular, and the performance is surprising for such an old platform.

Why This Matters

Engineers who work on embedded systems, retro‑computing, or cross‑platform emulation often face the same constraints: limited memory, slow clocks, and the need to keep legacy applications alive. Os8088.com demonstrates how to bridge decades of software stacks on a single hardware platform. It also serves as a reference implementation for anyone who wants to run high‑level languages, JavaScript, or even high‑resolution text rendering on hardware that never saw a GUI.

How It Works

The system is organized into four major layers:

1. Hardware Abstraction Layer (HAL) – provides uniform access to the XT’s memory, I/O ports, and interrupt controller.
2. 8088 Emulation Core – runs the original 8088 instruction set, while also hosting a lightweight Z80 interpreter for CP/M.
3. Subsystem Runtime – includes a WASM‑based browser engine and an MS Word 1.1a emulator that share the same memory manager.
4. Input Bridge – captures keyboard, disk, and serial events and routes them to the appropriate subsystem.

The flow moves from the HAL up through the emulation core, then into the specific runtimes. Memory is allocated by a custom pool allocator that tracks usage per subsystem to avoid collisions.

flowchart TD
    A[Hardware Abstraction Layer] --> B[8088 Emulation Core]
    A --> C[Z80 CP/M Subsystem]
    B --> D[Browser Runtime (WASM)]
    B --> E[MS Word 1.1a Emulation]
    C --> E
    F[Input Bridge] --> B
    F --> C
    G[Memory Manager] --> A

The HAL abstracts the XT’s 8250 UART and the BIOS video memory at 0xB8000. The 8088 core runs at 4 MHz (the XT’s stock speed) and uses a cycle‑accurate interpreter for the most critical paths. The Z80 subsystem is a thin wrapper that maps Z80 memory segments onto the 8088’s address space, allowing CP/M 2.2 to load its BDOS and BIOS unchanged.

When a browser request arrives, the WASM runtime generates native code that directly manipulates the video buffer. The MS Word emulator uses a text‑mode rasterizer that operates on the same buffer, overlaying a simple WYSIWYG cursor. All input goes through the bridge, which queues events and dispatches them to the active subsystem.

Core Concepts

• Dual‑ISA Emulation – The 8088 core runs natively, while a Z80 interpreter runs in a protected memory region. The interpreter intercepts Z80‑specific instructions and translates them on the fly.
• Flat Memory Model – Despite the segmented nature of the original XT, the HAL presents a 1 MiB flat address space. A simple bitmap allocator keeps track of free blocks per subsystem.
• WASM Thunking – The browser engine is written in C++ and compiled to WebAssembly. A thin JS glue module maps the WASM linear memory to the HAL’s video buffer, avoiding copies.
• TSR Integration – CP/M programs can install Terminate‑and‑Stay‑Resident hooks that the 8088 core respects, allowing background tasks like the word processor to remain active.

Examples & Code Walkthrough

HAL Memory Allocation

/* custom allocator used by all subsystems */
typedef struct block {
    uint32_t start;
    uint32_t size;
    bool     used;
} block_t;

static block_t memory_map[] = {
    {0x0000, 0x9C00, false},   /* BIOS / DOS area */
    {0xA000, 0x2000, false},   /* Video memory */
    {0xC000, 0x4000, false},   /* Extended RAM */
};

uint32_t alloc_block(uint32_t size) {
    for (size_t i = 0; i < sizeof(memory_map)/sizeof(memory_map[0]); ++i) {
        if (!memory_map[i].used && memory_map[i].size >= size) {
            memory_map[i].used = true;
            return memory_map[i].start;
        }
    }
    return 0xFFFFFFFF;
}

The allocator is called during boot to carve out regions for the 8088 core, the Z80 interpreter, and the browser/WASM heap.

8088 Interrupt Handler for Keyboard

; 8088 assembly, IRQ0 handler (keyboard)
push ax
push bx
push cx
push dx

; read scancode from 0x60
in al, 0x60
call translate_scancode   ; custom routine to ASCII
call queue_input          ; put into bridge queue

pop dx
pop cx
pop bx
pop ax
iret

translate_scancode is a small lookup table that converts raw scancodes to ASCII, respecting shift and ctrl modifiers.

CP/M BDOS Wrapper

/* thin Z80->8088 bridge for CP/M BDOS calls */
static void bdos_wrapper(uint8_t function, uint16_t arg) {
    switch (function) {
        case 0x0E: /* Print character */
            putchar((char)arg);
            break;
        case 0x0F: /* Flush output */
            fflush(stdout);
            break;
        case 0x12: /* Get address of PSP */
            // return segment base
            break;
        default:
            /* Unknown function – emulate with a stub */
            break;
    }
}

When the Z80 interpreter executes a BDOS call, it jumps to this wrapper, which forwards the request to the native 8088 I/O routines.

WASM Bootstrap

// glue.js – minimal bridge between JS and WASM
const wasmModule = await WebAssembly.instantiateStreaming(fetch('browser.wasm'), {
    env: {
        memoryBase: 0xA000,   // map WASM memory to video buffer
        tableBase: 0x0000,
        outputChar: function(ch) {
            // write directly to HAL video memory
            const pos = cursorPos & 0xFFFE;
            const page = (cursorPos >> 14) & 0x03;
            HAL_video_write(page, pos, ch);
        }
    }
});

The outputChar callback is invoked by the WASM runtime whenever the browser needs to render a character. It bypasses the JavaScript DOM and writes straight into the HAL’s video memory, achieving near‑native speed.

Best Practices

• Keep the HAL thin – avoid heavy logic inside the abstraction layer; it becomes a performance bottleneck on a 4 MHz CPU.
• Profile with cycle‑accurate simulators – tools like QEMU or an FPGA model let you see exactly where cycles are spent before you burn precious XT time.
• Isolate subsystems – use separate memory regions for each runtime. Overlap can cause subtle corruption when one subsystem overwrites the video buffer used by another.
• Reuse existing BIOS calls – the XT BIOS provides simple I/O primitives. Leveraging them reduces the amount of custom driver code you need to maintain.

Common Mistakes & Anti-Patterns

1. Mixing video pages – Assuming a single video segment is enough for both the browser and Word. The fix is to allocate distinct video pages per subsystem.
2. Blocking the interrupt line – Writing long loops inside IRQ handlers starves other devices. Use a queue and let the main loop process events later.
3. Assuming flat memory – The HAL presents a flat view, but the underlying hardware is segmented. Forgetting this leads to address wrap‑arounds and data loss.
4. Ignoring Z80 timing quirks – Some CP/M programs rely on precise Z80 instruction timing. A naive interpreter that skips cycles breaks compatibility.

Performance Considerations

• CPU utilization – The browser runtime consumes roughly 70 % of the 8088’s cycles, leaving ~30 % for the Z80 interpreter and Word emulator. The split can be adjusted by lowering the browser’s rendering quality or by using a faster interpreter for the Z80.
• Memory bandwidth – All subsystems share the same physical RAM, so contention on the bus can cause stuttering. The custom allocator reduces fragmentation, which in turn lowers bus traffic.
• I/O latency – Keyboard input is processed via a hardware interrupt, which adds ~30 µs of latency per scan. The bridge’s event queue smooths out bursts and prevents dropped keys.

Real-World Usage

A small museum uses Os8088.com to run a live demo of a CP/M word processor on an actual XT, while simultaneously loading a historic web page in the built‑in browser. The project also serves as a teaching tool for computer‑architecture courses, letting students experiment with low‑level emulation without needing modern hardware.

Frequently Asked Questions (FAQ)

Q: Does this require modifying the XT’s hardware?
A: No. All changes are software‑only. The HAL runs on the XT’s existing BIOS and does not require any extra cards.

Q: Can I run modern web pages?
A: Only those that rely on pure HTML/CSS/JS without plugins. The WASM runtime is limited to the subset supported by the browser build.

Q: How do I extend the system?
A: Add new subsystems by implementing the same HAL interface and registering them with the memory manager. The bridge automatically routes input.

Q: What about networking?
A: The project does not include a network stack. Serial I/O is present but not connected to a protocol layer.

Q: Is the code production‑ready?
A: It is stable enough for demos and educational use. Bugs may still surface under heavy load.

Conclusion

Os8088.com proves that a 1982 IBM XT can host a modern browser, a full CP/M 2.2 environment with Z80 emulation, and a vintage MS Word processor simultaneously. The key is a disciplined HAL, careful memory management, and tight integration between the 8088 core and the Z80 interpreter. The open‑source nature of the project invites further experimentation, whether you are porting new languages, adding networking, or simply preserving digital history on hardware that never expected a web browser.