Modular Z80 Really Racks Up The Retrocomputer Cred

Very few retrocomputing projects are anything other than a labor of love. There’s really no practical reason to build a computer that is woefully inadequate for just about any task compared to even an entry-level PC today. But the lack of a practical reason to do something rarely stops a hacker, as with this nifty modular Z80-based rack computer.

Actually, there’s at least one area where retrocomputers excel compared to their modern multi-core gigahertz counterparts — and that’s nostalgia. That’s what [Ricardo Kaltchuk] was going for with his build, which started by finding a Z80 and an Intel 8251 USART in his parts bin. Those formed the core of what would become the “Proton” computer, a modular beauty built around 7 cm by 10 cm PCBs that plug into a backplane inside a rack made from aluminum angle. Aside from the power supply and the Z80 CPU, other modules include a RAM card with a zero insertion force socket for an EPROM, a mass-storage module sporting a 128 MB Compact Flash card, plus modules for standard serial and I2C comms.

The fit and finish are excellent, and the performance is impressive. The Proton runs CP/M and boasts a ton of old applications that will bring back some memories, like SuperCalc and dBase. We’d venture a bet that WordStar is in there someplace, or easily could be. The video below is a little rough, but shows everything off really well.

In some ways, the Proton reminds us of the RC2014, but its fit and finish are what bring this build home. That’s not to take away from the work [Ricardo] obviously put into documentation, though. The 62-page manual has every detail of every module, plus instructions for building one of your own.

24 thoughts on “Modular Z80 Really Racks Up The Retrocomputer Cred

      1. My buddy told me that he had to write COBOL code at work recently. He said he couldn’t write lines of code longer than 72 letters – because that’s how much would fit on those old punch cards.

  1. After seeing this I kind of want to repurpose my Eurorack synth case to have a bus backplane (ribbon cable). I have one I no longer use that I bought from Waveform magazine that is made out of vector rails and PCB material.

      1. There’s an existing backplane that uses the Euro*card* connectors DIN 41612.
        ECB backplane is used by the N8VEM/retrobrew computers system.

        The Eurorack format uses a similar card cage as the Eurocard systems of old, but synth cards typically aren’t as deep, and don’t need a full 64 or 96 pin backplane.

        1. The retro S100 fans still use DIN41614 but most other homebrew computer builders prefer different connectors. The 3 row DIN41612 (96 pin) isn’t very friendly to people who prototype with wire wrap or strip board. I even considered the AB 64 pin but it expensive compared to alternatives.

          For old 8Bit CPU designs the latching 50 pin enclosed header and IDC plugs are a cheap alternative that works at lower currents (CMOS) rails need to be at least 2 pins per.

  2. This is an excellent rack micro comouter. A 68000 version would be very interesting. A max’d out Z80 system pretty much fits on a single board. On the other hand, a maximum 68K (or 68030) system could have 16M, 32M or gigabytes of memory. Multiple slots would be a real advantage.

    1. I played with a couple of old VME Bus systems with several 68000 CPU boards in one backplane. A great way to learn about old fashioned semaphores to share resources . I should have kept that equipment. Perhaps it is time to build a diy system allowing for the same concepts

  3. (Apart from chippageddon and parts unobtainability…)

    I have difficulty in understanding the attractiveness of this.
    A quick search leads to CP/M emulators on for example ARM, such as:

    In a single IC you would get:
    More “ROM”.
    More RAM.
    More clock speed, even with CP/M emulation.
    Built in Serial.
    Built in I2C.
    Built in quad SPI, for example for uSD cards, or eMMC.
    … and probably more, I guess you could also emulate sound chips and output through I2S, but at some time you’ll run into performance problems. USB and ethernet could also be added quite easily by choosing the right microcontroller.

    I did have a look at micropython recently, but I don’t like Python much. Micropython has some very rudimentory operating system features, but it’s quite limited.

    When mixing these things together, I get to the idea of having some sort of stand-alone system that has an operating system and can load and run different applications on demand, but does not have to be tied necessarily to some pre-existing platform. Maybe it could be something as simple as a (free-) RTOS kernel combined with a command line parser. CP/M could then run as a freeRTOS task and load and run CP/M programs, but other freeRTOS tasks could be written as overlays and compiled to native ARM code. Things like display drivers could also be run as a loadable module. Modern microcontrollers are much more powerful then the home computers from the ’80-ies or even PC’s from the (early) ’90-ies. Maybe something like this already exists, for example in the form of ucLinux. Or maybe it’s just a silly idea all together because full linux capable systems start at around EUR30. (Or even lower, such as Olinuxino RT5350F for EUR17).

    But something like that does not satisfy the nostalgia factor of retro computing hardware. But if that is so, then why add 3 to 5 mictrocontrollers just to create peripherals to this system? What is the frame of mind behind it that thinks frankenstining a bunch of uC’s together is fun, while putting it all in a single uC is not? Is it a fear of SMT soldering? That seems to be a common factor in retro-computer projects.

    1. Intel recently released an article saying that everyone is migrating to CSE for programming but there is no-one migrating to EE o build the things for CSE’s to program. lol

      I guess the choice is less than obvious so I’ll make it clearer … some people like to “build” things. You should encourage them or at least put up with them or you will end up programming rocks.

      1. Can you point out that Rticle, please. I will be really grateful. My current research deals with building physical things to learn how to program, so that article really interest me. Thank you!

    1. There’s so may Z80 variants now, many made by Hitachi and have numbering systems that don’t look anything like Z80.

      eZ80 Z180, Z1000, Z2000, Z3000 that Hitachi Rabbit thing. High speed emulations on the propeller micro-controller, plenty in VHDL and Veralog for FPGA – some up to 300MHz single clock cycle,

      Same with the 6502, have a look at the WDC W65C816S

  4. I built so many Z80 and Z180 based embedded systems back in the 1990s and early 2000s. It was solid as a rock and so easy to code for. Absolutely loved it. Learned to code on 6502s so all those 16 bit registers were an absolute luxury. Huge nostalgic hug around that little rack.

Leave a Reply

Please be kind and respectful to help make the comments section excellent. (Comment Policy)

This site uses Akismet to reduce spam. Learn how your comment data is processed.