The Altair sprang to life as a construction project in the January and February 1975 issues of Popular Electronics magazine, designed by a fellow called Ed Roberts.

Using a soldering iron and a kit of components, for around $439 you could build your own Altair. This was about two weeks income for the average household at the time, so still a pretty big deal. But any other computer of the time would cost at least ten times that much.

Ed Roberts only expected to sell a few hundred kits, but much to his surprise he sold thousands in the first months.

There was something in the air; the computer revolution was willing itself to happen.

The article, and the Altair, also stimulated the creation of the Homebrew Computer Club, a place where Steve Wozniak and Steve Jobs would go to hang out with like-minded souls, and eventually gave rise to Apple, and the iPhone probably lurking in your pocket.

Construction was not for the faint-hearted, and many of the kits were not successfully assembled. MITS also started selling pre-assembled machines for $621 as people came to recognise the exciting thing about computers is software, moreso than building hardware.

Here's a more detailed history, and another detailed history. And here is a third excellent history

Bill Gates and his partner Paul Allen wrote the very first Basic interpreter (high level language) for the Altair, the start of Microsoft.

The original Popular Electronics article is large and slow to load, but gives a good flavor of the time.

The MITS Altair ran an Intel 8080 processor at 2Mhz — the direct ancestor of the processor likely inside your desktop or laptop computer, but several million times less powerful.

It came standard with 256 bytes of RAM (not, gigabytes, not megabytes, not kilobytes — just 256 bytes). The architecture allowed for up to 64k of RAM, but anything so large was just crazy-talk; not the least because the memory would lose its contents every time the machine was powered down.

The Altair, like all entry-level computers of the day, had no screen and no keyboard.

It also had no operating system.

Instead, it featured banks of lights and switches. The processor would be manually halted, the memory would be loaded with whatever program and data you wanted (laboriously toggled-in through the switches), then the processor would be re-started and immediately execute whatever instructions it found.

These days we're accustomed to slow boot-sequences, but in reality computers instantly come to life and start executing instructions. It's just usually the operating system that takes control and makes the boot-sequence slow. No operating system, no start-up delay.

The lack of a screen or keyboard obviously meant you weren't going to be playing Call of Duty or surfing the web (there wasn't one), but Altair programmers rejoiced in extreme satisfaction even just getting the LEDs to flash in a certain way, and some did go on to write useful business software and entertaining games on the Altair.

The point of it wasn't necessarily achieving an amazing outcome — the point was in mastering the technology.

Today's computers (and phones) all work on exactly the same principle as the MITS Altair and its contemporaries. It's just the truth is hidden, and so people's understanding is incomplete. For them, there's a level at which things operate "by magic".

With the Altair, you go behind the curtain.

The Intel 8080 was (is!) is very simple CPU.

Only 78 instructions — that's it.

You may have worked with languages like Python or Javascript. These are fairly high-level computer languages, where you express yourself at a fairly abstract level and a lot happens "by magic".

Below that are more powerful but primitive languages, such as C. Computers don't really understand these languages; instead they're handled by another piece of software magic called a "compiler" which converts it into a form the machine can really handle.

Below that is a language called "assembler", which is customarily as low as programmers go (and even then, only relatively few of them). Assembler is a language that works at the level the computer hardware works, but even it is not in a form the computer can directly handle.

The reality is something called "machine code" -- ones and zeros that the computer hardware can directly process.

Your Windows computer, your Macintosh, your smartphone — they all execute machine code. That's all they do. Everything else is a layer of magic applied on top of that reality. Every programming language, web browser, operating system, game, word processor, video software — they all are machine code when the computer runs them.

Machine code is the truth and reality. Everything else you see in a computer is just fancy dress.

Machine code programming isn't all that hard. Here's a link to a (slow loading) original manual for the MITS Altair that starts assuming you know nothing about computers, and takes you through to writing your own program.

Even better, a reformatted version of the same manual, by Kevin Cole.

Also a very useful link to the 8080 instruction set reference card.

And the full Intel 8080 Programming Manual.

Here's a very useful tutorial by Mihai Pruna.

Here's the simulator itself, written entirely in Javascript and with thanks to Martin Maly and Chris Double for their 8080.js Intel 8080 emulator.

To use, it's identical to getting your pre-assembled MITS Altair shipped from New Mexico, opening the box and plugging it in. So read the ALTAIR manuals for info on what the switches do, and read the 8080 instruction set reference for info on the machine language.

Important things to know:

1.  First turn it on

2. There's a slide-out at the bottom which will let you "see inside" the processor and inspect registers and memory. This does not exist on real Altairs. You can also load a local binary file into RAM (see below).
 
Click here to LAUNCH SIMULATOR

What you can do

The Intel 8080 is a "Turing Complete" machine, which means anything that any computer can do, a MITS Altair can do too (subject to memory limitations).

In reality, here's a couple of sample goals you could set yourself:

• A program that adds two numbers, say 3 and 7, and displays the result on the LEDs
• A program that reads the switches, and in the LEDs displays the same pattern
• A program that starts at zero and displays a binary count in the LEDs
• A single LED on, all the others off, and the active LED sliding up and down the display, over and over

You'd start by reading the original Altair manual (slow to load), which explains everything from the very start in good detail. Understand what the switches do, understand the Intel 8080 instruction set, and get coding.

Or for something much easier on the eye, Kevin Cole's reformatted version of the same manual.

It turns out ChatGPT is actually pretty good at generating 8080 code, and will even convert it to hex for you. But it's really, really bad at creating even simple programs, and gets register assignment and flag side-effects completely wrong. It also calculates jump addresses incorrectly. It's useful as an "assembler", but for Quetzalcoatl's sake do not trust any sequence of instructions it suggests or any jump destination.

Known differences

There's a few areas in which the simulation is not completely accurate:

• Single-step on the Altair operated on a per-cycle level, whereas the simulator operates per-instruction. This is a characteristic of the 8080 library being used.
• The updating of the LEDs and reading of the switches is not as speedy or as immediate. This is because the HTML DOM is a lot slower than actual pieces of wire.
• Some of the status LEDs are not faithfully simulated.
• The Protect switch is not implemented.

Load binary file

Once the machine is switched on, the RAM is set to random contents and your program must be entered through the front-panel switches.

As a teenager, I spent many hundreds of hours happily toggling in addresses and opcodes in binary, but perhaps this is not for everybody. So there is also an ability to load a binary file into RAM from your 21st century computer (max 256 bytes).

The binary file is a straight binary file, one byte per byte, no encoding.

You could create such a file using your favorite editor in hex mode, or using a very nice free Macro Assembler created by Alfred Arnold, in which case you need a bin file as output by his P2BIN utility.

Who am I and why did I do this?

I designed and built my own "switch panel" 8080-based computer in the 70's, and taught myself machine code. It wasn't an Altair, but it was somewhat similar. After that I got a degree in computer science and eventually started my own software company, launching a product we developed and sold around the world over a period of 20 years before selling out to a US multi-national.

These days I'm passionate about kids understanding what goes on inside their smartphones -- they live in a digital world, they are digital citizens, so best they understand and control technology rather than the other way around.

My "main" project is S2JS -- an educational webapp that aims to help kids move beyond the (insanely excellent) Scratch programming environment from MIT, and introduce them to a more conventional programming language in the form of Javascript.

There's really no overlap between S2JS and this Altair emulator. Kids these days don't want to flip front panel switches (well, not many of them, anyway). But I'd noticed there was no online Altair emulator and it seemed like an omission that needed rectifying, so here it is.

I never owned or used a real Altair, so if you're an old Altair switch-flipper and notice some aspect of this simulation which isn't accurate, please do let me know.

Or if you're involved with kids who have been learning Scratch and need somewhere to go next, please point them towards S2JS.