Background

Around mid-2020, as I surveyed the collection of 8-bit and 16-bit retro-computers from the 1980's that I'd amassed in the previous 5 years, I started to contemplate which of these lovely machines might find a home on my desk, rather than in my closet. I liked all of them, each having their unique charms and memories, but I wanted this hobby to be about enjoying them, rather than collecting them. I needed a new project.

Of the 8-bit machines, it was the Commodore 64 for which I had the greatest affinity, having grown up with one in my home. I had acquired many cool modern add-ons for the C64, which I thought was particularly amazing...proof that others really wanted to USE their retro-computers. This was the same time when I was wanting to also scratch an old itch over learning some hardware design skills.

After some contemplation, I settled on learning about the machine I never got to know in the 1980's - the Commodore 128. Sure, I knew it's basic features and that it made a really nice upgrade to my C64. But, by early 1986 I'd already embraced the thrills (and chills) of becoming an early Amiga adopter. So I sorta missed one of the best 8-bit machines ever made. Time to remedy that, I thought.

Inspiration

As I thought about connecting my C128 to my modern computing life, many things seemed obvious. I wanted the retro-internals, but not the device limitations of the C128. Floppy disks were novel to use occasionally, but normal file management needed modern media and fast access. Also, networking was essential. It at least needed to talk to my LAN, if not the broader Internet too. I started imagining about a dozen virtual devices that I'd like to be able to access from C128 software using some simple, efficient, 8-bit friendly protocol. This led me to develop an I/O multiplexer as a Rust application running on a Raspberry Pi. I was also new to Rust as a programming language at this time, and that fascination ensured Rust would also become part of the project. I wrote test code for my protocol, and prototyped it communicating with the C128 over a low-speed serial connection.

Another limiting factor was that I was not at all proficient in programming in 6502 assembly language. So where would the essential applications come from? It's simple enough to learn the 6502, but to write large and useful applications with it is a whole separate skill to hone. I needed a jumping off point to help me build something useful for my project as I worked on my proficiency. That turned out to be ACE-128. ACE ("Advanced Computing Environment") was a project of Craig Bruce in the mid-1990s to create a suitable operating system for the C128, and one that was worthy of its advanced features. What he created inspired me because it was nice, clean 6502 code that was well-organized and documented. It made sense to me, and was a great jumping off point. I knew almost immediately I could add modules to it to realize the vision of it talking to my I/O multiplexer; making modern device connectivity accessible on my C128.

Development

I was already having great fun improving my Rust and assembly proficiency when I got serious about the hardware piece. I briefly considered a direct interface to a Raspberry Pi Zero, but deemed it too costly in terms of losing much of what makes the RPi a great little computer, in its own right, and adding software complexity in adapting everything to some bare-metal development platform. I mean, would my beloved Rust programming language even be there, let alone a full set of reliable device drivers, if I ditched Linux? I decided to stick with Linux and just customize a bare bones Arch Linux ARM that would be infinitely expandable if a user wanted to add additional software to it. The first thing I wanted to add myself was the "acme" 6502 cross-assembler, so that I could build the idun-cartridge software ON THE idun-cartridge.

So I'd need something to interface between the RPi and the C128 expansion...