1.0: My Mark-8 Computer

I've recently assembled a Mark-8 computer. This is a microcomputer based on the Intel 8008, the first 8-bit microprocessor. The computer was designed by Jon Titus and published in Radio Electronics magazine in 1974, and was one of the first computers that a hobbyist could hope to own. It inspired many in the early computer revolution of the 1970's.

2.0: What is the Mark-8 Minicomputer?

The Mark-8 Minicomputer was the first real "hobbiest" computer. (there was another computer which beat the Mark-8 by a few months, the Scelbi-8, but that was less known, and lacked the front panel controls which made the Mark-8 similar to comercial computers.) The Mark-8 was important for microcomputer revolution of the 1970's. It's significance can best be understood only by understanding the the state of computers in the mid 1970's. At this time, high-schools and colleges were teaching programming and computer sciences, but all available computers were enormous and expensive. Usually a small computer would cost $10,000 or more, and even a starter PDP-8 was around $5000. Bill Gates described how he and fellow high-school students would sneak into a local college just to play with their computer. Most couldn't even imagine a "personal computer."

At this time, digital electronics was a common hobby. The neighboorhood Radio Shack store was stocked with many more integrated circuits, than today, as well as books showing how to use them. Many amateurs could imagine building their own computer, but the processor would require a lot of chips. The advent of the 4004 microprocessor in 1971 was interesting, but then a disapointment for most. It's 4-bit word, and crazy RAM/ROM organization made it "computer-like" but far from the real computers that were prevalent. The 8008 changed this. It seemed to allow real memory organization, up to 16K for both memory and data, in one contiguous spread.

Jon Titus was a graduate student in college, who ordered the 8008 data books from Intel like many. Eager to have his own computer like the PDP-8's he'd used in school, he designed the Mark-8 circuitry. He tells his story in "http://www.his.com/~jlewczyk/adavie/mark8b.html". The beauty of his design was the inovative address latch and front panel circuit. The address load, deposit, examine, and single-step toggles made the Mark-8 remarkably similar to the expensive minicomputers that users were familiar with. This $350 computer was remarkably similar to the $5000 DEC PDP-8.

3.0: My Mark-8 Computer

I was too young in 1974 to build a computer, but I did see the pictures in later years. I got into computers a few years later with a TRS-80, followed by many other microcomputers, but was always fascinated with the older "Blinkin-Lights" computers. A decade later I worked with an old PDP-11, which often required re-loading of its bootstrap loader from the front panel. This was quite intriguing to me, so when I heard Steve Gabaly of Apalacia, NY was selling Mark-8 kits with the circuit boards and components, I had to have my own.

3.1: My Case

My computer uses the case recommended by Steve, but I didn't like the deeply recessed front panel, so turned it around. I feel this is closer to the original design from the magazine. The labels on the control panel are the same as the original by Titus. It's very tempting to label this front panel more clearly, as it's not obvious initially what the LEDs and switches are really to do. This is temporary labeling. I plan to use "dry-transfer" or "rub-on" lettering, but apparently that is getting hard to find. Temporarilly I put on clear-plastic labels (done on special paper with an inkjet printer.) The power light is far too bright -- I used a high-brightness one from Radio Shack, and it's "blinding."

The original Mark-8 was open in the back, with a power-supply that didn't fit inside the case. My large linear power-supply dissipates significant heat, so I installed two small fans, as the outer case would be quite warm after a couple hours. Notice the recessed back panel. It was meant to be the front, but I didn't like it, and it would have required me to trim a half inch or so around the pre-made front panel.

3.2: The Internals

This shows the wiring to the front panel, and the switch organization. I used a DB-25 connector so the front panel can be disconnected easilly. Not shown, but a resistor is in the shrink-wrap in the center-terminal of each switch in the switch register. This will allow me to pull-up or pull-down the input, with a 3-state TTL chip, regardless of the switch position. This will be the basis of "no bootstrap software" paper-tape reader I hope to get interfaced soon (you load start address from front switches, then the reader presents each byte, and strobes it into the "deposit" line internally.) The DB-25 connectors have since been covered with nice hoods adding to durability and reliability.

This is the rear view, with back panel off. Since taking this picture, I added small pins so a ZIF socket can be attached, to replace tne 8008 easilly. This allows testing other 8008 chips without taking apart the whole computer.

This shows the whole top of case off, again showing the layout. Notice that the recommended power supply was used, but it was too long to fit in the case. I cut it with a bandsaw so that it would fit on the case. Apparently, I'm not the first to think of this (Steve did the same.)

This shows the wiring on top of the card cage.

4.0: How to use the computer

To use the Mark-8, you load in a program in machine code via the front panel switches, then tell the computer to execute it. Output of the basic Mark-8 is limited to the 8 LED's on the front panel, which correspond to output port zero. This makes convenient for simple programs to show they are doing something.

4.1: Loading a Program

To load in a program, you place the computer in "JAM" mode (allowing you to Jam data onto the input bus, for placement into the memory.) First you enter the high and low bytes of the required address into the switches, loading each byte into the respective address latches with the "Load Address High" and "Load Address Low" switches. The LED lights of the front panel will reflect the current memory address under "HI" and "LO" respectively. Then the first byte of the program is set with the switch registers, and the "Deposit" key is pressed to deposit it into memory at the indicated address. After each press of the deposit switch, the address latch automatically increments to the next successive address, and will show whatever byte is already in that location with the "Memory Data" lights. The second byte is then set on the switch register, and the deposit switch is pressed again. With Practice, the octal byte values can be entered quickly, and deposited, at a rate of about 20 to 30 bytes per minute.

4.2: Verifying a Program/Memory

After entering all the bytes of the program, the program can be checked by again loading in the starting address. The byte currently in that location will be displayed on the "Memory Data" lights (labeled "MD".) To increment the address without changing the data, press the "Examine" switch (labeled "EX") wich will increment the address, to see the next byte, without changing it.

4.3: Running the Program

After all the bytes of a program are entered, the processor needs to be told to start, at some location. The builder's guide tells how to enter various instructions to the processor by "Jamming" an instruction op-code to the processor, but the easiest way is to "JAM" the code for the "Restart" instruction. This is a single-byte machine operation which will begin execution at one of several fixed addresses. Usually, we want to start at address "000 000" so we use "RST 0" instruction whose code is octal "005." Therefore, we set the switch registers to "005", move the switch from "JAM" to "Interrupt" then activate the interrupt momentary switch (next to the Jam/Interupt switch.) Then we can either single-step through the program, or it will continuously run, depending on the run/stop switch position.

4.4: A simple Example Program

Address:  Byte:  Mnemonic:  Comment:
000 000   104    JMP        Jump instruction
000 001   000               Low byte of address
000 002   000               High byte of address

4.5: A slightly longer program with Display

Address: Byte: Label: Mnemonic:  Comment:
000 000  006          LRA 106    Load register A with...
000 001  106                        binary 01000110 - pretty pattern
000 002  121   Next:  OUT 0      output A to output port zero (display)
                                 (Now just do a nested loop delay)
000 003  016          LRB 004    Load register B with four (outer counter)
000 004  004                      (This produces reasonable speed)
000 005  026   LoopO: LRC 0377   Load register C with 255 (inner counter)
000 006  377
000 007  021   LoopI: DECC       Decrement register C
000 010  110          JNZ LoopI  Jump if not zero, back to inner loop
000 011  007                        (low then high byte of address)
000 012  000
000 013  011          DECB       Decrement register B
000 014  110          JNZ LoopO  Jump if not zero, to outer loop
000 015  005                         (low then high byte of address)
000 016  000
000 017  012          RRC        Rotate register A right, through carry
000 020  104          JMP Next   Jump to top, display rotated register
000 021  002                          (low then high byte of address)
000 022  000

4.6: Various other programs

Following are a few other programs, in assembly code and in list form which may be of interest to others. The first link is the raw assembly code, in a form that assembles on my assembler. The second is a *.lst file, the output of my assembler, which shows the machine code and addresses.

1. memtst.asm memtst.lst A memory test program. This program writes pseudo-random byte patterns to all of memory, and then reads them back, sequentually. Any errors halt the program and display the bit error and location.

5.0: AS8: An 8008 assembler for free

There are a couple 8008 assemblers floating around the internet. I didn't like any of them, so made a simple assembler in ANSI-C. It should compile fine on any computer which has a C compiler, as there are no operating system dependent assumptions. Keep in mind this is a work in progress, and the version posted here is probably already out of date, but is a good starting point for anyone who wants an assembler.

The source code to the program is here as8.c

An assembled version that works under cygwin is here as8.exe If you don't have "cygwin" you can just get a copy of "cygwin1.dll" (available various places around the net,) put it in the same directory as the executable, and it will run in a DOS window under Windows.

The documentation for the assembler is here as8.html

6.0: SCELBAL, Basic for an 8008 computer

In 1976 a company called "SCELBI Computer Consulting" who designed the "SCELBI-8" computer published a version of BASIC that would run on an 8008 processor. The manual is available various places. I have modified this code to work with my assembler, and generates a code image identical to the code listed in the manual. I applied the 3 patches listed in the manuals and then in the "update" newsletter sent to the users, as well as a couple "non-patch" corrections in the code from the "update" newsletter.

This requires a Mark-8 with at least 8K memory, preferably 12K. I've added a modification to my mark-8 using a non-volatile 32K RAM to populate memory locations 2K-16K. Obviously you can't toggle all 8K bytes in on the front switches, so will needdownloading/loading hardware/software. I suggest either a hardware or software loader to read from a Parallel Printer Port.

For a "hardware" parallel port interface, set the starting address via front spaces, then have the parallel port lines latch their data into the switch register inputs (I added 10K resistors on the switch register output, so a TTL signal could be interfaced into the cable.) The strobe line could then be taped into the "deposit" signal after the debounce circuit. An acknowledge signal then needs to be returned, and this could be taped right out of the mono-stable multivibrator circuits of the address port (which increment the count of the address latch.)

A Software parallel port interface would be a simple loop which reads the data to an input port when a strobe occurs, and then an output port is used to send an "acknowledge" signal back to the sending computer.

I got this code from Steve Loboyko, who's web site is in links. He has originally worked on making it relocatable and ROMable, but I undid a bit of his work. My goal was initially to make it identical to the released RAM image (same location of each piece of code) until I get it debugged. I may then make it ROMable.

Keep in mind that this code has not been run. It assembles, and seems to generate the correct output as specified in the manual, but hasn't been debugged. Also, this code is constantly being modified, so the version here is probably already out of date. Ask if you really care, and I can share any fixes or corrections.

The code is here sc.asm

7.0: Recommendations for other builders

The Mark-8 is hard to build. Approximately 7500 people sent away for the construction plans, according to Jon Titus, but only about 450 people ordered the circuit boards in the 1970's. I think at least one other person fabricated circuit boards (modified for edge-card connector contacts, so a back-plane could be utilized.) The original boards were terribly hard to assemble, with non-plated through holes which required soldering the top and bottom of each IC. There were also errors in the original construction plans and board sets. The users- groups and newsletters collected corrections for dissemination to readers. Still, I suspect less than half of the original Mark-8 circuit boards resulted in a working computer. Guesses were made that 1000-2000 Mark-8's were built in 1974-1975, but I suspect this is quite high, and the number or working computers never exceeded a couple hundred. A surplus/parts electronic store "Godbout Electronics" marketed a 4K-byte RAM board, but I have no idea how many were made or sold. The Altair 8800 which came out 6 months later in "Popular Electronics" used the much improved 8080 processor, so few new computers were started after January 1975. Still, Mark-8 users argue that the front-panel controls on the Mark-8 were much better designed and easy to use. The wired backplane also was very reliable. The Mark-8 also became a bit more affordable as the price of the 1101 memory fell from $6 each to $2 each, and the 8008 price fell from $125 each, to around $60 in small quantities.

About 150 reproduction kits have been sold by Steve, but probably just a handful have been completed to date. The reproduction kit is MUCH easier to build than the original, as it has high-quality boards with plated through holes, and all components are included. Still, it takes persistance to put many hours into an obsolete curiosity. The resulting computer is many orders of magnitude less useful than an equivalently priced modern computer.

If you endeaver to complete a kit, here's what I suggest:

1. Use a case: Don't skimp on this. Yes, the recommended case is over $100, and I spent at least 60% of build time on the case, nice connectors and heat-shrink tubing. It will make the system more reliable and useable. But you don't have to get the "Bud" case as listed. I got it assuming the front panel with the kit would work without modification. It doesn't. The Bud case had very cheap screws that I eventually had to scrap. You can buy any case that's approximately the same size surplus, but don't go any smaller. It's a tight fit. I estimate that the case, linear supply, sockets, connectors, and misc. added $250 to the price of my kit. Building a Mark-8 interestingly probably costs more today than in 1974.
2. Don't cut the card-slots too deep into the wood. Every picture I saw shows the card-slots deep into the wood, so I did it too. I think 1/8th inch slots would give sufficient stability, but still allow flexion of boards a bit when the top guides are removed. This would facilitate debugging or removing IC's.
3. The molex connector leads are just a bit too big for the boards. Under "Links" below is a web site where a builder drilled out all of the holes, probably tearing off the copper pads with it. Don't do that. Just pinch the molex leads with a pliers, and they will fit fine into the holes.
4. Use sockets. I used expensive machined sockets, but even cheap sockets would be fine. While I had very little debugging to do, (just of switch connections, a single subtle solder-bridge that had to be scraped, and two flaky 1101 memory chips) assume you will be doing a lot of debugging.
5. Decoupling Capacitors: There isn't a lot of decoupling capacitors on the circuit. The -9 volt line is even less protected. I added some small tantalums on the bottom of the card cage, along the bus-wires.
6. Switch Connections: The connections to the front panel switches is not discussed well in the plans. In fact, just deciding which switches are momentary and which are toggle was confusing to me. I couldn't figure out why deposit seemed to go down, and why examine goes up. I couldn't figure out why the two on the bottom right are just labeled "A". Most of this is covered in Bryan Blackburn's construction articles at which I encourage you to visit.
7. You may notice the 0.6" wide Signetics multiplexor chip holes are just over 0.6" wide. Some cheaper sockets may fit without modification, but My machined sockets didn't fit. I sliced them down the middle with my band-saw, and the result actually looks fine.
8. Debugging: The assembly manual describes how to test and debug the memory and address latch board before even beginning the CPU/input/output boards. Consider the below debugging information by Terry Ritter under the "Links" section.

8.0: Modifications:

The Mark-8 was meant to be modified, but obviously any modifications shouldn't ruin the "Authenticity" of the vintage computing experience.

Brian Blackburn's computer had a modification so that the switch register could be read as an input port. I also implemented this, but found that it's not quite as usefull as I had hoped, but is still usefull for some reasons. The circuit is listed in one of the Mark-8 Newsletters and I may upload a diagram.

A more important modification is to allow memory expansion. The Mark-8 memory card only decodes the lower 12 bytes of the address, so the maximum memory was originally just 4K bytes. If you access the 2nd or 3rd or 4th 4K address space, you will just get a mirror image of the lower 4K space. A simple modification using a 7447 on the memory board properly turns off the board when an address over 4K is presented. There are many ways to do this, but I may upload my circuit soon.

8.0: Links

Steve Gabaly's Mark-8 Gallery The reviver of the Mark-8 has a web page of various Mark-8's, including his.

Bryan Blackburn's Mark-8 Pages Bryan may be the best known Mark-8 Expert. He located a Mark-8 on Ebay in 1999, and got it running in Spring of 2001. To get it running, he actually contacted Jon Titus, and got documentation directly from the designer. His site describes his computer, other vintage computer peripherals/systems, and his Mark-8 actually has a 4K memory board built by another company. Bryan sells a CD-ROM of Mark-8 info including all the Mark-8 newsletters, copies of SCELBAL manual along with all the update magazines and the Math and String package. He also has extra documentation which makes getting the front panel switches connected easilly.

Jon Titus' Story Jon Titus, the designer of the Mark-8, describes his story and his design.

Steve Loboyko's Site Steve appears to be a vintage electronic/computer resource, with lots of 8008 info and has made his own assembler. He is the original source for my highly-modified SCELBAL code. He also helped me get my ADM-3A terminal running lower-case. (Okay, he didn't help, he just did it. He programmed the EPROM, wired up the adapter board, and mailed it. I just plugged it in.

Terry Ritter's Mark-8 Experience This guy has the ugliest Mark-8 on the net, basically a pile of boards, slumped over by their own weight. But this computer was actually built in 1974, and the original owner describes the project and a whole lot of software he wrote. He even wrote a guide on how to "debug" the Mark-8, which he couldn't get published until the WEB allowed him to do so 20 years later. A most enjoyable site.

JLewczyk's Mark-8 Pages This guy has a Mark-8, and lots of information. It also contains the below site.

An Anonymous Mark-8 Builder This person describes his experiences building a Mark-8 from the Kit. He drilled out all board-edge connectors to fit the molex pins (would have been easier to crimp the leads as I describe) and built a back-plane out of molex connectors. A great site. (This web site doesn't name the builder, but does name his wife and kids and dog.)

Mark-8 at Smithsonian The original Mark-8 now lives at the Smithsonian, donated by the designer. The original computer did not have a power supply inside the case, and the back was left open.