Gigatron TTL microcomputer

Just because! A home computer without microprocessor

Similar projects worth following
In 1975 Wozniak famously designed the Breakout arcade game out of 44 simple chips, without using a microprocessor, simply because those weren't available to him at the time. When one year later the MOS 6502 and Zilog Z80 were launched, his Apple 1 started the microcomputer revolution. The debate still rages about which processor was the better one. But more interesting is to investigate if these devices were really necessary for the personal computer revolution at all: what would have happened had they never appeared?

Update: For info on the kit version of this project, check out:

History followed one path
There were many other ways
It will always be like that

Can fewer than 40 old-skool TTL chips implement a multi-megahertz microcomputer with video and sound?

This project started as an exploration of what you can build from 30-40 simple logic chips. It has turned into a general purpose 8-bit microcomputer without any microprocessor driving it. I initially designed this on a large breadboard in early 2017, but soon after that I converted it all to a small PCB. It has VGA-compatible 60 Hz video in 64 colors and can display full-screen images, scroll them and play sound. Soon it will be running games like Pac Man and Space Invaders. But just for fun, I'll keep everything compatible with the breadboard design.

This is what we have now:
• 8-bits system built out of 1970s TTL chips (74LS)
• 34 TTL ICs, or 930 logic gates, for the CPU proper
• No microcontroller and no complex chips (such as the 74181 ALU)
• 16-bit virtual CPU runs ported versions of classic games, WozMon, BASIC, ...
• 8-bit virtual CPU runs 6502 programs without blinking an eye
• Only simple ICs, such as AND/OR, 4-bit adders, multiplexers, registers and so on
• 6.3 MHz. Can be pushed to 15 MHz with 74F logic and faster RAM
• 32kB 70ns RAM
• Harvard architecture with EPROM for kernel and cold storage
• Operates on 2.5W, or below 0.5W for the 74HCT version
• RISC with pipelining:  1 instructions per clock (sometimes 2...)
• Instruction decoding with diodes
• Nice instruction set: ADD/SUB/AND/OR/XOR, conditional jumps, many useful addressing modes
• 60Hz 64 color VGA and 4 sound channels bit-banged from software
• Originally designed and built on a solderless breadboard in 6 weeks (see the logs!)

The build has become a contradiction of itself. To reduce the parts count, every hardware function is essentially software-defined: video, audio and I/O are all handled by software. Video at the pixel level. Audio at the sample level, in 4 channels. Even the applications themselves are running in a non-existent 16-bit processor (aka interpreter).

Yet there is no microprocessor chip in there that runs the software of any of those virtual subsystems: it's all handled by the TTL circuit, acting as a minimalistic CPU and switching rapidly between these tasks. Not only does it work, the board is smaller and faster than the microcomputers of the day, including the first IBM PC. Having no microprocessor might have been better than having any of the time :-)

Check the videos for the current capabilities. The HaD blog section has the full story in all detail, so don't miss that if you're interested.

Some concepts to ponder about before starting

  1. How many bits? 4, 8, 16, 32, ...
  2. Software-generated video or hardwired?
  3. Harvard or Von Neumann architecture?
  4. Single cycle or multi cycle? Pipelining?
  5. ALU chips or not?
  6. Sliced ALU or full width?

A rule of thumb is that a minimalistic four bit system can be done in 10 chips, an eight bitter needs no more than 20 chips and going to 16 bits roughly doubles that again. Not all units double in chip count, but by extending the buses you will also have need for more addressing modes for it all to make sense. For example, a four bitter might work fine with a 256 word memory and absolute addressing, but with larger memories you'll need ways to construct addresses dynamically. Also, add more chips if extra functionality is required, such as high speed, a stack pointer, interrupts, a custom ALU or video.

Simplest possible concept

One concept, probably the simplest, is to replace the TrinketPro from the earlier breadboard VGA from TTL and SRAM with a minimalistic 4-bit TTL CPU. We will then get a working system with around 25 chips, or about 30 if we make a custom ALU. It will...

Read more »


2019 Vintage Computer Festival Berlin presentation

Adobe Portable Document Format - 32.15 MB - 10/14/2019 at 06:55



2019 Hackaday Unconference UK slides

Adobe Portable Document Format - 6.09 MB - 03/17/2019 at 20:34


The Effect of R17.pdf

Measuring across R17 (68Ω)

Adobe Portable Document Format - 3.65 MB - 02/12/2019 at 11:37



2018 Vintage Computer Festival Zürich presentation

Adobe Portable Document Format - 39.86 MB - 11/26/2018 at 15:21


Cycle exact Gigatron emulator and ROM v3 for Hackaday Superconference 2018 badge (hex file and modified sources)

Zip Archive - 360.27 kB - 11/05/2018 at 01:13


View all 11 files

  • Heatmap of Gigatron applications

    Marcel van Kervinck10/08/2019 at 16:01 0 comments

    A static RAM map constructed by overlaying all GT1 files in the GitHub repo.

  • The anthem of 8-bit computing

    Marcel van Kervinck08/13/2019 at 10:07 0 comments

    A bunch of TTL chips playing the "anthem of 8-bit computing". Four channels: 2x pulse, 1x triangle, 1x noise

    The player is an enhanced version of the Contrib/at67/midi player in the gigatron-rom repository. The noise is created from waveform 0 ("metallic") that receives a randomised XOR modulation 60 times per second.

    Only 7400 logic. No microprocessor, no video chip, no sound chip.

    The Arduino is used to load the music and player into RAM. You see that happen in the first few seconds of the video.

  • Microchess and becoming an Apple-1

    Marcel van Kervinck06/23/2019 at 19:54 0 comments

    Today my Gigatron believes it's an Apple-1 instead of a TTL computer. It's running the original 6502 wozmon code with mockup terminal I/O patched to it. Of course the patching, and some relocation, make up for the system differences. With a tongue in the cheek, we can say it turns the Gigatron into an Apple-1 clone!(*)

    Here we can see the "Apple-1 on TTL" running MicroChess code for the first time, with kudos to @oscarv for helping out.

    (*) After all: "Apple1 = 6502 + RAM + WozMon ROM + PIA", and "PIA = DSP + KBD". There wasn't more to it and we emulate it all!

    In reality, any original Apple-1 software will likely need some relocation and a tiny bit of patching for I/O. More technical details in the user forum:

  • Adding 6502 support

    Marcel van Kervinck06/13/2019 at 00:15 5 comments

    The computer without microprocessor is becoming dual core.

    Today it ran its first 6502 program.

    All of the 6502 addressing modes are implemented, and a fair amount of instructions as well. The v6502 interpreter runs in place of the standard 16-bits application vCPU. Switching between the two virtual processors vCPU and v6502 is a matter of modifying a zero page variable. The video driver dispatches at the next available scan line, so very lightweight.

    The impressive thing about the 476-byte Baum-Wozniak 6502 disassembler isn't just its size: it's that it seems to be secretly designed for 26 character wide displays. Now that's quite a foresight by these gentlemen! Here you see it running on the Gigatron, disassembling it's own code:

    More details on the user forum:

  • Having fun with electron beam lithography

    Marcel van Kervinck11/15/2018 at 11:15 2 comments

    The joy of using hypermodern multiple e-beam direct-write lithography to "advertise" TTL technology from the 1960s... This is an electron microscope image of the Gigatron startup screen. This time it isn't displayed on a VGA monitor (or on a supercon badge), but printed on a silicon test wafer as used for IC making. The image was printed using a Mapper FLX-1200 e-beam writer. For comparison, a human hair is typically 75 µm in thickness.

    The Mapper principle is much like that of an ink jet printer head with hundreds of nozzles, except we're using accelerated electrons here instead of ink, and silicon wafers instead of paper (and there are no colors). The beams each have a spot size of under 30 nm and they're scanning the surface with a positioning accuracy of below 3 nm. They're all perfectly stitched together to seamlessly cover the large area needed to make complex devices. The wafer was coated with a thin layer of resist material, and everywhere a sufficient number of electrons landed, an image formed that could be developed. 

    This tiny area of 24 µm x 18 µm shown above was printed in just a few milliseconds by a couple of hundred parallel and independently controlled electron beams, all focussed on the wafer in a high-vacuum chamber. This image is a small part of a much larger test pattern. The resolution is in the 40-50 nm range here. The e-beam writer has tens of thousands of beams all working in parallel. The data stream to support that is about 3 Tbit/second and is generated by a large rack filled with FPGAs.

    A SEM is needed to view the result because the details are too small for optical microscopes. This super fast e-beam technology is developed to make new types of security ICs possible, but it has other applications in nano-fabrication as well (one is entertaining the engineers working with it).

    The image contains a schematic of the iconic 7400 quad NAND chip, introduced in the late 1960s. An actual NAND gate, or even a single transistor from the day, would be much larger than this entire image. The typical line widths in those early days of IC manufacturing were in the order 10 µm.

    Courtesy Mapper Lithography and CEA Leti.

    [Edit 2019-02-11: Unfortunately, Mapper is no more. Looking for a job now! ]

  • More 8-Bit Goodness & Superconference

    Marcel van Kervinck10/30/2018 at 17:21 3 comments

    The 8-Bit Guy just published his review of Pluggy McPlugface, Tiny BASIC v2 and the new games in ROM v3. And oh... we'll show it at the Superconference this weekend!

    For those interested, I brought a very limited number of kits to Pasadena. They can go for a nice discount because I don't want to bring them back home.

    Update: The conference badge was screaming for this hack:

    The emulation is slow as molasses, running at 3 frames per second, instead of 60 frames. Contrary to my expectation, the slowdown doesn't come from the LCD update. Instead it's all due to the cycle-exact simulation which is based on the gtemu.c reference.

    Hex file and modified sources attached to the project. Game controller button [A] is mapped to the DEL button. The BKSP button takes over the role of [Select] for switching between video/speed modes. You don't see the different scan line effects, because the LCD always only displays the first out of every 4 VGA scan lines (even in "full mode", aka "mode 0"), with the odd LCD lines always black. The applications still run faster depending on the mode. Continuous presses don't work, you have to simulate them by repeating. I managed to play Racer that way. Typing in Tiny BASIC v2 goes remarkably well.

    Credits must go to @shaos, @jaromir and @rogerrandom for helping me plow through all the PIC stuff, as I never worked with any of that before.

  • Full circle

    Marcel van Kervinck09/16/2018 at 18:27 2 comments

    Today, a circle closed at the Centre for Computing History in Cambridge, UK.

    How? Well, one week before this project started here on Hackaday, I was at the Computer History Museum in Mountain View, US, and jokingly posted the following remark on Facebook:


    That's an original Apple-1. The Apple-1 next to the Gigatron is a beautifully done replica. It's fully functional, complete with cassette interface. The PCB is drawn in the same way and the chips even have 1970s date codes on them. It's on display in an operational state. I could play around and type commands in the original Woz Mon to verify that the Gigatron version works the same.

    Many thanks to David Williams for the great opportunity!

  • TTL is hot

    Marcel van Kervinck08/12/2018 at 16:27 0 comments

    One of my side projects is to convert a board to original TTL series where possible, or at least to 74LS series with the oldest chips I can find. The breadboard prototype was fully 74LS, the kit edition is 74HCT.

    At a local electronics shop I recently found quite a few ICs that were manufactured more than 43 years ago, in 1975. These are "new old stock": never used before and the pins still unbent. Some are indeed original TTL series as existed in the 1960s, not 74LS (Low-power Shottky) as introduced in 1971. They're plug-in compatible with the Gigatron design and the system works fine at full speed:

    Although it is cool, it also gets hot! Original TTL consumes an order of magnitude more power. Due to this so far I only "upgraded" to original TTL the upper half the logic unit, the X register, the memory address unit and the program counter. Those 14 chips, together with a few 74LS replacements as well, already increase the current to 740 mA, or about a ten-fold from the kit version. Above that the multi-fuse and MCP start to do their thing. Remember that USB safety is the reason the kit comes with much more power-efficient 74HCT components in the first place.

    The nice thing about the 7400-series is that improved series remained compatible in pin layout and voltage levels.

    • 1966: introduction of the original 7400 series
    • 1971: introduction of 74LS series
    • 1983: introduction of 74HC(T) series

    I have them all on a board now.  The difference in generations is clearly visible.  The old TTLs get up to 60 degree Celsius. The blue square isn't a cool oasis in the middle of a hot desert. It is a reflection on the gold plated ceramic lid of a vintage SRAM.

  • Back to BASICs

    Marcel van Kervinck07/24/2018 at 20:33 0 comments

    I almost forgot about the project's original objective that I had in mind when it started one and a half year ago: to build a circuit from TTL components that can play Tic-Tac-Toe on an LED matrix. So lets correct that: today, with minor adjustments, Tom Pittman's Tic-Tac-Toe from 1977 is running on the Gigatron :-) Source code in GitHub.

    Ok, the planned LED matrix has morphed into a video screen along the way. That's just feature creep.

  • 200+

    Marcel van Kervinck07/16/2018 at 08:17 1 comment

    We've recently celebrated a dream milestone: there are now more Gigatrons out there than Apple-1's ever produced!

View all 68 project logs

Enjoy this project?



Peabody1929 wrote 04/01/2017 at 18:46 point

Consider one or two AMD2901 or a single CY7C115/116/117 -> More computer, fewer chips.

  Are you sure? yes | no

Marcel van Kervinck wrote 04/02/2017 at 20:09 point

Thanks. I can find the first. I do have ALU chips available, I just don't feel like using them in this build. Do you have data sheets for the second series? I have trouble finding out what it is. Some memory? I plan on using 62256 for RAM and 2x AT28C256 for ROM, with a possibility to extend the memory using the AT27C1024.

  Are you sure? yes | no

Big Boy Pete wrote 03/31/2017 at 18:19 point

Good luck Marcel.

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates