MoofStationManual
A classic Macintosh emulator for macOS, written from scratch: the 68000 family of processors, their memory buses and their chips, modelled rather than wrapped around somebody else's emulator.
Contents
- Installing
- ROMs
- The machines
- Disks
- Using the machine
- Settings
- What is and isn't emulated
- When something goes wrong
- Thanks
- Building it yourself
Installing
MoofStation needs macOS 14 or later and runs natively on both Apple silicon and Intel Macs. It has no dependencies beyond macOS itself — nothing to install, no Xcode, no runtime.
Drag MoofStation.app anywhere and double-click it.
The application and the disk image it arrives on are both signed with a Developer ID and notarised by Apple, and each carries its notarisation ticket stapled to it — so macOS checks them and lets them open without comment, and does so on a Mac that is offline as readily as one that isn't.
macOS may still ask you to confirm, once, that you mean to open an app downloaded from the internet. That prompt is the ordinary one every download gets, and clicking Open is the end of it.
ROMs
Every Macintosh model is defined by its ROM, and MoofStation can't emulate a machine without one. ROMs are Apple's copyrighted code and are not included — you provide your own.
MoofStation looks for a ROMs folder in these places, in order, and uses the first that has anything in it:
- Next to
MoofStation.app ~/Library/Application Support/MoofStation/ROMs~/Documents/MoofStation/ROMs
Or point it anywhere you like in Settings, which also shows which folder is currently in use.
If you keep ROMs or disk images in Desktop, Documents, Downloads or iCloud Drive, macOS will ask once for permission to read that folder — that's macOS's own file-access protection, not something MoofStation decides. Keeping them next to the app avoids the question entirely.
Inside it, ROMs are filed by size:
| Folder | Machines | ROM |
|---|---|---|
64KB ROMs/ | Mac 128K, Mac 512K | 64KB |
128KB ROMs/ | Mac Plus | 128KB |
256KB ROMs/ | Mac II, Mac SE/30 | 256KB |
512KB ROMs/ | Mac IIci | 512KB |
If a folder holds several ROMs, ROMs/roms.json says which one each machine prefers, matching on the filename. Settings lists what it found and whether each file's checksum is one it recognises.
The machines
| Machine | Processor | Screen | RAM |
|---|---|---|---|
| Mac 128K | 68000 at 7.8MHz | 512×342, black and white | 128K |
| Mac 512K | 68000 | 512×342 | 512K |
| Mac Plus | 68000 | 512×342 | 1, 2, 2.5, 4MB |
| Mac II | 68020 + 68881 at 15.7MHz | colour card, up to 640×480 in 256 colours | 1, 2, 4, 5MB |
| Mac SE/30 | 68030 + 68882 at 15.7MHz | 512×342, built in | 1, 2, 4, 5, 8, 16, 20, 32MB |
| Mac IIci | 68030 + 68882 at 25MHz | colour card | 1, 2, 4, 8, 16, 32, 64MB |
Only sizes verified to boot are offered. Changing the machine or its RAM restarts it.
The Mac II and IIci drive a colour video card; Monitors in the control panel switches depth between black and white and 256 colours. The SE/30's screen is built into the case, so there is nothing to choose.
Disks
Floppy images — DiskCopy 4.2 (.image), raw sector dumps (.dsk, .img) at 400K, 800K or 1.4MB.
Hard disk images (.hda, .dsk, .img) with an Apple partition map, or a bare HFS volume. Attach one in Settings; it becomes the machine's startup disk.
CD-ROMs (.iso, .toast, .cdr) mount read-only. Mac discs carry an HFS volume, including the hybrid discs that also hold an ISO-9660 track for PCs, and those mount from their Mac side. A disc with only ISO-9660 on it can't be mounted — a real Mac reads those through Apple's CD-ROM extension and Foreign File Access, which MoofStation doesn't provide, and it will tell you so rather than failing obscurely.
The machine has two drives, and everything shares them. A hard disk attached in Settings takes the internal drive when no floppy is set, and the external drive otherwise — it has to be in a drive when the machine starts, because the ROM only registers drives that hold something at that moment. A CD goes in the external drive too, so inserting one displaces whatever was there. The indicators always name what is actually in each drive rather than what was configured.
Disks can be swapped while the machine runs. Put one in and it mounts, as it would on the real thing. A machine sitting at the blinking disk icon will start from a disk inserted then, with no need to reset.
Writes are real. Anything the emulated Mac saves goes back to the disk image it came from, so work done inside survives being switched off — which also means the emulated Mac can damage a disk image the same way a real Mac could damage a real disk. Keep a copy of anything you care about, and note that a disk left mounted when the emulator is force-quit may not have had its final housekeeping written.
Discs are the exception: a CD is read-only, and the machine is told so properly, so it marks the volume locked rather than deciding the disc is faulty.
Ejecting is the mechanical kind — the paperclip in the hole. A System that still has the volume mounted will ask for the disk back, exactly as it would have then.
Using the machine
The keyboard and mouse go to the emulated Mac while its window is focused, including ⌘-key combinations: ⌘Q quits the application inside the emulator, not MoofStation. Use its own menu bar to quit.
In the File menu:
| New Blank Disk… | a formatted, empty 400K, 800K or 1.4MB floppy |
| Save State… / Load State… | freeze the whole machine to a file and restore it (⌥⌘S, ⌥⌘L) |
Below the screen, alongside the disk buttons:
| Reset | restart the machine, keeping its disks in their drives |
| Full Screen | the emulated screen, scaled, letterboxed in black |
The indicator lights show each drive's contents and blink on access.
Settings
Machine — which Mac, and how much memory. Both restart the machine.
Speed — the processor's clock. Each machine defaults to its real one; raising it makes the emulated Mac genuinely faster, and everything timed follows, so the cursor blinks and the clock ticks faster too. "Unlimited" runs as fast as your Mac can.
Screen — for the Mac II and IIci, which monitor the video card is driving and how deep its default mode is.
ROMs — which folder to look in, and what was found there.
Hard disk — an image to attach at startup, or none.
What is and isn't emulated
Faithfully: the 68000, 68020 and 68030 processors including their addressing modes and exception frames; the 68881/68882 floating-point unit; the 6522 VIAs and their timers at the real 783.36kHz; the real-time clock and its parameter RAM, which persists between launches like a Mac with a good battery; ADB for keyboard and mouse; the IWM and SWIM floppy controllers as far as their drives' sense lines; NuBus video with a synthesized declaration ROM and a driver; the 68030's MMU as the address map classic Mac OS actually uses it for.
Sound: the compact Macs' DAC, reading its buffer out of RAM a byte per scanline, and the Mac II family's Apple Sound Chip in both of its playing modes — the FIFO the Sound Manager pours samples into, and the four-voice wavetable the ROM uses for the startup chime. The chip's half-empty interrupt reaches the processor through VIA2 the way it should, so software that refills on interrupt works.
Not emulated: SCSI. Hard disks and CDs are served by intercepting the .Sony driver's entry points instead, so the volumes are real and behave correctly, but there is no SCSI bus underneath them. Nor is AppleTalk, or the serial ports beyond what the ROM's own diagnostics need.
Known gaps: the Mac II won't take 8MB — its memory sizing runs in 32-bit mode before the address translation folds the map, which its decode here doesn't model. The SE/30 won't take 64 or 128MB, where the ROM's table of legal sizes disagrees with the bank sizes the same ROM enumerates. Both are understood rather than mysterious, and neither affects the sizes offered.
When something goes wrong
A blinking floppy with a question mark — the machine has no startup disk. Insert one; it will start from it.
A "sad Mac" or a bomb box — the emulated System has crashed, the way it would have then. Reset. If it happens reproducibly with a particular disk, that's worth reporting.
The screen is frozen but the app is responsive — the emulated machine is wedged. MoofStation watches the Mac's own tick counter and, when that stops while the processor is still running, writes a diagnostic to the console naming the addresses it is stuck in. Reset, and send that along if you're reporting it.
"No ROM for the …" — MoofStation found no ROM for the machine you chose. The message names the folder it wants and where it looked. See ROMs.
A machine won't boot from a disk that should work — check the disk is for that machine. A System 7.5 disk needs a Mac II or later; System 1 through 6 will run on anything.
Everything is slow — check the speed setting hasn't been lowered, and note that a machine emulating a 25MHz IIci asks considerably more of your Mac than one emulating an 8MHz Plus.
Thanks
MoofStation is written from scratch — the processors, the buses and the chips are modelled here rather than wrapped around somebody else's emulator — but almost none of it would have been possible without two projects that got there first and wrote down what they found.
Mini vMac is the reason the compact Macs work. Its source is the clearest account anywhere of how the IWM's sense lines are multiplexed, what a Mac keyboard actually sends, how the mouse reaches the operating system through low memory, and which VIA signal is wired to what. Where this emulator disagreed with a real machine, Mini vMac usually explained why.
MAME and its Macintosh drivers are the reason the Mac II, IIci and SE/30 work. The RBV, the Apple Sound Chip, the ADB transceiver, the memory controller's bank sizes and mirroring, and the interrupt levels were all checked against MAME's devices, and its drivers settled more than one argument with the ROM.
Both are cited in the source at the points where they were consulted. No code was taken from either; what was taken was the hardware knowledge their authors dug out, and this project is grateful for it.
Building it yourself
MoofStation is a Swift package. With a Swift 6 toolchain:
swift build # library and a bare executable
swift test # the test suite
Scripts/build-app.sh # MoofStation.app, universal, ad-hoc signed
Scripts/build-app.sh --install # …and copy it to /ApplicationsThe test suite is not only unit tests: it boots real ROMs from real disk images and checks the resulting desktop pixel for pixel, which is how changes to the processor or the buses are kept honest.