DSKY — Volume 1 — The Computer That Flew to the Moon

About This Volume

This is the entry point to an eighteen-volume deep dive on the Apollo Guidance Computer (AGC) and the DSKY — the display-and-keyboard panel through which astronauts spoke to it. Between them they form one of the most important machines ever built: the small, rugged, real-time digital computer that navigated human beings to the surface of the Moon and back, nine times. This first volume sets the stage. It explains what the machine was, sketches the people and the stakes, and previews the road ahead. It carries no circuit diagrams and assumes no prior knowledge. Readers who already know the outline and want hardware may skip to Volume 6 (architecture) or Volume 8 (the DSKY itself); readers who want the whole arc should start here.

The series ends, in Volume 18, on a workbench — with a modern open-source replica, the Open DSKY, that lets anyone set a verb, key a noun, and watch the same green numerals the astronauts watched. Everything between here and there explains why that replica is worth building.

The Eighteen-Volume Series

Vol	Title	Focus
1	The Computer That Flew to the Moon (this volume)	Orientation, stakes, the whole story in miniature
2	Why Put a Computer in the Spacecraft?	The autonomy decision; MIT’s 1961 contract
3	The MIT Instrumentation Laboratory	Draper Lab, the Polaris heritage, the cast
4	The Integrated-Circuit Gamble	Building the AGC from chips; Apollo and Silicon Valley
5	Core Rope Memory — Software You Could Hold	Woven read-only memory; erasable core
6	Inside the AGC — Architecture & Instruction Set	15-bit words, registers, timing, interrupts
7	Block I to Block II — Evolution of the Machine	The redesign and why it mattered
8	The DSKY — Display & Keyboard	The interface: display, lamps, keypad
9	Verbs and Nouns — The Language of Apollo	The verb-noun command grammar
10	The Software and the Executive	Real-time priority scheduling; restart protection
11	Margaret Hamilton and the Birth of Software Engineering	The discipline, and the people who named it
12	1202 — The Alarms That Almost Stopped Apollo 11	The descent alarms and how software saved the landing
13	Landing on the Moon — The Descent Programs	P63–P66, Don Eyles, flying the LM down
14	The Whole Mission — Command Module, LM & Fly-by-Wire	Colossus vs Luminary; the Apollo 14 fix; the F-8 legacy
15	Manufacturing the Impossible	Raytheon, the rope weavers, testing and quality
16	Legacy — How Apollo Helped Build the Modern World	ICs, fly-by-wire, software engineering, embedded computing
17	Preservation, Restoration & Pop Culture	The 2019 restoration, Virtual AGC, museums, film
18	⭐ The Open DSKY — Building the Replica	The open-source kit, the build, what it teaches

---

A Box the Size of a Briefcase

It is not much to look at. A box of magnesium alloy, roughly the dimensions of two stacked briefcases, weighing about seventy pounds and drawing some fifty-five watts — less than a household light bulb. There is no screen on it, no keyboard, no blinking lights. Those lived on a separate panel, the DSKY (pronounced “DISS-key,” for Display and Keyboard), bolted into the instrument console within the astronaut’s reach. The computer itself was tucked out of sight in a bay of the spacecraft, doing its work in silence.

What that box did was unprecedented. It held the spacecraft’s sense of where it was and where it was going — its inertial navigation — and it could steer. It fired the thrusters that turned the ship, ran the engine burns that crossed a quarter-million miles of space, and, in the Lunar Module, flew the final descent to a particular patch of grey dust while a human watched and, at the last, took the stick. It did all of this with about two thousand words of erasable memory and thirty-six thousand words of fixed program — a total storage, in modern terms, of a few tens of kilobytes. A single modern phone holds the equivalent of millions of these computers. And yet the phone has never landed anyone on the Moon.

The comparison to a calculator is the most repeated fact about the AGC, and it is true as far as it goes — but it misses the point entirely. The AGC was not a slow, weak version of a modern computer. It was a real-time control computer, an embedded machine that had to respond to the world on a deadline measured in milliseconds, juggling navigation, engine control, radar, and a human operator simultaneously, and never, ever crashing in a way it could not instantly recover from. Judged on that job — the job of not killing the crew — it was magnificent, and parts of its design are still studied by the engineers who build the computers in your car’s brakes and your aircraft’s flight controls. Volume 16 returns to this in full.

The Impossible Assignment

To feel why the machine mattered, hold the problem in your mind for a moment. In 1961 the United States committed to landing a man on the Moon and returning him safely before the decade was out. Nobody had done it. Nobody knew how.

Among the thousand impossibilities that commitment contained was navigation. The Moon is a moving target a quarter of a million miles away; the spacecraft is a faster-moving object in between; both are falling around the Earth and the Sun. To get from one to the other and back you must know your position and velocity continuously and precisely, and you must be able to change them with carefully timed rocket burns. The Earth-based tracking network could help, but radio takes more than a second to make the round trip to the Moon, and a Cold War spacecraft could not depend on a ground station it might lose — or that an adversary might deny it. The decision, early and consequential, was that the spacecraft would carry its own computer and navigate itself if it had to. Volume 2 tells the story of that decision and the contract — the very first major hardware contract of the entire Apollo program — that NASA handed, in August 1961, not to a computer company but to a university laboratory.

That laboratory was the MIT Instrumentation Laboratory, the domain of Charles Stark “Doc” Draper, who had spent decades turning the abstract mathematics of inertial guidance into hardware that worked. His team had guided the Polaris submarine missile; now they proposed to guide a Moonship. Volume 3 is about the Lab and its people — not only the famous names but the architects, programmers, and engineers who, mostly in their twenties and thirties, invented much of what we now call computer engineering because the job in front of them demanded it.

Three Gambles That Built the Machine

The AGC was defined by a handful of bold technical bets, each of which gets its own volume.

The first was the integrated circuit. In 1962, the silicon chip was barely three years old, unproven, and made by almost no one. To build a flight computer small and light enough for a spacecraft, the Lab gambled the program on it — designing the entire logic of the AGC from a single, simple type of chip (a three-input NOR gate) and ordering them in such quantity that Apollo, for a time, consumed a large fraction of the world’s entire integrated-circuit output. That appetite helped drive prices down, drive quality up, and launch the industry that became Silicon Valley. Volume 4 is the story of that gamble.

The second gamble was memory. The computer’s programs could not be allowed to fail or fade, so they were stored in a remarkable medium called core rope — read-only memory in which each bit was set, permanently, by whether a wire passed through a tiny magnetic ring or around it. The programs were quite literally woven, by hand, by skilled workers at a factory, threading copper through cores according to listings printed from the programmers’ code. Software you could hold in your hands and snap; software that could survive a rocket launch. Volume 5 is devoted to it.

The third gamble was the software — and it was here that the AGC was most quietly revolutionary. The machine had to do many things at once, on deadline, and keep running even when overloaded. The Lab’s answer was a real-time operating system built around priority scheduling: every task had a priority, and when the computer ran out of capacity it shed the least important work and protected the most important, rather than freezing or crashing. That architecture, and the discipline of building it reliably, did not yet have a name. One of the people building it, Margaret Hamilton, gave it one: software engineering. Volumes 10 and 11 are about the software and the people who wrote it.

The Eleven Seconds That Tested Everything

If the series has a single dramatic peak, it is a stretch of about eleven minutes on 20 July 1969, and within it a few seconds of genuine peril.

As the Lunar Module Eagle descended toward the Sea of Tranquility, with Neil Armstrong and Buzz Aldrin aboard, the guidance computer suddenly flashed an alarm: 1202. Then another. Neither astronaut knew what it meant; for an instant, neither did Mission Control. The descent could have been aborted right there. It was not — because a 26-year-old engineer named Jack Garman had studied the alarm codes and knew that 1202 meant the computer was overloaded but coping: shedding low-priority work, completing the vital guidance calculations, restarting cleanly. The priority-scheduled design was doing exactly what it had been built to do. On the strength of Garman’s knowledge, the flight controller Steve Bales called “Go,” and Eagle landed. Volume 12 reconstructs those minutes in detail, because they are the purest demonstration of why the machine was designed the way it was.

The alarms, it turned out, traced to a spare radar left switched on, flooding the computer with needless work — a hardware-and-procedure story as much as a software one. That the landing succeeded anyway is the whole argument for the AGC’s architecture, made in real time, with the world watching and two lives in the balance.

The Human Face of the Machine

The most famous photograph in the history of software shows a young woman standing beside a stack of program listings as tall as she is.

Margaret Hamilton led the team that wrote the on-board flight software, and she is the figure through whom the wider world now remembers the AGC’s programming. But she was one of many — a cast that included Hal Laning, who designed the scheduling architecture; Don Eyles, who wrote the lunar-landing program; Hugh Blair-Smith and the architects of the machine itself; and the hundreds of engineers, technicians, and factory workers — many of them women, both at MIT and on the Raytheon assembly floor — without whom the code would never have flown. The series tries throughout to keep that breadth in view. Volume 11 is Hamilton’s, and Volume 15 belongs to the people who built the hardware with their hands.

What This Series Will and Will Not Do

A great deal has been written about Apollo, and a fair amount about its computer, much of it excellent and some of it mythologised. This series tries to do three things that popular accounts often do not.

First, it takes the machine itself seriously as an object of engineering. Volumes 4 through 9 are a genuine technical manual: how the logic was built from NOR gates, how rope memory stored a bit in a thread, how the 15-bit processor worked, and exactly how the verb-noun interface let an astronaut in a pressure suit command a computer with sixteen keys. By the end you should be able to explain the AGC to an engineer, not merely admire it.

Second, it takes the software seriously — the executive, the interpreter, the priority scheduling, the restart logic — because that, even more than the hardware, is where the AGC was ahead of its time, and where its lessons still bite.

Third, it ends with a build. The Open DSKY (Volume 18) reproduces the panel and its behaviour in modern, open, hackable hardware — re-creating the verb-noun interface and the glow of the original, driven by a faithful simulation of the Apollo software’s behaviour. Reproducing a thing is the oldest and best way of understanding it, and the final volume is where the series stops being history and starts glowing on your desk.

The One-Paragraph Version

If you read nothing else, read this. The Apollo Guidance Computer was a small, rugged, real-time digital computer — about seventy pounds, fifty-five watts, a few tens of kilobytes — built by the MIT Instrumentation Laboratory and Raytheon to navigate and control the Apollo spacecraft. The astronauts operated it through the DSKY, a panel with a glowing numeric display and a keypad on which commands were entered as a verb (an action) and a noun (the thing to act on). The machine was a pioneer three times over: it was among the first computers built from integrated circuits, helping launch the chip industry; it stored its programs in hand-woven rope memory; and it ran a priority-scheduled real-time operating system so robust that it survived a computer overload during the first Moon landing and let Eagle set down anyway. Its software effort helped give us the very phrase “software engineering.” It is, by a wide margin, the most consequential small computer ever built — and the rest of this series is the long version, ending with a replica you can build yourself.

---

Next — Volume 2: Why Put a Computer in the Spacecraft? Before the AGC was a machine it was an argument — that a Moonship should be able to navigate itself, without leaning on the ground. Volume 2 goes back to 1961, to the decision for onboard autonomy and the contract that started it all.