Close
0%
0%

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: https://gigatron.io/

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 (Snake, Racer, Tetris, Bricks, ...)
• 8-bit virtual CPU runs 6502 programs such as Microchess and Micro-Soft BASIC without blinking an eye
• Can emulate an Apple-1 including wozmon, Apple-1 BASIC, mini-assembler and some games
• 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. [And no @Benchoff, it doesn't require a large ROM at all.]
• 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 clean 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....

Read more »

Schematics 2020-03-20.pdf

Circuit diagram

Adobe Portable Document Format - 1.39 MB - 03/21/2020 at 10:07

Preview
Download

Gigatron Rev. 2012 OSH.zip

Gigatron TTL computer KiCad files and gerbers

Zip Archive - 4.60 MB - 03/20/2020 at 16:30

Download

PluggyMcPlugface.zip

PS/2 keyboard adapter KiCad files and gerbers

Zip Archive - 2.77 MB - 03/20/2020 at 16:27

Download

Native instruction overview 2019-11-25.pdf

Two views on the native 8-bit instruction set

Adobe Portable Document Format - 62.81 kB - 11/27/2019 at 00:47

Preview
Download

2019-VCF-Berlin-GigatronTTL.pdf

2019 Vintage Computer Festival Berlin presentation

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

Preview
Download

View all 13 files

  • 1000! And Gigatron future

    Walter4 days ago 0 comments

    In the last year, a lot has happened. We now have 6502 emulation and the Gigatron can run Apple-1 code, such as WozMon. We have BASIC running and there's a great BASIC compiler, opening the way to create great games. Looking back on the original goal to play tic-tac-toe on a LED matrix, we are super chuffed that we have a system running BASIC that feels like an actual homecomputer from years ago - still without a microprocessor.

    And today, Gigatron #1000 has found a new owner! Thanks to everybody for making happen what we could not have dreamt of when we started!

    We have decided to stop selling kits once our stock has been sold, which should be in a few months. For us, the Gigatron was always about inventing new things, understanding technology, designing, fine tuning, tinkering, and also about meeting like minded people (and having fun in the process). Making it into a kit had its own charmes, writing a manual, sourcing components, designing a PCB. Packaging and sending out kits, however, resembles a plain job too much, but was needed to create a community of people that would also want to design, understand and tinker.

    That community now exists, and wonderful things have already come from it, both in hardware and software. So we will stop selling and providing support in a few months. Does that mean you can no longer get a Gigatron? No, you still can, because the PCB layout, the schematics and the software have all been open sourced. The only thing you probably cannot get is the wooden case that we had tailor made for the Gigatron. Somewhere in July or August, the assembly manual and more will  open sourced as well. We hope the Gigatron will live on!


  • The gtBASIC compiler for games

    Marcel van Kervinck05/05/2020 at 09:31 0 comments

    The Gigatron can be a great gaming machine. However, Tiny BASIC is a bit too slow for games and nowadays not everyone wants to do assembly. Yesterday at67 formally released his solution to this dilemma: the gtBASIC compiler(!) supporting sprites, sound effects and music! Now there's NO excuse to turn the Gigatron into the retro game console you always wanted. I hope this brings the platform to a whole new level.

  • Mastermind in 177 bytes

    Marcel van Kervinck02/22/2020 at 12:21 0 comments

    Typed in from this 1976 Dr Dobbs article. Worked first time.

    Except that we don't do decimal mode and Woz used that to increment the "tries" counter on the left side. So you better win the game in less than 10 tries (or accept a hexadecimal count).

    If we sacrifice 13 more bytes, we can get the correct try count without using BCD mode:

    190 bytes works for me.

  • Why settle for two BASICs when you can have four?

    Marcel van Kervinck12/27/2019 at 20:47 0 comments

    Today we gained two more BASICs. One new, one very old. First at67 offered his BASIC compiler for the Gigatron. This project has been brewing for over a year. It's still in alpha, but it is GREAT already. This is a cross-compiler that creates fast Gigatron binaries. This is fantastic news for those who like to write games but don't want to dive too deep into the Gigatron machine languages. This week it built our Christmas greetings, with snow physics and Jingle Bells tune.

     Video link: https://streamable.com/5ds9d

    At67's compiler is the third BASIC for the Gigatron. The first was our port of Tiny BASIC more than a year ago. The second was MS BASIC with floating point. Today I decided that three BASICs aren't enough because we can have four.

    We have Apple-1 emulation after all, so why not? Most work was to arrange the video table such that we have a 4K continuous block for Wozniak's original Apple-1 BASIC. We managed to free $6000-$6FFF in the 32K system. That mirrors to address $E000 and that is exactly where the original likes to sit. Then we reordered the zero page a bit and recompiled the A1 BASIC using cc65. Et voilà, there it runs! 

  • Micro-Soft BASIC and π

    Marcel van Kervinck10/16/2019 at 19:32 0 comments

    It took a while, but now Micro-Soft BASIC is running on the 32K Gigatron! We already had Tiny BASIC of course, but that doesn't have 9 digits floating point (40 bits), let alone transcendental functions. Remember when Hackaday wrote that the Gigatron would probably never have floating point?

    This is the BASIC that Paul Allen and Bill Gates wrote with Monte Davidoff and Ric Weiland, and for which they started Microsoft, or spelled Micro-Soft back then. They licensed it to many microcomputer builders, amongst others to Commodore. The version we have running is an early one for the Commodore PET. 

    Although the system can interpret 6502 code, there still was work to do: code, buffers, zero page variables and stack needed relocation, but that wasn't the biggest hurdle as Michael Steil's excellent set of reconstructed assembly sources made that relatively painless. The main problem was to create a sufficiently large continuous memory space. Although the Gigatron has 32K of RAM, 19KB of that is used for screen memory and the remainder is heavily fragmented. For example, by default the largest continuous block we have is just 512 bytes. BASIC itself needs 8KB, plus we need some K's for user program and variables. Ouch... 

    The first win is to disable the sound channels 2 through 4. That creates a continuous block from $200 to $800. For this trick you need ROM v4.

    The next step is to compress the video memory. Our video resolution is already next to nothing, but we can always lower it even more! Of the 120 visible pixel lines, every 8th is always empty. At least, as long as we only use capitals, and for a mid-1970s BASIC that's perfectly acceptable. The empty pixel lines can then be shared for all rows of text. That saves 14*256 = 3585 bytes already.

    The last trick is to increase the spacing between text lines from 1 to 4. This reduces the text lines from 15 to 11, but yields 4 * 7 * 256 =7,168 bytes.

    Of course we then went overboard and added a flashing cursor, we made sure that the WAIT 6502 Easter Egg works, and that there is a π-symbol. The Gigatron doesn't have that in its font, but it does have T and U.... And... the font is stored without horizontal spacing, so there's our glyph:

      R         S         T   pi    U
      |         |         |   |     |
      v         v         v   v     v
      x x x x . . x x x . x x # # # # . . . x
      x . . . x x . . . . . . # . . # . . . x
      x . . . x x . . . . . . # . . # . . . x
      x x x x . . x x x . . . # . . # . . . x
      x . x . . . . . . x . . # . . # . . . x
      x . . x . . . . . x . . # . . # . . . x
      x . . . x x x x x . . . # . . . # x x .
      . . . . . . . . . . . . . . . . . . . .
      0 1 2 3 4 5 6 7 8 9 a b c d e f 1 1 1 1
      ^                               0 1 2 3
      |
      font82up

    Good enough for me:

  • 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: https://forum.gigatron.io/viewtopic.php?p=774#p774

  • 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: https://forum.gigatron.io/viewtopic.php?f=4&t=128

  • 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! ]

View all 73 project logs

Enjoy this project?

Share

Discussions

Yann Guidon / YGDES wrote 10/28/2017 at 12:41 point

Amazinger :-D

  Are you sure? yes | no

f4hdk wrote 05/26/2017 at 11:34 point

I like it! 

Every homebrew computer should have video output, even made with TTL!

Have you seen my project? It is quite similar (custom CPU architecture, video output) even if I used an FPGA  instead of TTL components.

https://hackaday.io/project/18206-a2z-computer

It's fully documented and open source. 

And welcome on the "homebrew CPU Webring" !

  Are you sure? yes | no

Marcel van Kervinck wrote 05/26/2017 at 13:52 point

Nice! FPGA's are a step up for me. Clearly the TTL and the RAM size are limiting my video resolution, but it is also cute in its own way.

  Are you sure? yes | no

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