Rediscovering my 1996 Machine-Code Windowed OS for a Custom Am29000 PC

By Oscar Toledo G. Date: July 30, 2026

Between the autumn of 1996 and the spring of 1997, in the heart of Mexico, I embarked on a journey to write a windowed operating system entirely in 32-bit machine code. The result was a system compact enough to fit on a single floppy disk. I remember the sheer adrenaline of seeing it boot up for the first time.

At the time, I felt a sense of triumph because mainstream options like Windows 3.1 or GEM couldn't be booted directly from a floppy. However, I didn't yet realize the true technical significance of what I had achieved. Because this OS was designed for a homebrew computer powered by the Am29000 processor, it wasn't something I could simply share with the world.

Now, I am diving back into my old notes and memories to rediscover a project that had slipped from my mind.

The "World's Fastest" Processor

While I was feeling accomplished with my work on the transputer and its OS, my father was preoccupied with a different challenge: building a new computer based on a cutting-edge 32-bit CPU.

"The AMD Am29000, released in 1987, was marketed as the world's fastest processor—a claim that feels like a meme today."

The Am29000 was indeed impressive, capable of executing one instruction per clock cycle. Its footprint was found in various high-end applications:

• Postscript accelerators for printers.
• NuBus video cards for Apple Quadra Macs.
• Arcade titles (e.g., Battle of the Solar System and F-15 Strike Eagle by Microprose).
• Avionics systems (specifically dual-processor boards for redundancy).

The Hardware Hurdle

Despite its speed, the Am29k was difficult to implement. Its performance relied on extremely fast TTL chips and memory. The architecture featured separate buses for data and instructions, which made interfacing a nightmare. Most developers used DRAM, but since DRAM was slow, the processor's speed advantage vanished.

My father, however, bet on Static RAM (SRAM). He acquired numerous 128KB SRAM chips with 8-bit buses. Some were early surface-mount components—four 32K chips packed onto tiny green PCBs.

G11V1 Technical Specifications

The Development Process

This project was a collaborative effort. My father handled the initial processor boot sequence, while I took over the following tasks:

• Translate Z280 code to initialize the Cirrus Logic VGA.
• Develop the keyboard decoder.
• Write the disk routines.
• Create a monitor program for memory listing and data saving.
• Integrate a micro-assembler and micro-disassembler.

Because the instruction set was so complex, the micro-assembler was vital. It allowed us to use mnemonics, though we were limited by the lack of labels, making the process of moving code blocks an absolute chore.

; Hypothetical Am29k-style mnemonic snippet
MOV R1, #0x1234  ; Load immediate value into register
ADD R2, R1, R3   ; Add R1 and R3, store in R2
CMP R2, #0x0000  ; Compare result to zero

To program the EPROMs, we had to use a separate Z280 machine. Eventually, I realized the daunting task ahead: I had roughly 200 programs (games, utilities, and apps) on the Z280 that needed porting. Unfortunately, most were already obsolete.

Since I have no photo of the G11V1, here is the G11V2. Note the PCI bus and the four 512KBx8 memory modules.

The Transition to Windowing

After the G11 was completed, my father spent his time documenting the processor's undocumented behaviors and special registers. I spent my time typing and printing his findings.

I returned to my transputer but occasionally used the G11 to build:

1. An enhanced floppy OS.
2. A text editor compatible with the Canon BJC-600 bubblejet printer.
3. An MSX emulator (which allowed me to finally play Gradius).

However, I was captivated by the colorful icons of Windows 3.1. I wanted to build a windowed system, but I couldn't find any Windows 3.1 programming manuals in my local libraries—they only had books on Turbo-C, Turbo-Pascal, and QBasic.

Eventually, I found a discounted book on OS/2 programming. This became my blueprint. The OS/2 model was elegant:

• Window Lifecycle: Open $\rightarrow$ Draw $\rightarrow$ Close.
• Message Pipelines: Every window process has a pipeline.
• Window Classes: You assign an interface handler (class) to a window to process user interactions.

The logic of user interaction can be simplified as: $\text{Interaction} = \sum (\text{MouseClick} + \text{MouseMove} + \text{DoubleClick})$

I learned that you could nest windows to create controls like:

• Buttons
• Slide bars
• Status bars
• Icons

The beauty of this architecture was that... [Article ends abruptly]