For a lover of retro tech, it is a delight to watch my PiDP-8/I sit quietly on the shelf and blink its lights at me as I work in my office. Building it was very rewarding and it introduced me to a lot of historically significant software. It was a great way to understand how people computed in the 1960s and how those experiences shaped the evolution of technology through the 70s and 80s.
But the PiDP-8/I is only a simulation of a real PDP-8/I running on a Raspberry Pi. Though the blinkenlights are pretty and the switches function, none of the hardware is authentic. This is a bit ironic since the reason I ended up building the kit was because of my experiences at the Computer History Museum.
The Computer History Museum brought me close to technologies I thought I would never be able to see in person, like watching a demonstration of a real, working IBM 1401 mainframe. I went to the museum to learn about computing history and to see old hardware, but I left desperately wanting some of my own.
This led me to finding the PiDP-8/I kit. It wasn’t a 1401, but was actually much more fun given how popular PDP-8s were and how much software is still available. However the 1401 and PDP-8 did have one thing in common: core memory.
I have long been fascinated by core memory. It is not only an important part of computing history, serving as the working memory of commercial computers for over two decades, but it is also highly instructive on how a memory system works, being approachable and most importantly, visible.
It was an absolute delight after years of reading about core memory to be able to see actual core memory planes in person at the Computer History Museum. And to actually hold a vial of the ferrite rings and see just how tiny they could be was a real treat. But I just assumed that that was as close as I was going to get using core memory. But we live in a golden age of retro tech, and a gentleman in Finland is still computing like its 1970 and wants to make it accessible to all.
Jussi Kilpeläinen has put together a kit that has everything you need to build your own 32-bit plane of core memory. The kit is a mixture of old and new. The plane itself is made of vintage ferrite rings that you thread together yourself, just like a real core memory plane. Addressing is aided by modern ICs (all socketed, a nice touch) to simplify the design. It is all mounted on a Arduino which takes care of running the logic to access and power the memory. So now I have a replica of a PDP-8/I and next to it a plane of working core memory. [Insert happy geek giggle here.]
You could argue that it is the most ridiculous memory expansion for an Arduino. But it is a delight to behold and putting it together was so satisfying. It would be a fun project to somehow make the PDPs actually use the memory somehow. Maybe it could serve as the accumulator or something. Given that SimH is open source, it would be possible. But that is a project for another day.
If you have any interest at all in historic computers, especially mainframes and early minicomputers, this kit is a must-have. I found it shockingly affordable and it is a simple build.
Building Tips
The only tricky bit of this build is handling the cores to weave the plane the small amount of surface mount soldering. Both of which are overcome by simple patience and taking your time. Jussi has great instructions available, so I will only point out a few things I learned during my own build that might be handy.
Handling the Cores
Definitely have tweezers and a self-standing magnifying glass on hand to handle the cores. I knew that cores were generally made as small as possible, but I kind of assumed that the kit would come with larger ones just because they are easier to handle. Jussi kept it authentic though and these appear to be as small as you would find in 70s minicomputers.
Open the container of cores on a rubber working mat so if you spill they won’t end up everywhere. And rest assured you have enough if you do drop a few. Jussi is generous in how many he provides in the kit.
Threading the Cores
I was a bit worried that something would break as I threaded the cores, but both cores and wires robust and there was not anything to worry about provided you don’t yank and just pull gently and consistently. Jussi also provides plenty of wire if you do break it somehow. Having so much extra lets you thread more wire than you need to handle it more easily. In the end the assembly of the plane feels a bit like making a ship in a bottle with wires and tweezers all over.
Surface Mount Soldering
The wires for the plane however have to be surface soldered as well as four bridge rectifiers. If you have no experience surface mount soldering, you will need to take your time here and potentially consult a few YouTube videos.
The biggest problem with the wires is that I underestimated how long it would take to burn off the insulating enamel, so take your time when soldering these to ensure not just a good joint, but good conductivity as well. I found using a good dab of flux, holding the iron for a few seconds, and then gently pulling away along the wire instead of up yielded a good joint. Taping the wires down frees your hands to concentrate on the soldering as well.
As for the rectifiers, just take your time and double check since the pads are rather small and it can be hard to verify your joint. When I finished I found that the upper byte was not being written. I traced it back to one rectifier and it turned out to be a dry joint that needed to be reflowed.
Just Take Your Time
But these are minor issues that you just need to be aware of going in. Don’t let it daunt you! This is a simple build all-in-all that just takes time and guarantee you that you will be grinning stupidly as you handle these tiny cores and watch your serial monitor in delight as you write to your own core memory plane.
And don’t forget a small magnet so you can take a strangely large amount of pleasure in erasing the plane core-by-core.
Truly geeky fun.