The Z80 Is Dead. Long Live The Free Z80!

It’s with a tinge of sadness that we and many others reported on the recent move by Zilog to end-of-life the original Z80 8-bit microprocessor. This was the part that gave so many engineers and programmers their first introduction to a computer of their own. Even though now outdated its presence has been a constant over the decades. Zilog will continue to sell a Z80 derivative in the form of their eZ80, but that’s not the only place the core can be found on silicon. [Rejunity] is bringing us an open-source z80 core on real hardware, thanks of course to the TinyTapeout ASIC project. The classic core will occupy two tiles on the upcoming TinyTapeout 7. While perhaps it’s not quite the same as a real 40-pin DIP in your hands, like all of the open-source custom silicon world, it’s as yet early days.

The core in question is derived from the TV80 open-source core, which we would be very interested to compare when fabricated at TinyTapeout’s 130nm process with an original chip from a much larger 1970s process. While It’s true that this project is more of an interesting demonstration of TinyTapeout than a practical everyday Z80, it does at least serve as a reminder that there may be a future point in which a run of open-source real Z80s or other chips might become possible.

This isn’t the first time we’ve featured a TinyTapeout project.

27 thoughts on “The Z80 Is Dead. Long Live The Free Z80!

      1. I believe the actual fabrication technology used original in the 6581 contributes to its sound and a re-implementation on a completely different process will not be entirely faithful to the original 6581 sound.

      2. The SID chip is a hybrid, part digital and part analog. It’s thus rather hard to emulate in pure digital hardware. There are however multiple solutions that use DSP hardware and software models of the SID to get close to the original (but rather too large to fit on an open chip like this.

  1. So out of curiosity, are there any FPGA cores that can very very very closely replicate the Z80 that would also be available in similar form factors? I am just thinking preservation here where you could zap in a Z80 core and pinmap to a cheap Lattice like device (for example) and revive old hardware. Or are we stuck with dwindling supplies and emulation on modern processors?

      1. Yeah but what about when it doesn’t still exist (or, more realistically, exists in small enough numbers to make it prohibitively expensive). It happens faster than you’d think. There’s plenty of hardware I can think of from my youth (or even ten or fifteen years ago…) that used to be so common you couldn’t give it away, but now command large ebay auctions.

          1. They will probably buy a Z80 core design from Zilog and use it to shrink the TI-84 down to one chip (cheaper for them to make). Don’t expect the price to drop though.

      2. The eZ80 is software compatible, but nowhere near cycle accurate. Their aim was to implement the instruction set, but in a modern pipelined core. I don’t think the bus is directly comparable either.

    1. The hype about FPGA doesn’t make any sense to me. The technology isn’t same. It’s like using a random transistor as a substitute for a former high-end nuvistor or electron tube.

      1. I’m afraid your statement doesn’t make sense to me. FPGAs are just a collection of logic blocks but are easily programmable to wired together and implement the logic you desire, including CPUs. The transistors in modern FPGAs are higher performance than those in 1970 Z-80’s in both speed and power efficiency, but FPGAs implement digital logic just like as CPUs do.

      2. From a software point of view an FPGA can emulate any CPU type you’d like (obviously within the available resources on the chip). IO pins on an FPGA can be assigned as required, so once you have level shifted to 5v (FPGAs can work at multiple levels, but not normally above 3.3V) they can appear to be identical from a signaling point of view also.

        You don’t need much FPGA fabric to implement a Z80, nor high performance, so it should be possible to create an FPGA implementation of a Z80 that fits in a 40 pin DIP socket, looks to the rest of the system exactly like a Z80, doesn’t cost much more than a real chip and runs Z80 code exactly like the original.

        If your original device is prohibitively expensive, unreliable or unobtainable then FPGAs make a good deal of sense.

      3. The technology isn’t the same but that doesn’t really matter for digital systems, as long as you can implement the same logic then it is functionally the same.

        There is a reason that FPGAs are becoming popular for retro games or retro computers. FPGAs are capable of being used as functionally equivalent systems, even down to hardware bugs.

        Now if it was an analogue system then you would have a point but the systems that are getting emulated are digital and the only difference using better or modern components yields is higher maximum clock speeds. You can run it at the original clock speeds and you would not be able to tell whether it was an FPGA or original chip you were using.

        It seems you just don’t understand FPGAs and likely have never used one.

    2. One issue with FPGAs is that they are 3.3V while Z80 is 5V. Not impossible to solve with PCB and buffering, but adds some complexity.

      The first iteration Z80 on TinyTapeout won’t be 5V compatible either, however the ChipIgnite and Skywater 130 nm process actually allows to support 5V – so going to happen in the 2nd iteration, I think!

  2. Jupiter ACE
    Year 1982
    Generation 4th
    CPU Zilog 80
    ran Forth.

    2024. ARM A and M., RISC-V … and even x86 platforms.

    Using indirect gcc c c technology:

    6.3 Labels as Values.

    “An alternate way to write the above example is

    static const int array[] = { &&foo – &&foo, &&bar – &&foo,
    &&hack – &&foo };
    goto *(&&foo + array[i]);”

    array[0]=0x0, array[1]=0x20, array[2]=0x40.

    256 bit ONGOSUB/ONGOTO?

    array[3] segment fault, core dump. 196-70s parlance?

    “Note that this does not check whether the subscript is in bounds—array indexing in C never does that.”

    1. [William Payne]
      Some of your comments are so cryptic, I wonder if they even relate to to subject at hand.
      A little more comments in your code perhaps?

  3. Most of what’s written is Swahili to me, though I know that my Moog The Source carries Z80 so just I worry, if a compatible replacement to it would be available anytime in case I need it anyone could please decipher or comment on that ?

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.