February 2025, after resurrecting the Commodore 64 version of ChipWits, I turned my attention to the game’s original platform: the 1984 Macintosh 128K. ChipWits debuted on the Mac in 1984, sporting a black-and-white GUI and 400 KB disks, and was later ported to colorful 8-bit systems in 1985. Rebuilding the Mac version presented a whole new set of challenges – from resource forks and archaic disk formats to coaxing a 40-year-old Forth codebase to run on an emulator. This is the story of how we rediscovered and rebuilt ChipWits for the Macintosh 128K, honoring the original 1984 release.
Where to Start?
I had an entire archive of Macintosh disks at my fingertips (thankfully imaged from Doug Sharp’s collection) – more than a dozen 3.5″ floppies labeled with various ChipWits versions and source files. My first reaction was déjà vu: “Here we go again… where on Earth do I begin?” I knew from the C64 project that jumping straight into compilation was a recipe for confusion. So, I carefully surveyed the Mac disks and notes instead of rushing in.
One disk stood out: “CW+ Work Final Src”, which appeared to contain the final source code for ChipWits on Mac (often referred to internally as ChipWits 1.2 or ChipWits Plus). There was also a disk labeled “ChipWits 1.1 Drexel Demo” – an early 1985 demo version – and even an “Adventure Creation Disk”. Clearly, the Mac edition went through iterations: from the original 1.0 release in 1984 to a demo (1.1) and an enhanced build (1.2) by 1986. To rebuild the game faithfully, I had to identify which version to reconstruct. We decided on ChipWits 1.2, the last known Mac update, to get the most complete experience.
Unlike the C64 version, where reconstructing the development timeline was nearly impossible due to the lack of clear timestamps on the disk files, the Macintosh version offered a significant advantage: each file had both a creation date and a modification date. By comparing the modified dates of the various FORTH source files with the dates on the released ChipWits disks, we were able to compile a chronological overview of the Mac version’s development:
| Type | Name | Date |
|---|---|---|
| Release | ChipWits 1.0 | 1984-11-08 |
| Release | ChipWits 1.1 | 1985-04-16 |
| FORTH File | ChipWits (CW Work) | 1985-08-01 |
| FORTH File | ChipWits (CW 1.2) | 1986-07-21 |
| Release | ChipWits 1.2 | 1986-07-22 |
This timeline confirmed that the Mac version of ChipWits was developed in three major phases: the original release in 1984, an update in 1985, and an enhanced version in 1986. These dates not only helped us identify the correct version but also provided valuable insight into how Doug and Mike refined their work over the years.
But unlike the C64 case, where a SuperForth environment was needed, ChipWits on Mac was developed in MacForth Plus. That meant I couldn’t use modern tools directly – I had to step into the shoes of a 1984 Mac developer. Before touching any code, I gathered the original manuals, read up on MacForth’s quirks, and set up a tiny virtual 128K Mac to experiment. It was time to go back to 1984.
Macintosh 128K vs Commodore 64: A Tale of Two ChipWits
Rebuilding ChipWits on the Mac really drove home how differently the game was implemented on these two platforms. On the surface, the Mac and C64 versions of ChipWits are the “same” game – same robot programming concept, same puzzles – but under the hood they diverged to fit their hardware:
- Memory & Performance: The original Mac had 128 KB RAM and a Motorola 68000 CPU at 8 MHz, whereas the C64 had just 64 KB and a 1 MHz 6502 CPU. Doug and Mike took advantage of the Mac’s extra memory and speed, whereas on the C64 they had to squeeze the game into half the RAM and work around a much slower processor. Rebuilding the Mac version meant appreciating the more generous memory – our build didn’t need the clever memory-swapping tricks that the C64 version used to fit in 64K.
- Storage & Media: ChipWits on Mac shipped on a single 3.5″ floppy (400 KB initially, later 800 KB), while the C64 version came on a 5.25″ disk (~170 KB usable). The Mac’s larger disk and hierarchical filesystem allowed the game to have multiple files (code, graphics, etc.), whereas the C64’s disk was packed with raw Forth “screens” in a single continuous image. In our rebuild, this meant dealing with Mac file structures instead of a flat D64 image – a new adventure in file handling.
- User Interface: The Macintosh interface is GUI-based – ChipWits on Mac used real menus, windows, and the mouse. In fact, on a Mac you navigate menus like Workshop, Environments, Options via the menu bar at the top of the screen. By contrast, the C64 had no native GUI, so the developers improvised a menu system controlled by the joystick. Our Mac rebuild thus had to ensure the original Mac GUI elements (like menus and dialog boxes) were preserved. Would they even still work in an emulator? (Spoiler: yes, they do!)
- Audio & Graphics: The 1984 Mac had only simple beeps for sound and a 1‑bit black-and-white display; the C64 boasted a SID sound chip and color graphics. ChipWits on Mac is a quiet affair with monochrome pixel art, while the C64 version added music, sound effects, and colorized icons. In rebuilding the Mac version, we got to see the original monochrome art exactly as it looked in 1984 – a nostalgic throwback, and a stark contrast to the C64’s pizzazz. (Fun fact: the lack of Mac sound hardware meant the C64 port actually had richer audio than the original Mac game!)
Despite these differences, both versions share their gameplay logic, thanks to being written in FORTH. The core robot AI code and puzzle logic in 1984 were ported quite directly from MacForth to SuperForth64 the following year. This cross-platform commonality was what we banked on – it meant the Mac source code, if recovered, could be understood using what we learned from the C64. Still, we had to navigate the unique Mac details to make that FORTH code run again on a modern machine.
Forks in the Road: Resource Forks vs Data Forks
One technical hurdle that loomed large was the classic Mac file architecture – resource forks and data forks. If you haven’t dealt with pre-OS X Macs, here’s the gist: each file can have two parts: a data fork (raw data, like the text of a document) and a resource fork (structured data like menus, icons, and even code). ChipWits’s Mac files definitely take advantage of this. For example, the ChipWits application (when built) likely stored its GUI resources and maybe some Forth dictionary segments in the resource fork, while using the data fork for other parts.
Why is this important? Well, when recovering the source from old disks, if you copy files incorrectly on a modern system, you might grab only the data fork and lose the resource fork, effectively halving the file – a corrupt copy that won’t run. We had to be extremely careful in how we extracted and handled the Mac files. Our strategy was to avoid copying individual files altogether and instead work with disk images as a whole (so both forks stay intact in their original environment).
This approach paid off when dealing with the ChipWits source code file itself. The source was stored as a series of Forth “blocks” in a MacForth format. Was that a data fork, a resource, or both? It turns out MacForth uses a document (the “Blocks” file) to store the source code, and the MacForth compiler application expects that structure to be preserved. By keeping the entire disk image, we ensured that things like the MacForth file type, creator codes, and any embedded resources remained as they were in 1986. I can’t overstate this: one wrong move with extracting the file and the MacForth compiler would simply refuse to recognize the ChipWits code. (I admit, I learned this the hard way initially when an early copy attempt yielded a 0-byte file because its data was all in the resource fork – oops!)
In practice, once I set up the emulated Mac, the resource vs data fork issue faded – inside the emulator, System 2.0 on a Macintosh Plus handled the files exactly as the original would. But getting to that point meant using the right disk image formats…
Taming Old Mac Disk Formats
Reading and restoring mid-1980s Macintosh disks turned out to be an adventure in retrocomputing. The original 1984 Mac used the Macintosh File System (MFS) – a flat file system with no folders – but Apple introduced the Hierarchical File System (HFS) in early 1986 to support larger disks and hard drives. HFS allowed true folders, subdirectories, and better scalability. But here’s the catch: Macintosh 128K and 512K models couldn’t read HFS volumes at all. HFS only became usable with the Macintosh Plus, which had a new 128K ROM and support for 800 KB floppies — making it the first Mac to natively support both MFS and HFS disks.
This detail turned out to be crucial for our project. While ChipWits originally launched in 1984, the version we were restoring — ChipWits 1.2, finalized in July 1986 — was clearly built and distributed using HFS-formatted 800K floppies. That meant we couldn’t rely on a strict Macintosh 128K emulator to access the recovered game disks. We needed to emulate a Macintosh Plus or newer, or else the disks would fail to mount altogether. In fact, one giveaway was the presence of a folder called “CW Folder” inside the disk image — a structure only possible on an HFS volume.
Thankfully, the original source disks had been carefully preserved. John K. Morris, creator of the AppleSauce Disk Imaging System, was instrumental in recovering the physical media. Using specialized AppleSauce hardware and software, he created flux-accurate images of the original floppies — capturing them in .a2r (AppleSauce Raw) format, which we later converted to the more widely used .dc42 format. These images weren’t just file-level copies: they preserved every sector, checksum, and layout detail, exactly as stored on the original Mac disks. For projects like ours, that level of accuracy was essential.
To use those images with an emulator, we turned to Mini vMac and the browser-based Infinite Mac, both of which emulate vintage Macintosh hardware faithfully. One small but important quirk: Infinite Mac expects disk images to use the “.image” extension. So we simply renamed the .dc42 files to .image, and the emulator accepted them without a hitch. With the right version of System Software (we used System 2.1), we booted into a virtual Mac Plus, dropped in the HFS-formatted ChipWits disk image, and — just like that — the CW Folder appeared on the desktop.
From there, it was easy to open MacForth, load the source blocks, and rebuild ChipWits v1.2 as if we were sitting at a Mac in 1986. Even better: all of this happened inside a modern browser.
In the end, restoring ChipWits wasn’t just about code — it was about understanding and respecting the media it lived on. We dealt with MFS vs HFS quirks, made emulator choices based on disk format support, and worked with disk images that were recovered at the bit level using specialized preservation tools. We owe a special thanks to John K. Morris for making those images possible — without his careful imaging work, this version of ChipWits might have stayed lost on aging floppies. Instead, it runs again, clean and crisp, like it’s 1986.
Rebuilding ChipWits in an Emulator (Infinite Mac to the Rescue)
To compile ChipWits for the 128K Mac, I needed a Mac environment that matched the era. After some research and trial, I found Mini vMac and the excellent Infinite Mac browser emulator. Infinite Mac provided a ready-to-go System 2.1 (circa 1985) Mac Plus setup – perfect for our needs. Here’s how I used it to rebuild the game within a virtual vintage Mac:
1. Booting up a 1985 Macintosh: I started the System 2.1 emulator which greeted me with the familiar grey desktop and Finder menus. This virtual Mac had a “System Disk” and some tools preloaded. It’s astonishing to realize this OS fits in just a few hundred kilobytes! Once the Mac was up and running (with 512K emulated RAM for stability), I was looking at a screen that could have been on a real Mac Plus in the mid-80s.
Inside the Infinite Mac emulator: a Macintosh Plus running System 2.1 (1985). This environment simulates the 68000 CPU, 400K/800K floppy drives, and original Mac OS – essential for compiling the MacForth source.
2. Loading the Source Disk: I took our preserved disk image containing the ChipWits source code (the one named “CW+ Work Final Src”) and dragged it into the emulator’s window. Infinite Mac makes this incredibly easy – it treats the dragged file as if I inserted a floppy. The disk icon appeared on the Mac desktop, and I opened it to reveal the “CW Folder”. Sure enough, there were the files exactly as Doug and Mike left them in 1986: the ChipWits Forth blocks file, MacForth compiler apps, utilities, etc.
3. Compiling with MacForth: To my delight, rebuilding was mostly a matter of double-clicking the “ChipWits” source file. This invoked the MacForth Plus compiler (the file type was associated, so it launched MacForth automatically). MacForth loaded the ChipWits blocks and began compiling the Forth code right inside the emulator. Lines of Forth flashed briefly, then the screen went mostly blank while the compiler churned through the code. This step took a couple of minutes – the emulator was effectively simulating all the 68000 instructions to compile thousands of Forth words. Eventually, MacForth finished and printed the magic word “ok” at the bottom of its window.
At this stage, we had essentially built the program in memory. The question was how to run it. On the C64, we ended up with a binary we could just RUN. On the Mac, the code was now sitting in MacForth’s environment. The build instructions from the 80s weren’t explicit (this is where some guesswork came in), but I found that simply switching out of MacForth triggered the game. By clicking on the background (i.e. returning to the Finder) and then back into MacForth, the ChipWits application took over and launched. In other words, the compiler had effectively turned into the running game when it was done – voila! ChipWits sprang to life on the emulated screen.
4. Running ChipWits on Mac: The result of the compilation is the ChipWits game running natively in that virtual 1985 Mac. I was greeted with the title bar “#3 in Greedville” and the familiar grid with my little robot, exactly as players in 1984 would have seen. The menus (Warehouse, Workshop, Environments, Options) were functional, the mouse controlled the cursor, and I could play the game! We had successfully built what appears to be ChipWits v1.2 for Macintosh – likely identical to the final version Doug and Mike worked on.
A quick note on version numbering: The in-game screens don’t explicitly say “1.2”, but given the file dates and the label of the disk, we’re confident this is ChipWits 1.2. I’m still working on confirming via byte-level comparison to an original 1.0 disk (should we recover one – more on that in a moment). Regardless, the game is running with all features, and no obvious differences in gameplay were noticed compared to the known 1.0 release. It’s incredibly satisfying to see the original Mac edition running after all these years.
Hacking the Game: Editing In-Game Text via FORTH
One delightful aspect of having the FORTH source code is that we can tweak the game and see changes immediately. In fact, we wanted to test how a player or hobbyist could modify ChipWits – say, to change some in-game text – using the restored source. Here’s a quick walkthrough we came up with (for those brave enough to play time-traveler programmer):
- Load the ChipWits source disk in the Mac emulator, as described earlier (remember to rename it to .image), but don’t compile it yet. Instead of double-clicking the ChipWits file straight away, first open the MacForth application itself (the compiler program).
- Double-click K3.4D- to launch the MacForth Plus environment.
- Enter your initials when prompted. This initializes the MacForth session.
- Load the ChipWits source by typing
USE" ChipWits"in the MacForth command line. This command loads the ChipWits blocks file into the environment. - Select the block to edit by typing
1 SELECT. This command opens the first block of the source code. - Edit the desired block by typing
73 EDIT. This opens block 73 in the editor, where you can make changes. For example, locate the text “Ready when you are.” and replace it with your desired string. - Save your changes by selecting
Edit > Stampand thenEdit > Exit Edit. This ensures the block is updated and saved. - Exit MacForth by selecting
Options > Exit MacForth. This returns you to the Finder. - Run the updated ChipWits by double-clicking the ChipWits application Block file. Your changes should now be reflected in the game.
This little experiment proved how accessible the game becomes once you have the source and a proper environment. Editing text, changing levels, or even altering robot behaviors could be done by anyone following similar steps. In the 1980s, Doug and Mike themselves likely used MacForth’s editor to refine gameplay elements – now we can step into their shoes. The process gave us a newfound appreciation for the interactive nature of FORTH: the ability to modify and rebuild on the fly, even on original hardware constraints, is pretty empowering.
(Curious readers: all the original FORTH source code for Mac ChipWits is available in our GitHub repository, converted to a text listing for browsing. Take a peek if you want to see how things like Electrocrabs or I/O boards were coded in 1984!)
Next Steps: From Retro Rebuild to ChipWits Classic
Rebuilding ChipWits on the Mac 128K has been a rewarding trip down memory lane. Now that we have ChipWits running on its original platforms – Mac, C64 (and hopefully Apple II someday) – our goal is to carry this legacy forward. The next big step is to create ChipWits Classic: a version of the game that runs on modern systems natively, using the recovered FORTH code as a reference. Essentially, we want the best of both worlds – the authentic gameplay and logic of the 1984–85 ChipWits, but without requiring an emulator to play.
How will we do that? One approach under exploration is to use a modern FORTH environment or cross-compiler to transpile the old code, or even to write a ChipWits emulator in a contemporary language that reads the original game data. That’s a project for another blog post, but suffice it to say, having the nearly complete source code puts us in a great position to revive ChipWits for a new generation of players.
Before closing, I’d like to express my gratitude to a few key people who made the Mac restoration possible. Ward McFarland provided crucial help in deciphering some of the MacForth technical hurdles. Mark Simonson, a long-time Macintosh fan who had saved several original MacForth disk images all these years, reminded us why preserving software history matters. Mark Roth shared a crucial coding example that helped us better understand MacForth’s nuances. And John K. Morris, whose expertise with AppleSauce imaging ensured the original disks were preserved with incredible accuracy, played a vital role in making this restoration a success.
With the Macintosh version rebuilt and verified, we’ve come full circle back to 1984. It’s been a joy to honor the work of Mike Johnston and Doug Sharp by making their original Mac implementation accessible again. If you love retrocomputing or have memories of the original Mac, we hope this journey inspires you to dig into the code or even fire up an emulator to play a few rounds of ChipWits. Stay tuned as we continue our adventure by bringing ChipWits Classic to life on today’s machines. Until then, happy hacking – and as the original manual says, “May all your ChipWits obey your commands.”
Thank you for reading! Stay updated on all things ChipWits by subscribing to our newsletter, following us on Mastodon or BlueSky, and joining the conversation on Discord. We’d love to hear from you!