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
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
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.)
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 ProgramA very simple Program, (the first one written on a Mark-8) is a simple loop. A jump instruction that jumps to itself. Here's an example:
Address: Byte: Mnemonic: Comment: 000 000 104 JMP Jump instruction 000 001 000 Low byte of address 000 002 000 High byte of addressThis can be loaded into memory starting at address zero, then single-stepped or continuously run to verify the processor runs. After entering the program in memory with the "JAM" button activated, and "RUN/STEP" on "STEP", enter 005 (the restart 0 instruction) on the switch register, switch the "JAM/INT" switch to the interrupt position, and then activate the interrupt momentary switch, next to the "JAM/INT" switch. Then each time you activate the step momentary switch, the processor executes one step. Switch the "RUN/STEP" to "RUN" and the computer will continuously run.
4.5: A slightly longer program with DisplayHere's a slightly longer program, which outputs to the front-panel LED's a rotating patern, giving visual indication the processor is running:
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 000This is a program I commonly run for display on my machine. It is easy to load (around 60 seconds) and gives a classic "blinking-lights" display.
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.
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:
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.
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.