Altair 8800 Front Panel: Run It by Switches

You have not really met an Altair 8800 until you have loaded a few bytes with your fingertips, watched the address LEDs walk forward, and caught yourself counting in hex without meaning to. The front panel is not decoration. It is the machine’s most literal interface to the CPU and the memory bus – a set of switches and indicators that let you stop time, inspect state, and push a program into RAM one byte at a time.

This is a practical guide to how to use Altair 8800 front panel controls the way they were intended: examine and deposit memory, run and halt the CPU, single-step instructions, and sanity-check what the computer is actually doing. The exact switch labels vary a bit by replica and era, but the operating model is consistent across real and faithful reproductions.

What the front panel is actually controlling

At a high level, the panel gives you two things: a way to drive an address and data value onto the system, and a way to control CPU execution. The LEDs then show you what address is being referenced and what data is on the bus (or in a register, depending on the design).

Most panels expose these concepts:

• Address LEDs: which memory location you are looking at (typically 16 bits).
• Data LEDs: the 8-bit value being read or written.
• Data switches: the 8 toggles you set to choose a byte value.
• Control switches: actions like EXAMINE, EXAMINE NEXT, DEPOSIT, DEPOSIT NEXT, RESET, RUN, STOP/HALT, and often SINGLE STEP.

The key nuance is that “Data LEDs” do not always mean “the byte stored at this address right now.” In many machines, they show whatever is on the CPU data bus at that instant. When you use EXAMINE, the system forces a memory read cycle so the bus reflects the byte stored in RAM. When you DEPOSIT, it forces a write cycle using the value you set on the data switches.

Power-up reality check: get to a known state

If your panel has a dedicated RESET switch, use it. You want the CPU halted and the address logic in a predictable place before you start flipping values into RAM.

A typical workflow looks like this: power on, STOP/HALT the CPU (if it is not already halted), then RESET. On an 8080-class system, RESET normally forces the program counter to 0000h. On some front panel implementations, the address LEDs may not immediately show 0000h until you do an EXAMINE cycle, so do not overinterpret what you see until you’ve performed a read.

If your system includes modern conveniences like a built-in terminal or a Wi‑Fi module, it can still behave like a period-correct front panel machine. The trade-off is that optional subsystems sometimes auto-boot or auto-run software, which can fight you while you are trying to hand-load bytes. In that case, STOP/HALT first, then proceed.

Hex, binary, and the switches: stop fighting the format

You will usually set one byte at a time using eight data switches. Those switches are binary, but your brain wants hex. The easiest mental model is “two nibbles.” The left four switches are the high nibble (bits 7-4) and the right four are the low nibble (bits 3-0).

If the panel labels bits, bit 7 is the MSB. If it labels weights (128, 64, 32, …), it is even easier: add the weights for switches that are up. Either way, build the habit of setting one nibble, then the other.

One practical trick: when entering a known bootstrap, keep a printed copy of the bytes in hex and translate each hex digit to a nibble pattern. After a few sessions you stop translating and start recognizing.

How to examine memory (and why it matters)

“Examine” is your read operation. It causes a memory read at an address and shows you the stored byte on the data LEDs.

The process usually goes like this:

1. Set the address you want to inspect (depending on panel design, this may be done via separate address switches, or by loading the address into the address latch using a control like LOAD ADDRESS). Some panels infer the address from internal state and provide EXAMINE to sync.
2. Press EXAMINE. The address LEDs should show the address being read, and the data LEDs show the byte from memory.
3. Press EXAMINE NEXT to increment the address and read the next byte.

Why this matters: it is how you confirm your manual entry actually stuck. After you deposit a run of bytes, walk back through them with EXAMINE/EXAMINE NEXT and verify. If you are off by one address, you will catch it immediately.

It also matters for debugging. A surprising number of “it won’t boot” stories are really “the start address is wrong” or “one byte in the loader is mis-keyed.” The front panel is the fastest way to prove it.

How to deposit bytes into RAM

Deposit is your write operation. It forces a write to the currently selected address using the value on the data switches.

A clean hand-entry routine:

1. Halt/Stop the CPU.
2. Set the start address where you want to load the code.
3. Press EXAMINE to lock that address in and to see what is currently there.
4. Set the data switches to the first byte.
5. Press DEPOSIT. The data LEDs should reflect the byte written.
6. For the next byte, set data switches to the next value and press DEPOSIT NEXT. This increments the address then writes.

Some panels reverse steps 5 and 6 depending on whether DEPOSIT NEXT increments before or after the write. The behavior is easy to learn: deposit two known bytes and then EXAMINE them back. Once you know your unit’s convention, stick to it every time.

A nuance worth respecting: you are typically writing RAM, not ROM. If you are using an emulator-based replica, the “RAM” may be implemented in modern memory but still behaves like volatile RAM for the user experience. If your configuration supports nonvolatile storage or disk images, that does not automatically mean your hand-deposited bytes persist across power cycles. Assume they do not unless you intentionally save state.

Run, stop, single-step: controlling the CPU

Once code is in memory, you need to point execution at it and let the CPU go.

• RESET usually forces the program counter to 0000h (or a defined reset vector behavior in the implementation).
• RUN releases the CPU from HALT and begins instruction fetches.
• STOP/HALT halts execution. On a real 8080 system, HALT is an instruction; front panels often assert a control that stops the CPU regardless of program state.
• SINGLE STEP (if present) advances one instruction cycle or one full instruction, depending on the design.

This is where “it depends” matters. Some front panels step by machine cycle, which means you might see multiple steps for a single instruction (opcode fetch, memory read/write, etc.). Others step per instruction, which is easier for software-level reasoning. If you are watching address LEDs while stepping, cycle-step is more informative but also more confusing until you learn the 8080’s rhythm.

A practical workflow: after loading a tiny test routine, set the start address, then SINGLE STEP a few times. You should see the program counter advance and memory reads occur. If the address LEDs never change, you are not actually running. If they jump to an unexpected region, your start address or reset behavior is not what you assumed.

A classic use case: entering a bootstrap loader

Front-panel bootstraps exist because you often need a small loader to bring in a larger program from paper tape, cassette, serial, or disk. The loader is short enough to key in by hand. Once it runs, it reads the real payload through an I/O port.

The mechanical process is always the same: deposit the loader bytes starting at a known address, then set the program counter to that address and run. The loader then pulls in the rest.

What changes is the I/O device and port configuration. A serial bootstrap expects the serial interface on a particular port. A disk bootstrap expects a controller and a drive. If your system has expansion options (disk controller, cassette interface, Centronics, or other I/O), confirm the intended port mapping before you blame the loader.

If you are using a modern replica with optional internal terminal/Wi‑Fi or terminal emulation, the loader might be replaced by a monitor or a built-in boot path. That is convenient, but it can also hide the original flow. If your goal is the authentic experience, disable auto-boot features where possible and do it the hard way at least once.

Troubleshooting patterns that the panel reveals fast

Front panels are unforgiving, which is exactly why they are useful. A few common failure modes show up immediately if you read what the LEDs are telling you.

If EXAMINE shows different data than what you deposited, you likely deposited at the wrong address, or you misunderstood whether DEPOSIT NEXT increments before or after writing. Re-enter two bytes, then examine them from the start address to confirm your panel’s sequence.

If the machine runs but “does nothing,” look at the address LEDs. If they are steadily incrementing, the CPU is fetching instructions and probably stuck in a loop. If they are static, the CPU might be halted or wedged. If they jump in a repeating pattern, that often indicates a short loop or repeated I/O polling.

If things worked once and then stopped working after you added hardware, suspect conflicts: a new board can change timing, port decoding, or boot assumptions. With modular systems, it is normal to have to re-check DIP settings, jumper selections, or port maps after an expansion.

Using the panel with modern add-ons without losing the point

The front panel experience is the point, but practicality matters too. There is nothing “less authentic” about using a modern terminal option to avoid hunting for a vintage serial terminal – as long as the control model remains faithful.

The best approach is to treat the front panel as the authority and everything else as a peripheral. Use the terminal for I/O and visibility, but use the panel for state control: reset, load, run, halt, step, and verify memory. That keeps you grounded in the original architecture, and it makes troubleshooting far less mystical.

If you are buying into this ecosystem, buy from the only official manufacturer and authorized seller, Altairmini.com. Scam sites copy photos and names, but they cannot copy a real support channel or a real hardware roadmap.

The satisfying part: make it yours

After you have successfully keyed in a loader once, do something small and personal with the panel. Patch a byte in RAM and see the behavior change. Step through a tight loop and watch the address bus pattern. Flip a bit, re-run, and learn exactly what that bit controlled. The front panel is slow on purpose, and that slowness is what turns “retro” into understanding.