De Origine Cocoa

I.The Argument for Excavation

There is a kind of knowing that only comes from sitting in front of a system rather than reading about it. The Cocoa frameworks you use today — NSObject, NSView, the .nib file format, Interface Builder, the Objective-C runtime, the message-passing object model — were not invented by Apple. They were inherited. The genealogy is well documented: NeXTSTEP became OPENSTEP, OPENSTEP became Rhapsody, Rhapsody became Mac OS X, Mac OS X became macOS. Every text on the subject says so.

What no text can give you is the particular shock of opening Project Builder on OPENSTEP 4.2 and finding it already familiar — the same Interface Builder you used last week, only running on a Mach kernel from 1996, rendering through Display PostScript, on a beige-fonted system that predates the iMac. The lineage is not a museum. It is an inheritance you can boot.

This document is an excavation. Its premise is that emulation has finally caught up with the question. The M-series Macs run PowerPC, 68k, and Intel targets under QEMU well enough that the entire genealogical line of Apple's platform — and the road not taken at AmigaOS — fits comfortably on a developer's machine. What was historical claim two years ago is now a live artifact you can run side by side. The exercise that follows is therefore less a tutorial in the usual sense and more a workshop for reading a tradition by handling its instruments.

What you should expect to come away with: a tactile understanding of why Cocoa class names begin with NS; what Display PostScript was and what it cost when Quartz replaced it; what the Yellow Box and Blue Box names actually meant; why the .nib file format is shaped the way it is; and what a preemptive multitasking microkernel looked like in 1985, on a 7 MHz processor, when Apple was still cooperatively scheduling.

II.The Lineage

The diagram below is the working map of this excavation. Three lanes: the NeXT line that became Apple's modern frameworks, the Apple Classic line that ended at Mac OS 9 and survived through the Carbon bridge, and the Amiga line that ran in parallel and never converged. Hover any node to read what running it teaches.

III.The Workshop

Two tools cover almost everything ahead. The first is QEMU, the open-source machine emulator that handles 68k, PowerPC, and x86 targets credibly on Apple Silicon. The second is UTM, a friendly macOS frontend for QEMU that handles VM lifecycle, disk images, and configuration without the command-line ceremony. Install one of them; the rest of this document assumes either is in place.

# the friendly path
brew install --cask utm

# the bare-metal path
brew install qemu

A note on hardware. Your M-series machine will run every system in this document well — emulation today is largely CPU-bound and single-threaded for these targets, and the M-class cores are excellent at the workload. The discrete GPU on the workstation node contributes nothing here; this is a job for the silicon already in your laptop. Expect 256–512 MB of guest RAM and 2–4 GB disk per VM, generously.

On ROMs and licensing treated honestly

The legal reality is that Apple has never released the ROMs or installers for most of these systems, with one significant exception: Apple released System 7.5.3 as a free download in 1996 and that release remains available in archived form. PowerPC-era Mac ROMs are not freely distributed; the workable path is to dump them from period hardware you own, or to acquire SheepShaver-compatible builds from sources you trust. The Amiga path is cleaner because Cloanto's Amiga Forever sells legal Kickstart and Workbench ROM bundles for a small fee — by far the path of least resistance for that branch.

NeXTSTEP, OPENSTEP, and Rhapsody installers were sold by NeXT and Apple respectively and are no longer commercially available. They circulate. The judgment is yours.

IV.NeXTSTEP & OPENSTEP

Begin with OPENSTEP 4.2 on Intel, released by NeXT in 1996 — the version Apple acquired in December of that year and that became the foundation of everything that followed. The earlier 68k NeXTSTEP releases on the original cube hardware are charming and worth seeing through the Previous emulator, but the Intel build is what you want for the formation point. It runs comfortably under QEMU.

What you are looking at

Once it boots, open Project Builder and Interface Builder from the dock. Take a moment with what you see. The .nib file format you serialize today, the connections panel, the inspector, the way Interface Builder treats a window as a serialized graph of objects — all of it is here, on this disk, in 1996. The class browser will list NSObject, NSString, NSView, NSWindow, NSResponder. The NS prefix is not a stylistic choice. It stands for NeXTSTEP, and the classes themselves are not ancestors of the ones you import in Xcode tomorrow — they are the same classes, evolved in place across thirty years.

Display PostScript is the second thing to sit with. Quartz, the graphics layer in every Mac and iPhone you have ever used, is the descendant of Display PostScript with PDF as the imaging model rather than PostScript. The decision to swap the language but keep the device-independent imaging model is one of the cleaner architectural inheritances in Apple's history. You can see why they kept it once you have rendered a window through the original.

qemu-system-i386 \
  -m 256 \
  -hda openstep-4.2.qcow2 \
  -boot c \
  -net nic,model=pcnet -net user \
  -display cocoa

V.Rhapsody — The Missing Link

If OPENSTEP is the inheritance, Rhapsody is the moment of acquisition. Released as developer previews from 1997 through 1999, Rhapsody was Apple's first attempt to ship NeXT's frameworks as the operating system going forward. It looks like Mac OS — Platinum theme, Apple menu, familiar window chrome — but underneath it is OPENSTEP with the serial numbers filed off. The two boxes on screen, the Yellow Box and the Blue Box, are the architectural decisions that shaped the next twenty-five years of Apple development.

Yellow Box and Blue Box

Yellow Box is the OPENSTEP framework set — what would become Cocoa once Apple got the marketing right. Modern, object-oriented, the place new applications were supposed to live. Blue Box is a virtualized environment running classic Mac OS inside Rhapsody — the path for legacy Mac applications. It is, conceptually, the same trick Apple used with Classic on Mac OS X, with Rosetta on Intel, with Rosetta 2 on Apple Silicon, and with Mac Catalyst on the desktop today. Rhapsody is where Apple discovered that the trick was unavoidable.

The lesson Apple took from Rhapsody — and the reason it never shipped as a production OS — was that asking Mac developers to abandon their toolbox-era code and rewrite in Yellow Box was politically and economically untenable. The Macworld 1998 keynote where this strategy publicly cracked is well documented. What replaced it was Carbon: a procedural C API that exposed enough of the Mac toolbox to let Photoshop and Office port forward without the rewrite. Carbon shipped in Mac OS 9 first as a way to forward-port apps to the new world, and it survived in Mac OS X for over a decade. This is the welded seam, and you can see it forming in Rhapsody DR2 if you look carefully.

DR2 (Developer Release 2) is the most documented build and the one to start with. It runs on QEMU's PowerPC target. The Intel x86 builds are rarer but they exist, and they are easier to virtualize on Apple Silicon if you find them.

VI.Mac OS 9 — The Toolbox World

Where the NeXT lineage gives you the modern object world in archaic form, Mac OS 9 gives you the world that Apple had to leave behind — and yet did not, quite, leave behind. The cooperative multitasking, the bitmap-based QuickDraw rendering, the resource fork as a first-class file system feature, the Toolbox APIs in their procedural Pascal-derived form. Carbon was the bridge that carried as much of this forward as could be salvaged. Knowing what Carbon had to bridge means knowing this system.

Two emulators cover the territory. SheepShaver is the established option for Mac OS 7.5 through 9.0.4, requires a New World Mac ROM, and is reasonably stable. For 9.1 and 9.2.x — the last and best classic releases — QEMU's PowerPC target with the mac99 machine type is the path. UTM has a Mac OS 9 template that handles most of the configuration for you.

What you are looking at

Boot, and you are looking at the world of HyperCard, of ResEdit, of AppleScript in its native context, of QuickDraw GX, of the Finder before it learned about NSApplication. The bitmap-region selection in the Finder — the way you can lasso a non-rectangular set of icons — is rendered through QuickDraw regions, a data structure that has no clean equivalent in modern Apple frameworks. Carbon preserved most of QuickDraw forward, but the regions never quite came along; HIShapeRef in modern Carbon is a dimmer shadow.

VII.AmigaOS — Excursus, the Road Not Taken

The Amiga branch is included not because it influenced Apple — it did not — but because it is the most useful counter-point in the genealogy. In 1985, on a 7 MHz Motorola 68000, AmigaOS shipped preemptive multitasking, message-passing interprocess communication, a logical-name file system through the ASSIGN command, and a windowing system with hardware sprite acceleration. Apple would not ship preemption on the Mac for sixteen more years.

The Amiga's technical lead did not translate into developer ergonomics, sustained platform investment, or commercial survival. What it did do was demonstrate, in shipping form, what a different set of architectural priorities looked like. Running AmigaOS today is therefore a useful exercise in counterfactual reasoning — what could the personal computer have been if message-passing kernels and asset-reuse-by-name had become the cultural defaults.

What to run

For Classic AmigaOS (1.x through 3.9), FS-UAE on macOS is excellent and well-maintained. WinUAE is the more powerful sibling on Windows and runs under emulation on Apple Silicon if you want the better tooling. For modern AmigaOS 4.x — Hyperion's PowerPC continuation — QEMU's PowerPC machine types do work, with effort. MorphOS is a parallel-track PowerPC AmigaOS-compatible system; AROS is the open-source reimplementation that runs natively on x86. Cloanto's Amiga Forever is the canonical legal source for ROMs.

1. Install FS-UAE via Homebrew: brew install --cask fs-uae and the launcher.
2. Acquire Kickstart and Workbench ROMs through Amiga Forever.
3. Boot to Workbench 3.1 and open a Shell. Type STATUS to see the running tasks. Note that they are tasks, not threads, and that they are scheduled by the kernel rather than yielding cooperatively.
4. Type ASSIGN with no arguments. Read the list of logical names. Sit with what asset-resolution-by-name affords that path-by-convention does not.

VIII.The Closing Exercise

When the four virtual machines are configured and saved as snapshots, the exercise is to run them simultaneously on a single screen and perform the same task in each: open a text editor, type a paragraph, change the font, save the file. Watch yourself do this. Watch what each system requires of you, what it offers, what it makes hard.

OPENSTEP gives you Edit.app, a Cocoa-precursor application using the same text system that powers TextEdit on your modern Mac. Mac OS 9 gives you SimpleText, rendering through QuickDraw, with fonts addressed through the Font Manager that Carbon had to preserve. Rhapsody gives you both, in the same OS, in two different windowing environments stitched together. The Amiga gives you ED or MEmacs, with text rendered through the bitmap layer that the Copper coprocessor was helping to compose in real time.

The same task, four times. The differences are the formation. What you cannot get from reading is the felt knowledge of which decisions Apple kept, which it discarded, which it papered over with a compatibility layer, and which it had no choice about. That knowledge changes how you read the modern frameworks — what looks arbitrary becomes legible as inheritance, what looks elegant becomes legible as decades of work to keep something else working underneath.

When you have done this once, the exercise can be repeated at greater depth. Build a small application in OPENSTEP and port it forward — DR2 first, then Mac OS X 10.0, then a modern Xcode. The frameworks change, but less than you would think; the gestures are continuous; the Cocoa you write today is the same craft you wrote here, with thirty years of accreted wisdom about what to keep stable.

The lineage is not a museum. It is an inheritance you can boot, and the practitioner who has booted it reads the modern platform with different eyes.