Front Panelthe personal computer that started an industry, working

1 What you are looking at

Two rows of lamps and a row of switches. That is the entire machine as far as you are concerned. There is nothing else to look at and nothing else to type on.

Why a running program looks like a blur. Because the lamps follow the bus, a running program does not display a tidy number. It displays a smear whose brightness is how often each wire was high. This panel reproduces that by sampling every bus cycle, which is why it looks like the photographs instead of like a debugger. Load a program below and watch.

2 A bit is a switch

Up is one, down is zero. That is not a metaphor for how computers store numbers. On this machine it is literally the storage.

Flip the data switches on the panel above — numbered 7 to 0, the right-hand eight; the bottom row when the panel folds to fit a phone — and watch this change. On a phone you can drag your finger across them.

The panel groups its switches in threes, and the manual talks in octal, because three bits make exactly one octal digit. Reading 10 111 010 as 272 is something you can do in your head. Reading it as 186 is not. Hexadecimal won later, but in 1975 this machine was built for octal and the spacing between the switches still says so.

3 A byte is an instruction

The same eight switches that spell a number also spell a command. Which one it is depends entirely on whether the processor happens to read that byte while it is looking for an instruction.

The encoding is regular, and the regularity is the whole trick. In the range 100 to 177 octal, the middle three bits pick where a byte goes and the last three pick where it comes from. That is 63 different move instructions from one pattern you can hold in your head. The one slot that would have meant MOV M,M was pointless, so they gave it to HLT.

Try 01 000 111. That is MOV B,A: destination 000 is B, source 111 is A. Now change just the middle three bits and watch the destination change while everything else stays put.

All 256 of them fit on one sheet of paper. The panel card puts the switches and the lamps on its first page and every opcode in octal on its second, generated from the same decoder this page runs, and it prints on A4 or US Letter.

4 A program is bytes in order

Put one instruction at address 0, the next at address 1, and keep going. Then tell the processor to start at 0. There is no more to it than that, and there never has been.

—

The machine has no sound hardware. It can still play you a tune. In April 1975, at an early meeting of the Homebrew Computer Club, Steve Dompier stood a transistor radio next to his Altair and played the room a song. What the radio picked up was the interference thrown off by the address bus, and by choosing how long each loop took, Dompier chose the pitch. Turn the radio on under the panel and run Music of a sort. On real hardware this is interference from actual wires, so an emulator normally has nothing to reproduce: the bus has to be modelled closely enough that there is something for a radio to hear in the first place. This one already samples every bus access to drive the lamps, so the tone is counted off address line A7 while the program runs. I have not found another browser Altair that does it, and would be glad to be shown one. Stop the machine and it stops mid-note. Dompier's radio is where Legibility Used to Be Free begins: a piece on machines that could not hide what they were doing, and on what went when the lamps went.

Dompier found the trick by accident. His first tune for the club was “Fool on the Hill”. Writing about it in the May 1975 People's Computer Company, he said a sort program was running when the radio beside the machine began to buzz, and he wrote down “My first peripheral device!!!” He also said the Altair was shy at its first recital and “refused to power up”: the wall sockets were dead, and a long extension cord and half an hour fixed it. Lee Felsenstein, remembering the night long after, wrote that someone knocked the plug out of its socket. On Daisy Bell the two accounts differ a little too. Dompier has it in the encore; Felsenstein has him telling the room to wait, and then it played.

Gates read about it. In July 1975 MITS's newsletter, Computer Notes, ran a note by Bill Gates. He said the best Altair demos he had seen were the ones that make music from the signals on the bus, and of Dompier's article he wrote, “He doesn't explain why it works and I don't see why. Does anyone know?” The same note lists a second way to make music: send one bit of an output port through a capacitor to an amplifier and switch it on and off fast.

5 Give it a keyboard

Toggling in fourteen bytes to add two numbers is a good way to understand a computer and a terrible way to use one. The fix, in 1975, was to bolt on a serial card and a Teletype, and then feed the machine a program that could read what you typed.

Below is a Model 33 Teletype attached to the machine's 88-2SIO serial card, and a language to run on it: Palo Alto Tiny BASIC, by Li-Chen Wang, 1976. It is 1,920 bytes. It fits in the same memory you have been depositing bytes into by hand.

The other BASIC, and the company it started

Tiny BASIC is on this page because Altair BASIC cannot be. That one was written for this machine in early 1975 by Bill Gates and Paul Allen, who did not own an Altair and never touched one while writing it. Allen had already written an Intel 8008 simulator that ran on a PDP-10 time-sharing system for an earlier venture; he adapted it to the 8080, and the two of them wrote and tested the interpreter against a simulated Altair on Harvard's mainframe. A fellow student, Monte Davidoff, wrote the floating-point routines.

Allen then flew to Albuquerque with the interpreter on a paper tape, and realised on the flight that they had never written the thing that reads a paper tape. He wrote a bootstrap loader in 8080 machine code before the plane landed. In his own account it was 21 bytes of octal, scribbled on a steno pad in the last minutes of the flight and toggled in the next morning. That is the kind of program the walkthrough on this page has you toggle in, through the same switches, though the loader MITS printed is sixteen bytes. The first thing Altair BASIC printed was MEMORY SIZE?, and Allen's next test, PRINT 2+2, answered 4. Gates and Allen later made a bet over who could write the shortest bootstrap loader. Gates won.

MITS licensed it, and Gates and Allen founded Micro-Soft in Albuquerque in April 1975 to sell it. Altair BASIC was the first product Microsoft ever shipped, and the hyphen went away later. Ten months after that, Gates wrote the letter in the next chapter.

The button below puts Tiny BASIC there for you. The walkthrough called Switches to BASIC does not: it has you toggle in the sixteen-byte loader that reads the tape, and then makes you wait for the tape. That is how the 1,920 bytes actually arrived, and it is the join between the panel above and the Teletype below.

A saved machine keeps every register, all of memory and the boards in the cage. It comes back stopped, where you left it, and does nothing until you press RUN. Disks stay in their drives and are not part of it.

Once it answers, try PRINT 2+2. Then try PRINT 355/113, which is the classic approximation of pi and here returns 3: Tiny BASIC has integers and nothing else. Floating point would not have fit. For something longer: 10 A=1, 20 A=A*3, 30 IF A<1000 GOTO 20, 40 PRINT A, then RUN.

This is not a recording. The BASIC you are typing at is real 8080 machine code, assembled from Li-Chen Wang's published source by a build step in this project's repo, executing on the same emulated processor the switches drive. Stop the machine on the panel above while BASIC is running and it will stop mid-sentence.

6 Make it yours

You have made it add two and two a byte at a time, and watched a language arrive down a wire. This is the part where you write something of your own and keep it. Three steps, and the machine marks each one by reading what it printed.

1. 1. Run one that works

   Countdown is four lines long and does exactly what its name says. Type it in, send RUN, and watch the screen.

   Type it in and run itCheck the screen

2. 2. Change one thing

   Line 10 reads 10 FOR I=10 TO 1 STEP -1. Type that line again with a different number in place of the first 10, which replaces it, then send RUN. It counts from wherever you told it to.

   Go to the TeletypeCheck the screen

3. 3. Write one

   No listing this time, just the job: print the even numbers from 2 to 20, one on each line. NEW clears what is already there. Everything you need is in Countdown: a loop, a variable and PRINT. There is more than one right answer, and the machine does not care which one you use.

   Go to the TeletypeCheck the screen

Then keep it. Save it puts it in this browser, Copy a link to this program puts the whole listing in a URL you can send to somebody, and the punched-tape button writes the file a real Altair would have read back.

7 Give it a disk

Everything so far disappears when the power goes off, and comes back only by hand or by tape. A disk ends that. MITS sold one for the Altair, an eight-inch floppy drive and a controller, and a machine with them loads its own software, an operating system included. The front panel is left with one job: starting it.

Three steps, the way an owner did them

1. Put the controller in the cage. Its two boards, the PROM card that holds the loader, and a second 88-EC expander: a CPU, a serial card, four 16K boards, the PROM card and the controller come to nine slots, and one expander stops at eight. Fit the disk system does it, and What was in the box shows the cage it makes.
2. Put the CP/M disk in drive A.
3. Start the loader. On the panel, set the address switches to 376 000, which is FE00 in hexadecimal, press EXAMINE, then RUN. Boot the disk does all three for you. MITS called the PROM that does the reading a disk bootstrap loader, which is where the word comes from; the button starts whatever disk is in drive A, CP/M or not.

The loader lives in a PROM on the card. It reads two sectors off the first track into the bottom of memory and jumps to them, and those two sectors read the rest: CP/M's command processor, its disk operating system and the part written for this machine. About two seconds later the Teletype prints 62K CP/M 2.2 and a prompt, A>. The drives show what the controller is doing, and the Teletype's title bar shows it too, since that is where you will be typing.

Things to type

What the drive is doing

The disk turns at 360 revolutions a minute. Each of its 77 tracks is cut into 32 sectors by holes punched through the disk, which makes it a hard-sectored floppy, and a sector holds 137 bytes, 128 of them data. The controller tells a program which sector is passing under the head, with a pulse 30 microseconds long as each one begins. The ring on each drive lights the sectors going past, so it turns while the machine runs and stops when it stops.

Then the bytes arrive, one every 32 microseconds, which at two megahertz is 64 of the processor's clock cycles to take each one, and nothing waits. A read loop that is too slow gets no error. It gets the wrong bytes, the sector's checksum fails, and it has to wait a whole revolution for the sector to come round again. That is emulated too, from the timings in MITS's disk manual.

Where the software came from

CP/M is Digital Research's, built for this page from DRI's own source by the same assembler that builds Tiny BASIC. Built that way it matches the copy DRI shipped byte for byte, apart from the six bytes of serial number DRI stamped into every copy it sold. DRDOS, Inc., which bought Digital Research, has granted the right to use and distribute CP/M. The utilities on the disk, among them PIP, ED and ASM, are DRI's too.

The BIOS, the part of CP/M that DRI left to each machine's owner, and the loader in the PROM are this site's own, written from DRI's guide and MITS's disk manual. The disk is in the format of the real Altair disks, so MITS's own boot PROM starts it, and so does SIMH, the long-running simulator of historic computers. Save it as a file and it runs there too.

MITS's own disk software, Altair DOS and Disk BASIC, is not here, because no one has been found who holds its rights today. It does run on this emulated controller, and that is how the controller was tested: Disk Extended BASIC 4.1 and Altair DOS 1.0, both from 1977, MITS's own boot PROM, and Burcon's CP/M for the Altair from 1980 all run on it, and none of them was consulted when its timing was written.

More disks

Other people keep libraries of Altair disks, in the same format as the ones here. Download one, then drop it on a drive or use Open a .dsk file. A disk with CP/M on it boots from drive A. A disk that only holds files goes in drive B, next to the system disk.

• Mike Douglas's eight-inch shelf is the largest. It has Zork, a games disk with Microsoft BASIC and Lunar Lander, Adventure, WordStar, SuperCalc, the BDS C compiler, every version of MITS Disk BASIC and Altair DOS. Archived copy.
• The Altair Clone downloads, also Mike Douglas's, carry many of the same disks for the Altair Clone replica. Archived copy.
• Peter Schorn's collection for SIMH packs MITS's BASICs, Altair DOS and Burcon's CP/M into zip files. Unzip them first. Archived copy.

Zork, Lunar Lander and Adventure from those shelves are booted by this page's PROM in its tests, and each one starts. Some programs expect a video terminal and send it codes that a Teletype prints as they come. The rights to most of these disks are no clearer than MITS's, which is why they are linked here and not copied. If a shelf moves, the Internet Archive's copy of its page is linked beside it.

Play Zork, or run anything else

1. Download the disk. Zork is zork.dsk on Mike Douglas's shelf. The table below has two more.
2. Put it in drive A. Drop the file on drive A, or press Open a .dsk file under it. This replaces the disk in drive A, so if you wrote anything to the CP/M disk, press Save as a file first. CP/M disk puts a fresh one back.
3. Press Boot the disk, which lights up once a disk is in. These disks bring their own CP/M, so the Teletype prints 56K CP/M and a 1980 or 1981 copyright, not this page's 62K CP/M 2.2.
4. At A>, type the program's name and press Return.

Keep it

Whatever you write to a disk here stays in this browser for next time. Save as a file writes the disk out as a .dsk image, and Open a .dsk file puts one back, from here or from anywhere else in this format.

With a disk, the panel's work each morning came down to one address and two switches: EXAMINE 376 000, RUN. That is where the front panel's own story stops. What people did with the machine once it could load its own software is the next two chapters.

8 Talk to CP/M

In A program is bytes in order your program had the machine to itself: it read the switches and lit the lamps, and nothing else ran. Under CP/M a program is a guest. It asks the operating system for everything, a character, a line, a file, and always the same way: a number in register C, and a call to address 5.

Boot a fresh CP/M disk puts a new copy of the CP/M disk in drive A and starts it. The programs in this chapter are on it, as source and ready to run. A disk you already wrote to may be a copy from before they were added, so if you want to keep it, press Save as a file under drive A first.

The agreement

Digital Research split CP/M in two. The part that knows the hardware, the BIOS, was written for each machine; this page's is its own. The part a program talks to, the BDOS, was Digital Research's and the same everywhere. So a program that only ever calls address 5 does not care whose computer it is on. The tests prove it the long way round: this disk's FIB.COM runs unchanged under Burcon's CP/M of 1980, on Burcon's BIOS. The whole agreement is a handful of addresses:

And these are the calls this chapter's programs make, out of the thirty-nine CP/M 2.2 offers:

Run them

Printing a number with no divide instruction

To print 46368 you need its digits, and the usual way is to divide by ten. The 8080 cannot divide. So FIB takes 10,000 away as many times as it will go, and the count is the first digit; then 1,000, then 100, 10 and 1. Taking away is done by adding a negative number with DAD, which sets the carry flag for as long as the answer stays at or above zero:

; DIGIT: DE HOLDS MINUS A POWER OF TEN. ADD IT TO HL UNTIL HL WOULD
; GO BELOW ZERO. WHILE IT FITS, DAD SETS THE CARRY; THE FIRST TIME
; IT DOES NOT, TAKE BACK THE COPY SAVED BEFORE TRYING.
DIGIT:  MVI     B,'0'
DLOOP:  PUSH    H               ;A COPY, IN CASE THIS ONE DOES NOT GO
        DAD     D
        JNC     DGONE
        INX     SP              ;IT WENT: DROP THE COPY
        INX     SP
        INR     B
        JMP     DLOOP
DGONE:  POP     H               ;ONE TOO MANY: HL AS IT WAS

Assemble one yourself

That last check earned its keep while this chapter was being written. A label called TITLE, a word Digital Research's assembler reserves, made it skip a line and move every address after it. This page's assembler did not mind, the two sets of bytes disagreed, and the label was renamed.

Watch it run with DDT

DDT is Digital Research's debugger, on the disk with the rest. It loads a program and lets you read it back as instructions, run it one at a time, and look at memory. DDT's prompt is a dash.

The programs, and how each was checked, are in src/cpmasm in this site's repository and in the engineering notebook.

9 Write it in C

Assembly language names the machine's instructions one at a time. C lets you say what you want done, add these up or print that, and a compiler writes the instructions for you. Leor Zolman's BDS C did that on machines like this one from August 1979, and it runs here the way it ran then: on the machine itself, from a floppy, and not quickly.

Boot the C disk fits the disk system if the cage needs it, puts the C disk in drive A and starts it. It replaces whatever was in drive A, so if you wrote to a disk there, press Save as a file under it first. The C disk is this page's CP/M with the compiler, its linker and a debugger added, and the programs below as source and ready to run. Then type into the Teletype, as with the CP/M disk.

hello, world, three ways

Kernighan and Ritchie opened their 1978 book on C with a program that prints hello, world, and it has been the traditional first program ever since. This machine can say it three ways, and each is on this page.

Run what is on it

Every program on the disk comes compiled, so you can run it straight away, and as source, so you can compile it yourself. Each one prints a line first to say what it is doing.

Compile one yourself

Half a minute for three lines of C is what a 2 MHz 8080 reading an eight-inch floppy takes, and nothing here is sped up. People did this all day.

How MANDEL does it with whole numbers

The Mandelbrot set is complex numbers, squared and added over and over, and this machine has neither fractions nor a multiply instruction. So the program lets 128 stand for 1.0, which makes 64 a half and -256 minus two, and does all its sums in 16-bit integers. Squaring is the danger: 16 bits hold numbers up to 65,535. The program never squares anything until it knows it is smaller than 2, which is 256 here, so the biggest square it ever takes is 255 times 255, 65,025. That fits with 510 to spare. The compiler's library does the multiplying in software, and that is where the two minutes go.

Find the bug

SQUARES is wrong on purpose. CDB, BDS C's debugger, can stop it inside a function, show its variables by name and step through it a line at a time. Compile it with -K, which asks the compiler to leave hooks for the debugger, and link it with L2 instead of CLINK.

Asked for ten, fill made nine: its loop runs while i < n - 1, and it should run while i < n. That is the most common bug there is, off by one, and a debugger found it by showing the data rather than by reading the code.

Why this page can hand you a copy

BDS C was sold, and then given away. On 20 September 2002 Leor Zolman released all of it, compiler, linker, library, utilities and documentation, into the public domain. The L2 linker was Scott Layson's, and his source says it is public domain too. So the C disk carries them, which is more than this page can do for Zork or MITS's disks. How the debugger was unpacked, and how every program on the disk was checked, is in the engineering notebook.

Forth, from the Forth Interest Group

Forth is a language you talk to one word at a time, and you can add words of your own. The Forth Interest Group, a society of its users, published release 1.3 for the 8080 as assembly source, and the file is dated 18 July 1981. Its header says the group’s publications are public domain and may be passed on with this notice, so this page builds Forth from that file, on the same disk system, and hands you the disk:

ALL PUBLICATIONS OF THE FORTH INTEREST GROUP ARE PUBLIC DOMAIN. THEY MAY BE FURTHER DISTRIBUTED BY THE INCLUSION OF THIS CREDIT NOTICE: THIS PUBLICATION HAS BEEN MADE AVAILABLE BY THE FORTH INTEREST GROUP, P. O. BOX 1105, SAN CARLOS, CA 94070

Boot it, and at A> type FORTH. It answers 8080 fig-FORTH 1.3. Numbers go first and the word that uses them goes after, so 2 3 + . prints 5 OK. To teach it a word, type : SQ DUP * ;, then 7 SQ . prints 49 OK. Type BYE to go back to CP/M. Forth keeps its screens on a disk of its own, so for those put a blank disk in drive B and type DR1. The source is the published fig-FORTH listing, forth130.asm, and src/forth/README.md says what was fetched and how the build was checked. The file needs small fixes before any assembler will take it. They are made at build time and listed there, and the file itself is left as it was published.

10 1976: two answers to the same question

Software had been a business for twenty years by 1975 — Computer Usage Company was founded in March 1955 to write it for other people’s machines — but it had been sold to institutions, by contract, along with the hardware. The Altair is where software began being sold to individuals, and where it began being copied by them. Both answers to that were written for this machine, within months of each other.

Both men were right about something. Gates's complaint became an industry worth trillions. Wang's joke supplied the word and nothing else: what became the legal machinery behind Linux is copyleft as Richard Stallman built it in the mid-1980s, a licence that uses copyright to compel the freedom it grants, and which Wang's two lines — a joke in a source listing, with no terms in it — could not have enforced against anybody. Fifty years on, the argument has not been settled so much as split into two industries that need each other.

So why does this page run Wang's BASIC and not Gates's?

Because it can. Tiny BASIC's source carries a notice that says you may copy it, so this page assembles it from that source and ships the result. Altair BASIC has never carried one.

To be exact about how strong that notice is: the listing says @COPYLEFT, ALL WRONGS RESERVED, in 1976, before the word or the licences that came after it. It is a plain-words permission, not a licence a lawyer would have drafted, and we have not found a formal one. Later printings of the listing may carry different notices, and we have not read them all. We rely on the notice as written. If you know more about it, write to us at the address below.

That is not the same as it being lost. For Microsoft's fiftieth anniversary in 2025, Gates published the Altair BASIC source himself, as a scan of the original dot-matrix printout. You can read the code that started the company. What was not published with it was a licence, so reading it is all anyone can safely do. Microsoft did put a BASIC on GitHub under the MIT licence around the same time, and it is a real open-source release, but it is the MOS 6502 version, for a different processor entirely. It will not run on the machine above.

So the answer is technical rather than sentimental. This emulator could run Altair BASIC tomorrow: it is a verified 8080 with 64K and the right serial card, and the paper tape reader on this page is the exact mechanism the thing was loaded with in 1975. What is missing is not the capability or the code. It is the one line of permission that Li-Chen Wang wrote and Microsoft, fifty years on, still has not.

So: thank you, Li-Chen Wang. He wrote ALL WRONGS RESERVED as a joke at the top of a listing in 1976, and it is the only reason there is a working BASIC on this page at all. Everything above runs because one person decided, before there was a word for it or a licence to point at, that his program should stay free to copy. The joke has outlasted the machine it was written for.

What this site itself is licensed under

The words and pictures on this site, and the manuals and notes we wrote, are under Creative Commons Attribution 4.0. The emulator code is under the MIT licence. Both stop at the edge of what is not ours: the Intel, MITS, Digital Research, Li-Chen Wang and other third-party programs, manuals and recordings on the page keep whatever terms they came with, and the sources list says which those are. Credit us as frontpanel.dev with a link.

What is waiting on a licence

Some things are missing because nobody has said we may ship them. If you hold the rights to one of these, or know who does, please write to cisco@frontpanel.dev. A yes in writing is all it takes. We add the program, credit you, and say on this page who agreed.

• Altair BASIC. Microsoft holds the rights and has not published a licence. Tiny BASIC stands in for it.
• Micro-Chess, by Peter Jennings. His own site says its derivatives are MIT licensed. The Altair port was later published under other names, so we want his written word that it is covered.
• Zork. The game source was released, but nothing that runs it on an 8080 carries a licence we can point to. The disk chapter links to copies instead.
• Colossal Cave and Super Star Trek for CP/M. Some sources are free. No build for this processor has a licence.
• MITS Altair DOS and Disk Extended BASIC. We have not found who holds the rights.
• The Fool on the Hill. Dompier's first tune at the Homebrew Computer Club was a Beatles song, and it is still in copyright, so this page plays Daisy Bell instead. If you can grant the rights to a beeping 1975 arrangement, say so (Homebrew Computer Club newsletter, May 1975).

11 How this was built, and what is honest about it

What is emulated, exactly

Where it departs from the original, on purpose

• On a screen wide and tall enough to hold it, the panel is the real four-row arrangement at the original's proportions: lamp diameter is about three tenths of the column pitch, the first status lamp sits just over twelve per cent of the panel's width in from the left edge, and the face is 2.54 wide to 1 tall. All three are measured off a head-on photograph. The lettering is small because it was small.
• That needs about 1360 by 760. Below it the type would fall under nine pixels and stop being readable, so the panel folds instead and a note under the machine says so. Where the real layout does fit, a switch offers it either way: accurate, or folded and enlarged if you would rather read it comfortably. There is no such switch on a phone, because there is nothing there to choose between.
• The accurate layout also drops the octal digits printed under the switches. They are a reading aid this site added and no Altair had them, so they stay in the readable layout, where the point is to help, and come off the accurate one, where the point is the machine.
• Folded, the sixteen split into the two banks people already name, the control switches move up beside them, and SENSE SW. has nowhere to go. The dashed leader lines come off too, because once the rows wrap they would point at the wrong lamp. DATA and ADDRESS headings, which the original never printed, come back, because wrapped rows need naming.
• Folded, the power switch also comes first rather than last. The original puts it at the far left of the bottom row; on a phone the switch that turns the machine on has to be in reach without scrolling, and that matters more.
• The WO lamp is active low on real hardware and printed with a bar over it, so it is lit during reads and dark on a write. That is correct here, and it looks wrong until you know.
• An original needed a STOP then RESET after power-on to reach a sane state. This one resets cleanly, because that quirk is a fault rather than a feature.
• SLOW throttles the clock so you can watch single cycles. The earliest machines left that switch position blank.
• The Teletype prints faster than 110 baud. Ten characters a second is historically right and unwatchable. The sound of it does not follow the screen. The clatter runs on its own clock at ten strikes a second no matter how fast the text arrives, because 480 percussive events a second is a buzz rather than a clatter, and because that is what the machine did: the hundred-millisecond cycle was the printing rate, so a Teletype fed faster than it could print simply did not go faster. The bell, the carriage return and the line feed are exempt and always sound, since they happen once a line rather than once a character.
• The serial card never drops a character. A real 6850 holds one received byte, and a second byte arriving before the first is read destroys it and raises the overrun flag; here the receive path is a queue, so a paper tape, a cassette, a pasted paragraph and a replayed recording all arrive whole. The chip's behaviour is written and tested (setSerialRate, tests/sio-overrun.test.mjs): give the receiver a rate in bits a second and it becomes the single register the datasheet describes, overrun flag and all. Nothing on this page turns it on, because a page that loses a byte of your tape at 300 characters a second is teaching the wrong lesson.
• There is no light mode. The machine sat in a dim room with red lamps and that is the only setting in which any of this looks correct, so the page commits to one and does not offer the other.

The lamps, in one paragraph

The lamps are wires, not a display. On MITS's own drawing 880-105 each one hangs off its bus line through a single 220 ohm resistor — no latch, no buffer — so while a program runs they carry the blur of everything the bus did that frame, and this page draws exactly that by sampling every cycle. MITS put it plainly in the operator's manual: while running, the lamps “may appear to give erroneous indications”. That blur is the machine working.

The rest of the evidence has its own page: the engineering notebook — the parts list checked against the panel, the four switch colours, the full lamp circuit and the RL-21's own datasheet, this page's loader against the three MITS printed, and where the panel's actual size comes from. Every measurement, every document, and the dead ends too.

Sources

• Intel Component Data Catalog, 1978 — the 8214 priority interrupt control unit, in Intel's own words and as text: “8 Priority Levels”, a current status register, and a comparator that issues an interrupt only for a higher priority than the one being serviced. That is the rule this page describes. The words up to seven deep are this page's own, not Intel's, and are still owed a source.
• MITS price list, 1 April 1975 — the list the prices above come from, as text rather than as a scan. It reads “8800 Altair 8800 Computer S 439 00 S 621.00”, which is where $439 and $621 come from, and it is readable so a gate can check that rather than take it on trust.
• Altair 8800 Theory of Operation Manual & Schematics — MITS, Inc., 1975. Where EXAMINE, DEPOSIT, the ready line and the RUN/STOP flip-flop are described by the people who built them.
• Dunfield Altair archive — scans of the Operator's Manual, Assembly Manual, Theory of Operation and the parts/price lists.
• Altair 8800 Assembly Manual — the build instructions, and the source of what the basic kit shipped with.
• Altair 8800 Operator's Manual, Part 3 — switch and lamp semantics.
• Altair BASIC Reference Manual — MITS, 1975. Appendix A has the three bootstrap loaders and the toggle-them-in procedure; Appendix I says the cassette format carries no checksum.
• bitsavers, MITS 8800 — the bus definition, and the card manuals for the 88-2SIO, 88-PMC and 88-ACR this page emulates. The 88-VI/RTC manual lives on deramp.com and classiccmp.
• MITS Altair 88-PIO Card Manual, 1975 — the parallel card, read in full for the emulation: the even control address and the odd data address above it, the two status bits (“If DI1 is high, the input device has sent data”), the two interrupt enables, and the jump to location 70 octal when the board is strapped to the processor's own interrupt line. An image scan with no text layer, so it was read by OCR at 300 dpi.
• Martin Eberhard, Loading Basic with the 88-PIO Board — 6 June 2013, corrected 15 December 2019. Where the card's BASIC 4.x address comes from, 004 with data on 005, and the reason this page's parallel loader reads the card once before it starts: the card holds a byte until software takes it, and threading a tape into a reader strobes one in.
• Litronix RL20/RL21 data page — a 1975/76 distributor databook scan, and the only located source for the panel LED's 0.7 millicandela rating and 180° viewing angle.
• MITS Altair computers, Fonts In Use — the typeface identification, from a Computer History Museum specimen.
• Dompier's music listing — as he published it in the People's Computer Company newsletter, May 1975, after playing it at the Homebrew Computer Club on 16 April.
• Homebrew Computer Club newsletter, volume 1, issue 3 — May 1975; the club thanks Steve Dompier for playing “Fool on the Hill” on his Altair at the April meeting.
• People's Computer Company, May 1975 — Steve Dompier's own account of the recital: the radio, the dead wall sockets and the extension cord. The scan's text is rough.
• Lee Felsenstein, Homebrew Computer Club, FoundSF — his memoir of the club, written long after; the knocked-out plug and the order of the tunes.
• MITS Computer Notes, volume 1, issue 2 — July 1975; the Gates note on the music demos, the second way to make music, and the MITS-MOBILE seminars.
• Forrest Mims III, The Altair Story, Creative Computing, November 1984 — the mock-up on the cover, the prototype lost at Kennedy Airport, and the naming meeting.
• Les Solomon, Solomon's Memory — his own telling of the name and of the lost shipment, read from the Wayback Machine's copy of the Atari Archives page.
• Cromemco I/O News, September-October 1980 — Cromemco's own account of how the S-100 bus got its name.
• Paul Allen, Microsoft's Odd Couple, Vanity Fair, 2011 — his account of the loader, MEMORY SIZE? and PRINT 2+2.
• Shugart 8-inch drive, disk insert and latch close — micropolis, Freesound, 2022, released CC0; the door sounds are shaped to its latch.
• Kill the Bit — Dean McDaniel, 15 May 1975, original listing.
• 8080 CPU diagnostics — the suite used to verify the processor.
• CP/M 2.2 manual, section 5 — “CP/M 2 System Interface”: the thirty-nine BDOS functions, and the addresses a program is written to, 0000H, 0005H, 005CH, 0080H and 0100H.
• BD Software, BDS C — Leor Zolman's own page: first sold August 1979, released into the public domain 20 September 2002, and the distribution the C disk is built from.
• BYTE, September 1981 — Jim Gilbreath, “A High-Level Language Benchmark”, the sieve SIEVE.C runs, and its answer: “1899 is correct”.
• Palo Alto Tiny BASIC 2.0 — Li-Chen Wang, translated to Intel mnemonics by Roger Rauskolb, 1976.
• MITS company history — the collected account of the four founders, the calculator crash, the $60,000 loan, the lost prototype and the Pertec sale, with a footnote trail into Forrest Mims's and Les Solomon's own tellings. The chapter Where it came from leans on it and says so.
• S-100 bus history — the draftsman's connector, the clone makers' naming problem, Garland and Melen's 1976 coinage, and IEEE 696-1983. The sidebar in What was in the box rests on it.
• Reimer, "Total share" — Ars Technica, 2005 — where the 25,000-units figure comes from; this page quotes it as the estimate it is.
• RR Auction, lot 7011 — serial 222514K, sold $3,328; the FAQ's price and serial data point.
• Computer History Museum catalog 102626725 and Smithsonian NMAH object 334396 — the museum holdings the FAQ points at.

Built by Cisco Caceres. If you want the other end of the same story, you can train a language model in your browser.

12 What was in the box

An Altair was a bus in a case. What it could do was exactly which cards were plugged into it, and nothing else. The kit arrived with no memory at all, and no way to talk to anything, so the first thing every owner did was start buying boards.

The two primary documents disagree, and this page prints both rather than picking a winner quietly. The January 1975 Popular Electronics launch article describes the basic computer as having 256 words. MITS's own later promotion prices those 256 words as something you add: Altair Computer plus 256 words of memory (save $45.00) only $497.00, which is $439 plus the 88-MCS card's $103 less $45, and that arithmetic only works if the computer alone has none.

Both can be true of different configurations sold months apart, which is the likeliest reading. The card cage above starts empty because the arithmetic is the harder evidence to explain away and because an empty machine is the more interesting one to press. This page used to state the empty version flatly, as though the launch article did not exist.

Why 256 and not some rounder number: the 1K static board holds eight Intel 8101 chips, each 256 words by four bits, so two chips make one 256-byte bank and the board can be bought a quarter-stuffed. MITS treated that as an ordinary configuration: the assembly manual's IC-installation step says “The basic 8800 kit is provided with 256 words of memory”, that this means only two 8101s are fitted, and then walks the builder through adding chips 256 words at a time. So 256 is not a product tier, it is the smallest number of chips that makes a working bank.

So here is the cage. Take the serial card out and the Teletype stops, because nothing drives the port. Take the memory out and Tiny BASIC will not fit, which is the entire reason anybody bought a memory board. The boards this page cannot honestly emulate are here too, marked, explaining themselves. Prices are MITS's own, from the list dated 1 April 1975; the famous $397 is the January 1975 magazine figure and appears in no MITS document.

And the cage counts, because MITS counted: “Basic unit has 4 slots available, one of which is used up with CPU Board.” Three free, in a machine where the disk controller alone was two boards and 64K of memory is four. The 88-EC expander bolted four more slots to the bus for sixteen dollars, up to sixteen in the case, and the machine this page runs by default already needs one — try pulling it. Boards had to agree with each other too: each memory board was strapped by hand to its own address range, and the assembly manual walks through the hole you get in the address space when a partly-filled board is placed ahead of a full one (p.78). This page straps them for you, from zero up, which is where the manual tells you to aim anyway.

010 000  076 200  MVI A,200   the enable byte: display on, picture at 000 000
010 002  323 016  OUT 016     send it to port 0E
010 004  333 377  IN 377      read the sense switches
010 006  323 017  OUT 017     send them to port 0F
010 010  303 004 010  JMP 010 004   back to read them again

64K of memory fitted and a serial card, so there is somewhere for BASIC to live and something for it to talk to. 7 of 8 slots taken, counting the CPU board.

Configure it as a base machine Put everything back Copy a link to this cage

The connector outlived the company

Every card above plugs into the same 100-pin edge connector, and that connector is the Altair's longest-lived invention. It was not designed so much as picked: an unnamed MITS draftsman chose a military-surplus 100-pin connector from a parts catalog and assigned signals to pins more or less arbitrarily. Then the clone makers arrived, built to the same slots so they could sell into Altair systems, and found themselves marketing products for the “Altair bus” — their competitor's name. Harry Garland and Roger Melen of Cromemco coined S-100, for “Standard 100”, and talked Processor Technology into adopting it on a flight to a computer show in August 1976. Cromemco's own 1980 account says Garland suggested the name on a TWA flight to the Atlantic City show, and that Bob Marsh of Processor Technology, on the same flight, agreed after being woken from a nap. The name stuck, dozens of manufacturers built for it, and in 1983 it was formalized as IEEE 696: the microcomputer industry's first standard bus, born as one company's parts-catalog shortcut. This page does not emulate the bus's electrical timing, and says so in How this was built; what it borrows is the idea the connector proved, that a computer could be a cage anyone could fill.

13 Where it came from, and where it went

The machine above was not built by a computer company. It was built by a model-rocket electronics firm in Albuquerque that was losing the calculator war and had one bet left.

MITS — Micro Instrumentation and Telemetry Systems — was founded in the autumn of 1969 by four people: Ed Roberts, Forrest Mims, Stan Cagle and Robert Zaller, to sell telemetry kits for model rockets. Mims wrote the article that started it, a tracking light for night-launched rockets in the September 1969 Model Rocketry; Roberts wanted to call the company Reliance Engineering and was talked out of it. Calculators made it a real company: by 1973 it had 110 employees running two shifts and sold every unit it could build. Then the semiconductor houses began selling single-chip calculators under their own names, and by early 1974 Roberts could buy a finished calculator in a store for less than his parts cost him. Bowmar, the biggest name in the business, went bankrupt. Texas Instruments won the price war and still lost sixteen million dollars doing it. MITS, down to twenty employees, was not going to outlast the companies that made the chips.

The bet was a $60,000 bank loan and an order for a thousand Intel 8080s at $75 each, a fraction of the chip's list price, which is what made a $397 computer kit arithmetic instead of fantasy. Roberts and his chief engineer Bill Yates finished the one prototype in October 1974 and shipped it by Railway Express to New York, to be photographed for the January 1975 Popular Electronics cover. It never arrived. Forrest Mims wrote that it was “apparently lost or stolen at Kennedy Airport”; Les Solomon of the magazine said the shipper went bankrupt with it. The magazine needed a machine to photograph right away, and Mims wrote that Yates “put together a non-functional mock-up” and shipped it to New York. A second prototype was built later and sent on. So the machine on the cover that started the industry is a non-working shell wearing a dress panel, and production machines used a different board layout anyway. The notebook's typeface note is physical evidence of exactly that gap: the cover shell wears lettering no shipped panel wore.

Orders arrived faster than machines could be built. In 1975 MITS fitted out a camper van, the MITS-MOBILE, with an Altair and a Teletype, and after three weeks in California it wrote that its nightly seminars were drawing “crowds of 200 plus”. In March 1976 David Bunnell, a MITS technical writer, organized the World Altair Computer Convention in Albuquerque: seven hundred people from forty-six states and seven countries, the first convention personal computing ever had, weeks after the open letter in chapter 6 was written. By 1977 sales reached six million dollars a year.

That was the year it ended. Pertec, a maker of disk and tape drives, bought MITS in 1977, and the name was absorbed within a few years. Roberts left the industry he had started, went to medical school, and spent the rest of his working life as a small-town doctor in Georgia. The machine's legacy had already left the building: the 100-pin connector on its boards became the industry's first standard bus, and the two young men who wrote its BASIC kept the company they had founded to sell it.

14 Questions people ask

Short answers, each one traceable to a source. Where the record is genuinely contested, the answer says so rather than picking the better story.

15 Words used on this page

Bus

The bundle of wires the processor uses to name an address and move a byte. The lamps are soldered to it.

Byte

Eight bits. One setting of the eight data switches, 7 to 0.

Octal

Base eight. Three bits make one octal digit, which is why the switches are grouped in threes.

Opcode

The byte that says which operation to perform. Everything after it is data for that operation.

Program counter

The processor's bookmark: the address it will read from next. RESET sets it to zero.

Sense switches

Address switches 15 to 8, the magenta-handled half. A running program can read them at port 255, which is how Kill the Bit is played.

M1

The status lamp that lights while the processor is fetching the first byte of an instruction.

HLTA

Halt acknowledged. The processor has executed a HLT and stopped.

88-2SIO

The serial card that let an Altair talk to a Teletype. Emulated here at ports 16 and 17.

Paper tape

How software arrived before disks: punched holes on a roll, read at ten characters a second.

Bootstrap loader

A few bytes you enter by hand whose only job is to fetch the rest. Memory was empty every time the power went off, so before an Altair could read a tape it had to be told, by hand, how to read a tape. Sixteen bytes on this page; MITS printed twenty.

Machine cycle

One trip to the bus: the processor puts an address out, and a byte goes in or comes back. An instruction takes one to five of them. The lamps are wired to that bus, which is why they show cycles rather than instructions.

Latch

A circuit that catches a value and holds it. The eight status lamps are fed by one on the processor board, which grabs the status byte at the start of every machine cycle, so they step once per cycle where the address lamps run free.

Flip-flop

A latch holding a single bit. The RUN/STOP flip-flop is the one that matters here: it is what the STOP switch sets, and until it is set the front panel switches do nothing at all.

WAIT

The lamp that says the processor is stopped and the panel has the machine. Deposit and examine only work while it is lit.

Status lamps

The row reading INTE, PROT, MEMR, INP, M1, OUT, HLTA, STACK, WO and INT. They report what kind of cycle the processor is in: reading memory, writing, fetching an instruction, talking to a device, acknowledging a halt.

Momentary switch

A switch that springs back when you let go. The eight control switches are momentary and rest in the middle; the sixteen data switches and the power switch stay where you put them.

Teletype

A Model 33 Teletype: a keyboard and a printer on one heavy frame, connected by a serial line. It printed ten characters a second onto a roll of paper, and it was how you talked to a computer before screens were cheap.

Dress panel

The printed metal face of the machine, the part with the lettering on it. It is separate from the sub-panel behind it that the switches and lamps actually mount to.

PROM

Programmable read-only memory. Written once with a programmer, erased with ultraviolet light, and untouched by the power switch, which is what made it the cure for retyping the bootstrap loader every morning. Lives in sockets, 256 bytes a chip.

S-100

The Altair's 100-pin card connector, after the industry renamed it. Clone makers hated saying the "Altair bus"; Cromemco's founders coined "Standard 100" in 1976 and IEEE made it official as IEEE 696 in 1983. What was in the box tells the story.

Slot

A position on the bus a board can plug into. The base machine had four, one spent on the CPU board; the $16 88-EC expander added four more. Capability was literally how many of these you had filled.

Open bus

What you read from an address where no board answers: the bus pull-ups float every line high, so it reads 377. Not zero, and the difference matters, because 377 is an instruction.

Interrupt

A signal that makes the processor stop what it is doing and run a service routine, instead of being asked politely by a program that has to keep checking. The 88-VI board carried it to the Altair, with eight levels and a vector per level.

Homebrew Computer Club

The hobbyist group that met in Menlo Park from March 1975. An Altair prompted the first meeting; a copied tape of Altair BASIC handed out at a later one prompted Gates's open letter.

Floppy disk

A flexible magnetic disk in a card sleeve, eight inches across on the Altair's drives. It turns under a head that is lowered onto it to read or write, and lifted off when nothing needs it, because it wears where it touches.

Track and sector

Where a byte is on a disk. A track is one ring, at one position of the head; the Altair's disks had 77. A sector is a slice of a track, marked on these disks by a hole punched through them: 32 to a track, 137 bytes each.

CP/M

Digital Research's operating system for 8080 machines: a command line, a file system and a set of utilities, the same on any machine whose owner supplied the small part that knew the hardware.

BIOS

That small part: the routines CP/M calls to read the keyboard, print, and read or write one sector. Everything machine-specific lives here, which is how one CP/M ran on many different computers.

BDOS

The part of CP/M that programs talk to, the same on every machine: put a function number in register C and call address 5. The BIOS beneath it is the part written for each machine.

Compiler

A program that turns a language written for people, such as C, into the machine's own instructions. BDS C does it in two passes on the machine itself.

Debugger

A program that runs another one under its control: it stops it where you ask, shows its variables and memory, and lets it go a step at a time. CDB does this for C, DDT for machine code.

Copyleft

Licensing that keeps a work freely shareable. The word appears in Li-Chen Wang's 1976 source listing.