Vintage Hardware – The IBM 701

The Basics

The IBM 701 computer was one of IBM’s first commercially available computers.  Here are a few facts about the 701:

  • The 701 was introduced in 1953.
  • IBM sold only 30 units.
  • It used approximately 4,000 tubes.
  • Memory was stored on 72 CRT tubes called Williams Tubes with a total capacity of 2,048 words.
  • The word size was 36 bits wide.
  • The CPU contained two programmer accessible registers: Accumulator, multiplier/quotient register.


There were two types of electronic switches in the early 1950’s: The relay and the vacuum tube.  Relays were unreliable, mechanical, noisy, power-hungry and slow.  Tubes were unreliable and power-hungry.  Compared to the relay, tubes were fast.  One of the limitations on how big and complex a computer could be in those days, was determined by the reliability of the tube.  Tubes had a failure rate of 0.3 percent per 1000 hours (in the late 40’s, early 50’s).  That means, that in 1,000 hours of use, 0.3 percent of the tubes will fail.  That’s pretty good if you’re talking about a dozen tubes.  At that failure rate, the 701 would fail at an average of less than one hour (0.3 x 4,000 tubes = 1,200 units per 1,000 hours) assuming an even distribution of failures.

Tubes use higher voltage levels than semiconductors and that means a lot more heat and more power usage.  It also means that tubes are much slower than semiconductors.  By today’s standards, tubes are incredible slow.  Most tube circuit times were measured in microseconds instead of nanoseconds.  A typical add instruction on the IBM 701 took 60 microseconds to complete.

The main memory was composed of Williams tubes.  These are small CRT tubes that stored data by exploiting the delay time that it took phosphor to fade.  Instead of using the visible properties of phosphor to store data, a secondary emission effect can occur by increasing the beam to a threshold causing a charge to occur.  A thin conducting plate is mounted to the front of the CRT.  When the beam hits a point where the phosphor is already lit up, no charge is induced on the plate.  This is a read as a one.  When the beam hits a place where there was no lit phosphor, a current will flow indicating a zero.  The read operation causes the bit to overwritten as a one, so the data must be re-written as it is read.  Wiki has an entire article on the Williams tube: Williams tube wiki.  Here’s an example of the dot pattern on a Williams tube:

By National Institute of Standards and Technology – National Institute of Standards and Technology, Public Domain

The tubes that were used for memory storage didn’t have visible phosphor, therefore a technician could plug in a phosphor tube in parallel and see the image as picture above for troubleshooting purposes.

Williams tube memory was called electrostatic storage and it had an access time of 12 microseconds.  Each tube stored 1,024 bits of data data for one bit of the data bus.  To form a parallel data bus, 36 tubes together represented the full data path for 1,024 words of data.  The data is stored on the tube in 32 columns by 32 rows.  If you count the columns and rows in the tube pictured above, you’ll see that it is storing 16 by 16, representing a total of 256 bits of data.  The system came with 72 tubes total for a memory size of 2,048 words of memory.  Since the word size is 36 bits wide, 2,048 words is equal to 9,216 bytes of storage.

Here’s a photo of one drawer containing two Williams tubes:


Williams tubes used electromagnets to steer the electron beam to an xy point on the screen.  What this means is that the entire assembly must be carefully shielded to prevent stray magnetic fields from redirecting the beam.  In the picture above you can see the black shielding around each of the long tubes to prevent interference between the two tubes.

In order to address the data from the tube, the addressing circuitry would control the x and y magnets to steer to the correct dot, then read or write the dot.  If you want to learn more about the circuitry that drives an electrostatic memory unit, you can download the schematics in PDF here.

One type of semiconductor was used in this machine and that was the Germanium diode.  The 701 used at total of 13,000 germanium diodes.


The CPU or Analytical Control Unit could perform 33 calculator operations as shown in this diagram:

Here is the block diagram of the 701:

Instructions are read from the electrostatic storage into the memory register where it is directed to the instruction register. Data that is sent to external devices must go through the multiplier/quotient register.  Data read from external devices (i.e. tape, drum or card reader) is loaded into the multiplier/quotient register.  As you can see from the block diagram, there is a switch that feeds inputs from the tape, drum, card reader or the electrostatic memory.  This is a physical switch on the front panel of the computer.  The computer operator would change the switch position to the desired input before starting the machine.  Here’s a photo of the front panel, you can see the round switch near the lower left (click to zoom):

By Dan – Flickr: IBM 701, CC BY 2.0

The front panel also has switches and lights for each of the registers so the operator could manually input binary into the accumulator or enter a starting address (instruction counter).  Notice how the data width of this computer is wider than the address width.  Only 12 bits are needed to address all 2,048 words of memory.  If you look closely, you’ll also notice that the lights are grouped in octal sets (3 lights per group).  The operator can key in data that is written as octal numbers (0-7) without trying to look at a 12-bit number of ones and zeros.  The switches for entering data are grouped gray and white in octal groupings as well.

There is a front panel control to increment the machine cycle.  An operator or technician could troubleshoot a problem by executing one machine cycle at a time with one press of the button per machine cycle.  For a multiply instruction the operator could push the button 38 times to complete the operation or examine the partial result as each cycle was completed.  The machine also came with diagnostic programs that could be run to quickly identify a physical problem with the machine.  A set of 16 manuals was provided to assist the installation, maintenance, operation and programming of the 701.  The computer operator normally only operated the start, stop and reset controls as well as the input and output selectors on the machine.  The instruction counter and register controls are normally used by a technician to troubleshoot problems.

The CPU was constructed using a modular technique.  Each module or “Pluggable Unit” had a complete circuit on it and could be replaced all at once by a technician.  The units looked like this:

Image from Pintrest (Explore Vacuum Tube, IBM, and more!)

Each of these units are aligned together into one large block:

(By Bitsavers, IBM 701)

Notice how all the tubes face the front of the machine.  One of the first things to burn out on a tube is the heating element.  By facing the tubes toward the front, a technician can quickly identify any burned out tubes and replace them.  If all tubes are glowing, then the technician will need to run diagnostics and try to limit down which tube or tubes are not working.  Another reason to design the modules to face all tubes forward, is that the technician can grab a tube and pull it out of it’s socket to put it into a tube tester and determine which tube really is bad.

My experience with tubes date back to the late ’70s when people wanted to “fix” an old TV set (usually a TV that was built in the early 60s).  I would look for an unlit tube, read the tube number off the side and run down to the electronics shop to buy a new one.  If that failed, then my next troubleshooting step was to pull all the tubes (after the TV cooled off), put them in a box and run up to the electronics store where they had a tube tester (they wanted to sell new tubes, so they provided a self-help tester right at their store).  I would plug my tube into the tester, flip through the index pages for the tube type being tested.  Then adjust the controls according to the instructions and push the test button.  If the tube was bad, then I bought a new one.  Other components such as diodes, resisters, capacitors rarely went bad.  Those would be the next thing on the troubleshooting list after all the tubes were determined to be good.  One other note about troubleshooting tubes: The tube tester had a meter that would be read to determine what the testing current flow was.  The manual had a range of acceptable values (minimum and maximum values).  The values were based on the tube manufacturer’s specifications.  For some devices, the tube would not work, even though it was within manufacturer specifications.  We referred to tubes like this as a “weak” tube (in other words it might not be able to pass as much current as needed by the circuit).  So a determination would have to be made to replace the tube.

Here’s an example of the type of tube tester I remember using:

(PDX Retro)

All cabinets were designed to be no larger than necessary to be able to transport up an elevator and fit through a normal sized office door (see: Buchholz IBM 701 System Design, Page 1285 Construction and Design Details).  The entire system was divided into separate cabinets for this very purpose.  Cables would be run through the floor to connect cabinets together, much like the wiring in modern server rooms.

Storage Devices

The 701 could be configured with a drum storage unit and a tape storage unit.  The IBM 731 storage unit contained two physical drums organized as four logical drums able to store 2,048 full words of information each (for a total of 8,192 words, equal to 82,000 decimal digits).  Each logical drum reads and writes 36 bits in a row.  The drum spins at a rate of 2,929 RPM with a density of 50 bits to the inch.  There are 2,048 bits around the drum for each track.  Seek time could take up to 1,280 microseconds.  The storage capacity was intentionally designed to match the capacity of the electrostatic memory.  This was used to read all memory onto a drum or read a drum into the electrostatic memory.


The primary input device for the 701 was the punch card reader.  Computers in the 50’s were designed as batch machines.  It cost a lot of money to run a computer room and it is more economical to batch jobs so the computer was processing data continuously.  It would be too expensive to have an operator typing data into the computer and saving it on a storage device like we do today.  Timeshare systems were not invented yet and this machine was too slow and tiny for time sharing.  In order to perform batch jobs, operators or programmers would use the keypunch machine to type their program and data onto punch cards (usually in a different room).  The keypunch machine was an electro-mechanical device that looked like a giant typewriter (IBM 026):

By Columbia University, The IBM 026 Keypunch

A punch card reader is connected as an input to the 701 in order to read in a batch of punch cards.  The cards can be read in at a rate of 150 cards per minute.  Each card holds one line of data from a program or 72 characters wide.  If the punch cards are used as binary input, then they can contain 24 full words per card.  A program can be punched onto a stack of cards and then loaded into the card reader for execution.  Programmers used a lot of common routines with their programs, so they would punch a routine on a small stack of cards and then include that stack with their main program to be run in sequence (see: Buchholz IBM 701 System Design, Page 1274 Card programming).  Then they could save the common routine cards to be used with other jobs.  The stacks of cards were equivalent to today’s “files”.

By IBM Archives, IBM 711 Punch Card Reader


The 701 was normally configured with a line printer that can print 150 lines per minute.  Information to be printed was transferred from the multiplier/quotient register to 72 thyratrons (a type of current amplifier tube) connected directly to the printer.  The tyratrons were located inside the Analytical Control Unit and their function was shared by the printer and the card punch (thyratrons activated the print magnets or the punch magnets).  Data that was printed came directly from the electrostatic storage and needed to be converted by the program into decimal data before going to the printer.


I have provided links from each embedded photo above to the sources (with the exception of diagrams I copied from the sources below).  You may click on a photo to go to the source and obtain more information.  For more detailed information about the IBM 701, I would recommend clicking through these sites/documents:


Vintage Hardware – Arcade Games

In my last Vintage post I talked about the first commercially available fully assembled PCs and ended with the Space Invaders video game console.  In this blog post I’m going to talk about a few other video games.


I spent so many quarters on Galaga that I probably bought the company owner his/her yacht.  I went searching around the Web looking for schematics (which didn’t take too long) and stumbled onto this site (click here).  The schematic for Galaga is a PDF that you can download by clicking here.  When I first opened the schematic I immediately noticed that the CPU board contained three Z-80 CPUs.  These guys were serious!  At that time, this game probably cost a lot to manufacture.

You can learn a lot about the original video game from people who collect and repair these games.  Here’s a website that has some interesting material on Galaga: Galaga Information.  The best site on the design of the game is at the Computer Archeology site.  This site has the assembly code from the EPROMs used by all 3 CPUs and indicates that CPU1 and 2 control the game while CPU3 is the sound processor.  All three processors share 8k of static RAM (using 2147 memories).

There are custom chips on the boards that are used for various functions.  One function is the bus driver chips that interface between each CPU and the common data bus.

There are three of these chips used and I’m assuming that the logic connecting to them is used to interlock between the three so that only one can access the main bus at a time.  What I’m uncertain of is how the bus is shared.  There is a 6Mhz clock signal that is fed into all three chips, so maybe each CPU gets 1 or 2 clock cycle each turn?  The Z80 chips are normally clocked at 1Mhz, so it would make sense to run the bus at 3x or in this case 6x the CPU frequency and then do a round-robin.  Each CPU can be programmed as though it had complete control of the address and data bus.

For information on the custom chips, I found this site: The Defender Project.

Finally, here’s a blog describing an arcade emulator that Paolo Severini built using javascript:

Galaga: an Arcade machine emulator for Windows and HTML5


This video game was a horizontal shooter game with a video resolution of 360 x 240 pixels at 16 colors from a palette of 256 total colors (according to the manual, which can be found here). Here’s a snippet of the color RAM circuit:

The TTL 7489 is a 16 bit memory used to store the palette information.  You can see where the 8 outputs from the ram (4 bits from each chip) feed the analog Red, Green and Blue circuits used by the monitor.  It appears that the blue gets the least amount of control with only 2 bits, or 4 levels, while the Red and Green receive 3 bits or 8 levels of information.  The 74LS257 at the left of the circuit diagram is a multiplexer.  The job of that circuit is to allow the microprocessor to access the 7489s (and use the MPU data bus to load data) or allow the video circuitry to access the memory to display on the video monitor.  The microprocessor can only write to the memory during a monitor blanking operation.

At the top of the Red, Green, Blue amplifier circuits is another transistor.  This transistor shuts off the power to all three amplifiers and is controlled from the horizontal blank signal.  If you’re not familiar with the old video tubes, basically, there is a beam of electrons that are fired at the front of the screen.  The inside of the tube is coated with phosphor and it glows when electrons hit it.  The beam is “steered” by magnets on the neck of the tube.  The beam is moved in a horizontal line pattern starting from the top left of the screen and ending at the bottom right.  When the beam returns to light up the next line of phosphor, it has to be shut off, otherwise an angled beam would be drawn on the screen.  The beam is also shut off when it returns to the top left from the bottom right.

Unlike Galaga, Defender uses only one CPU and it’s a 6809 processor.  The game program is stored in ROM like other video game boards (no need for a hard drive).   There are two versions of Defender and both versions contained 26k of ROM (in different configurations of 4k and 2k ROM chips).  There are three banks of RAM used for video memory and scratch pad memory.  All RAM used is the 4116 dynamic RAM organized as 16k by 1 bit.  If you look at the schematic it appears that banks 1 and 2 are just 8 chips (4L-4S), but the diagram represents two chips per location (5L-5S).  Bank 3 is wired a bit different from banks 1 and 2.  The data bus is connected through a multiplexer.

The video RAM is fed into 4 8-bit serial shift registers.  All three banks of memory go into these shift registers at one time.

The TTL 74165 is a parallel load, serial out shift register circuit.  According to the circuit above, 6 bits are loaded at a time into each shift register.  Two bits from each bank per shift register.

If you read through the manual, you’ll stumble onto the E and Q generator.  These are 1Mhz clock signals that are out of phase from each other.  The purpose is to interleave the CPU and video access to the video memory.  During one clock cycle the CPU (call MPU in the manual) can read and write to the memory banks.  During the other clock cycle, the video timing circuit reads the memory banks into the shift registers.

Here are some other sites with information about Defender:

Asteroids and Battlezone

The unique aspect of these two games is that they use vector graphics.  If you don’t know what vector graphics are, you can think of it as a bunch of lines drawn on a screen instead of a grid of pixels.  The maximum number of lines that can be drawn on the screen depends on the speed that lines can be drawn in 1/60th of a second, which is the refresh rate of the video screen.  The circuitry for generating the images seems pretty simple: Run down a list of 2D vectors and output the x,y coordinates to the screen.  Video tubes operated on a X and Y or horizontal and vertical magnets that “steer” the electron beam to the phosphor coating in the front.  The circuitry to run this is a bit more complicated.  Basically the vector graphics are driven by a digital to analog circuit that is independent of the CPU.  This circuit calculates all the intermediate values of x and y for each line that is rendered on the screen.  There is a state machine that performs all of this logic, which is detailed in this document: The hitch-hacker’s guide to the Atari Digital Vector Generator.  The last page shows the states:

The DVG was a special purpose processor built out of discrete TTL components in order to run a vector graphics system.  The DVG had 7 operation codes:

  1. VCTR – draw long vector
  2. LABS – load absolute x,y coords
  3. HALT
  4. JSRL – jump to subroutine
  5. RTSL – return from subroutine
  6. JMPL – jump
  7. SVEC – draw short vector

There is also a “Z” axis circuit.  This determines if the beam is on or off and there are also different intensities to represent different shades.  Both games are black and white, so there is no color.  Here’s the intensity scaling circuitry:

The intensity has a range from 1volt to 4 volts and can be any of the 16 shades in-between. Scale0 through Scale3 are bits of a 4-bit word.  The bottom part of the circuit above is the blanking circuit.  This is controlled by the BLANK signal, or the BVLD which means beam valid.  If either signal indicates that the beam should be off, then Q8 will turn on and force Q9 to turn off and block any signal coming from the intensity circuit.

You can get a more detailed (and clean) schematic and description of the DVG by clicking here.

There’s an interesting article on the making of asteroids by Ed Logg, Howard Delman and Lyle Rains, the people who created the game (click here).  You can click here to download the schematics for Asteroids and click here to download the schematics to Battlezone.  If you want to know more about the software side of Asteroids you can go to the Computer Archeology site.  This site shows the data that the ROMs contained describing the vector shapes of things like the asteroids, the flying saucer, the ships, etc:

The CPU used for both games is the faster 1.5Mhz 6502A.  Only a single CPU is used for the game.  There is a small amount of RAM using 2114 static RAM chips.  There are two sets of ROMs used.  One set contains the vector shapes as described above (4k) and the other ROMs contain the program to run the game (8k?).

When these video games were designed, microcomputers were not very powerful and it required a PDP-11 to create the program that would be used by Asteroids and Battlezone.  This program was punched onto a paper tape and then loaded into an emulator.  Paper tape was like a cheap floppy disk.  Networks were not very common in the late 70’s, early 80’s, so a cheap method of copying programs was needed.  While PC began to use 5 1/4″ drives, there was also an 8″ drive that came out (the 8″ came out in the mid-70’s just before the 5 1/4″ drive).  Here is a very interesting article about the day to day work environment at Atari while working on coin-op arcade games: Pay No Attention to those Folks Behind the Curtain.  This article also includes emails from Jed Margolin, who worked for Atari and Atari Games for 13 years.

For those who have never seen paper tape or punch tape readers, they were used by the military in the 80’s.  The machine could punch 8 holes wide (there are other tape formats) to represent a byte of data:

The image above is from the crypto museum.  When the machine punched the tape the little holes were punched out at high speed like a paper punch tool.  This leaves a bunch of round circle “holes” that go into a collection bucket for emptying.  That bucket is called the “bit bucket”:

By Retro-Computing Society of Rhode Island – Own work, CC BY-SA 3.0


Vintage Computer Hardware Design


In this blog post I’m going to talk about some computers that came out in the late 70’s and early 80’s.  These are some of the earliest home computers and utilized mostly 8-bit CPUs.  Schematics are available and I’ve done some deep-diving into the circuitry to see how these machines were created.  The first microcomputer I put my hands on was the Commodore Pet.  I have used commodore 64s, TRS-80s, an Apple IIc and I own a Macintosh.  I also used many variations of the PC XT.

The Apple I

I have never actually seen an Apple I computer.  According to my research about 200 units were sold.  This computer came mostly in kit form, but Steve Jobs sold 50 units to the Byte store fully assembled.  You can download the manual, which includes a schematic in the back, by clicking here.  When you look at the schematic you can see the 6502 processor and the ROM and RAM sections.  There are some jumpers on the board that allow you to use a 6800 CPU instead of the 6502.  They’re using an MK4096 memory for RAM.  That’s a dynamic RAM chip that is organized as 4096 x 1 bit.  So it takes 8 chips to represent 8k bytes of memory.  I count 16 chips in that row of memory (click for larger image):

So that’s 8k of RAM.   The PROMs are used for booting up the machine, the schematic shows two chips.  Note 11 indicates that they are 256 x 4 bits wide, so there’s 256 bytes of bootstrap program.  This computer didn’t ship with any device to store your programs on, so you would need to interface with something like a cassette drive or paper tape reader or something.  The competition for this computer when it was built was the IMSAI 8080 or the Altair 8800.  Both of which used front panel switches to input a program.  There is a video output circuit and a keyboard can be attached to the Apple I motherboard which gave it an advantage over the competition.

The Commodore Pet

Somewhere around 1978 or so my family visited an electronic engineer that we used to be neighbors of.  He had just bought a Commodore Pet (Personal Electronic Transactor).  I had never touched a computer before this and I was amazed at all the things it could do.  We played a lot of computer games that night.  The machine used an audio cassette tape to store programs onto.  This could take up to 30 minutes to load a program (at about 75 bits per second).  You can see the cassette tape machine next to the square keyboard:

Photograph by Rama, Wikimedia Commons, Cc-by-sa-2.0-fr, CC BY-SA 2.0 fr

The schematics for this machine can be found here.  This computer also uses the 6502 CPU.  The original PET used the MOS 6550 RAM, which is 1k x 4.  The first computers came with either 4k or 8k of memory and articles on-line indicate that the chips can be replaced with the 2114.  All of these RAM chips are static ram, no refresh logic was necessary but the chips were more expensive.  You can find more history on the PET at the wiki site by clicking here.

The TRS-80

The TRS-80 was built by Tandy/Radio-Shack and it used the Z80 CPU.  You can find a schematics inside the technical manual by clicking here.  The schematics show that this computer used the 2102 static RAM.  I’m surprised that they didn’t take advantage of the dynamic RAM refresh logic built into the Z80 CPU.  The initial memory of a TRS-80 was also 4k in size:

The computer can be upgraded by replacing the chips with bigger chips and re-configuring the selector wires.  You can see the 4k or 16k configuration jumpers in places on the schematic (see X71 blocks below):

The TRS-80 also stored programs using a tape drive.  In 1977 this was the cheapest medium to store data on.  The hard drive was far too expensive for personal computer use and the floppy was still a bit out of the price range of most people.  The 5 1/4″ floppy drive came onto the scene in 1978 (click here).

Space Invaders

Space invaders was one of the first video games when arcades become all the rage.  I was in high-school when arcades opened near me and I spent many quarters on these machines.  The space invaders game used the 8080 CPU and the schematic can be downloaded by clicking here.  This computer used the Intel 2107 memory which is a 4k x 1 dynamic RAM.  The board has 16 chips, so there is 8k bytes of memory.  When looking at the schematics for space invaders, you’ll notice that the hardware is designed specifically for the game itself (since that’s all it really does).  So there’s a synthesizer circuit for the explosions and missile sounds, etc:

There’s a special video circuit too.  Apparently the monitor is mounted sideways in the video game console so the aspect ratio is vertical.  So the program that runs actually plots the pixels sideways (so the aliens appear right-side up).  You can download the assembly language for this game by clicking here.  The EPROMs for this machine contain the running program and there are straps that allow between 4k to 64k of EPROM storage:

Apparently, the game can be upgraded in the field if Midway decided to update the program.  A local technician could pull the old chips off the board and insert new chips.  This, of course, never happened because arcades went out of style in what seemed like a nano-second.  I remember my favorite arcade disappearing only 3 or 4 years after they opened.

Here’s the coin input circuit:

I traced the route and it looks like it’s multiplexed (74153 is a multiplexer) and fed into another circuit on the motherboard.  I’m betting that this drives the interrupt line and there is probably a small program that increments the coin count.  Was that displayed on the screen?  Why yes it was (see “Credit”):

The arcade game uses a black and white display and the program renders one dot per bit using 7k of RAM (224  x 256 pixels).  The color that you see in the picture is a plastic cellophane overlay that was adhered to the screen.  The Wiki on Space Invaders has an interesting story on the challenges of building this game (click here).  Here’s an interesting excerpt from the Wiki:

Because microcomputers in Japan were not powerful enough at the time to perform the complex tasks involved in designing and programming Space Invaders, Nishikado had to design his own custom hardware and development tools for the game.[10][14] He created the arcade board using new microprocessors from the United States.[12] The game uses an Intel 8080 central processing unit, features raster graphics on a CRT monitor and monaural sound hosted by a combination of analog circuitry and a Texas Instruments SN76477 sound chip.[4][15][16] Despite the specially developed hardware, Nishikado was unable to program the game as he wanted—the Control Program board was not powerful enough to display the graphics in color or move the enemies faster—and he considered the development of the hardware the most difficult part of the whole process.[10][14] While programming the game, Nishikado discovered that the processor was able to render the alien graphics faster the fewer were on screen. Rather than design the game to compensate for the speed increase, he decided to keep it as a challenging game play mechanism.

That’s all for now.  I have a collection of other computers that I’ll talk about in a future post.  If you enjoyed this blog post, please hit the like button!


Homebrew Computers


I’m going to switch it up a bit and talk about one of my other hobbies.  Electronics.  I haven’t worked with digital circuits in a while.  In fact it’s been so long that I had to do a lot of research to find out what is new the world of electronics.  Micro-controllers have come a long way.  Components have become dirt cheap over the years and way beyond the capabilities of my test equipment.  As I was looking around the world of technology, I stumbled across an article describing a guy who built a computer out of thousands of discreet transistors.  So that’s what I’m going to talk (or ramble) about in this article.


That’s the name of this homebrew computer system built by a guy named James Newman.  You can get to the website by clicking here:  

First I was intrigued by the fact that he built an entire system out transistors.  Not just transistors but NMOS transistors that are sensitive to static discharge.  I usually avoid these things, I have a difficult enough time building circuits out of TTL logic and NPN transistors.  However, if you want to build something out of a large number of transistors (like 27,000), you have to be conscious of power consumption and speed.  He has an entire story about his adventure with controlling static and burning out transistors.

As I dug through the website, I discovered that he built little circuits representing logic gates with these transistors, then he treated the circuits as components in a larger structure.  There is an LED on each input and output of every circuit, so it’s easy to visually verify and troubleshoot any hardware problems.  Here’s a sample picture of a 2-input AND gate:


His website describes that he built this machine as a learning machine.  Anyone who wants to visually see what goes on inside the computer can see the LEDs light up as the program operates.  That is a really good idea.  I think every college should have one of these for their computer engineering class.  Unfortunately, due to maintenance costs and physical space, I don’t think too many colleges would be interested in setting one of these up.
In addition to the single logic gate boards, some boards contained repetitive circuitry consisting of many gates.  Those boards are diagrammed accordingly (also with LEDs on inputs and outputs).  Here’s an example of an 8-bit logic board:


The next step up is the assembly of circuits into modules.  The connecting wires are diagrammed on the front of the board (see the red lines below) and the circuits are wired from behind.  Here’s a state machine module:


Here’s what one of these modules looks like from the backside:


The modules are mounted in frames which he has arranged in his living room (though he’s looking for a permanent public accessible location for the device).

As I mentioned before, you can follow the link and dig around through his website and learn all the fun details of how he built the machine, how long it took him and how much it cost.   For those of us who have worked in the electronics industry, his section called “Progress” has a lot of interesting stories about problems that he ran into not to mention the “Good, Bad & Ugly”.  This story made me cringe: Multiplexor Problem.  Unexpected current flow problems are difficult to understand and troubleshoot. 

So what’s the point?  

It’s a hobby.  The purpose is to built something or accomplish some task and stretch your abilities.  The goal is to experience what it would be like to construct such a machine.  Think of this as an advanced circuit building exercise.  

I’ve built microprocessor based circuits in the past (mentioned on my website:,
the megaprocessor is much more complex and more challenging than my project.  If you really want to learn how a computer operates, nothing compares to a project like this.  I have to warn readers that this is not something you jump into out of the blue.  If you have no electronics experience, start small.  I mean, really small.

I would start with a book like this:


You can find this book at Amazon or at this link:  The bookstore that I visited yesterday (Barnes & Noble) has this as well.  I browsed through a lot of the “Make:” series of books and they are very well organized.

You’ll need some basic supplies like a breadboard, wire, hand-tools, a volt meter (nothing fancy).  If you move up into faster digital circuits, or you dive into microcontrollers and microprocessors, you’ll need to invest in an oscilloscope.  This will probably be the most expensive piece of test equipment you’ll ever buy.  I still own an original Heathkit oscilloscope that is rated at up to 10Mhz.  If you understand CPU speeds, you’ll notice that this oscilloscope is not able to troubleshoot an i7 processor running at 4Ghz.  In fact, oscilloscopes that can display waveforms of that frequency are beyond most personal budgets of a hobbyist (I think that crosses over to the domain of obsessive).

Other Homebrew Systems

I spent some time searching the Internet for other homebrew computers and stumbled onto the  “Homebuilt CPUs WebRing.”  I haven’t seen a webring in a long time, so this made me smile.  There are so many cool machines on this list (click here).  There are a couple of relay machines, one in particular has video so you can see and hear the relays clicking as the processor churns through instructions (Video Here, scroll down a bit).  The story behind Zusie the relay computer is fascinating.  Especially his adventures in obtaining 1500 relays to build the machine (and on a budget).  I laughed at his adventures in acquiring and  de-soldering the relays from circuit boards that were built for telephone equipment.

There are a lot of other machines on this webring that are just as interesting.  Great stories, schematics, how to build their machine, etc.  The one machine that really got my attention was the Magic-1 (click here).  This is a mini-computer built by a guy named Bill Buzbee.  He has a running timeline documenting his progress in designing and building the computer.  Reading his notes on designing an emulator and then his issues with wire-wrapping really gives a good picture of what it takes to build a computer out of discreet logic.  Here’s a photo of the backside of the controller card:


The final machine schematics are posted here.  He used a microprogrammed architecture.  Microprogrammed architecture is like building a computer to run a computer.  This is one of my favorite CPU designs which I learned about when I bought a book titled “Bit-slice Microprocessor Design”.  Coincidentally, this book is listed in his links page under “Useful books”.  You can still get this book as new or used.  I would recommend picking up a cheap used book from Amazon.  The computer discussed in this book is based on the AMD 2901 4-bit CPU, which is a bit-slice CPU.  Basically, you buy several of these CPUs and stack them in parallel to form a computer.  For a 32-bit CPU, you would buy 8 chips and wire them in parallel.  Unfortunately, AMD doesn’t manufacture these chips any more.  The book, however, is a good read.  He also has PDF postings of another book called “Build a Microcomputer” which is virtually the same book (go here, scroll down).

Building Your Own

If you’re looking to build your own computer, just to learn how they work, you can use one of the retro processors from the 70’s and 80’s.  These are dirt cheap, so if you blow one up by hooking up the wrong power leads, you can just grab another one in your box of 50 spare CPU’s.  On the simple side, you can use an 8085 (this is almost identical to the 8080, but doesn’t need an additional +12v power supply).  The 8080 CPU was used in the original Space Invaders arcade game (see Space Invaders schematics here).

The 6502 has a lot of information available since it was used by Apple and Commodore computer companies in their earliest designs.  The Z80 is like an souped up 8080 processor.  This CPU has index registers which makes it more flexible.  There are a lot of hobbyists who have built machine around the Z80, and quite a few arcade games were built with this CPU.  The Galaga arcade game used 3 Z80 CPUs to run the game.

I suspect that over time these CPUs will become difficult to find.  Jameco currently lists them as refurbished.  If you build a project around one of these CPUs, be sure and buy extra chips.  That way you’ll have spares if the supply chain runs dry.

If you’re more advanced, you can still buy 8088 CPU’s for $3.95 each at Jameco Electronics.  This is the CPU that the first IBM PC was based on.  At that price, you can get a dozen for under $50 and build a parallel machine.  This CPU can also address 1 Megabytes of memory (which is a lot for assembly language programming), is contained in a 40-pin chip format and there is a huge amount of software and hardware available for it.

If you’re not so into soldering, wire-wrapping or circuit troubleshooting, but would like to build a customized system, you can experiment with tiny computers like the Raspberry Pie or the Arduino or Beaglebone.  These devices are cheap and they have ports for network connections, USB devices, HDMI outputs, etc.  There are a lot of books and projects on the Internet to explore.

These are not your only choices either.  There are microcontroller chips that are cheap.  Jameco lists dozens of CPUs with built-in capabilities like this one: ATTINY85-20PU.  It’s only $4.49 and you can plug it into a breadboard.  

So Many Resources Available

My website doesn’t tell the whole story of my early days of building the 8085 computer board.  I’ve actually built 2 of these.  My first board was built somewhere around 1978.  At that time, I was a teenager and computers were so expensive that I didn’t own one.  So I was determined to build one.  I had an old teletype (donated by an electronic engineer that lived across the street from my family when I was younger).  I built my own EPROM programmer that required dip switch inputs (this was not a very successful way to get a program into EPROM memory).  After I graduated from High School, I joined the Navy and purchased a Macintosh computer in 1984.  I’m talking about THE Macintosh, with 128k of memory.  Before I was honorably discharged from the Navy, I upgraded my Mac several times and had a Mac Plus with 4 Meg of memory.  My old 8085 computer board was lost in one of many moves my parents and I made between 1982 and 1988, so I decided to reconstruct my computer board and that is the board pictured on my website.  I also constructed a better EPROM programmer with a serial connection to the Mac so I can assemble the code and send it to the programmer (I wrote the assembler and the EPROM burner program in Turbo Pascal).  All of this occurred before the World Wide Web and Google changed the way we acquire information.  Needless to say, I have a lot of books!

Those were the “good ole’ days”.  Now we have the “better new days”.  I own so many computers that I can’t keep count.  My primary computer is a killer PC with 500 Gigs of M.2 hard drive space (and a 4TB bulk storage SATA drive), 32 gig of memory and a large screen.  I can create a simulator of what I want to build and test everything before I purchase a single component.  I can also get devices like EPROM burners for next to nothing.  There are on-line circuit emulators that can be used to test designs.  I’m currently evaluating this one: Easy EDA.  There are companies that will manufacture printed circuit boards, like this one: Dorkbot PDX.  They typically charge by the square inch of board space needed.  This is nice, because I can prototype a computer with a wirewrap design and then have a board constructed and build another computer that will last forever.


If you’re bored and you’re looking for a hobby.  This is the bottomless pit of all hobbies.  There is no depth you can go that would conclude your knowledge.  You can always dig deeper and discover new things.  This is not a hobby for everyone.  This hobby takes a significant amount of patience and learning.  Fortunately, you can start off cheap and easy and test your interest levels.  Otherwise, you can read the timelines and blogs of those of us who build circuits and struggle with the tiny details of getting a CPU to perform a basic NOP instruction.  I like the challenge of making something work but I also like reading about other people who have met the challenge and accomplished a complex task.

Never stop learning!