DSKY — Volume 17 — Preservation, Restoration & Pop Culture

About This Volume

Most of this series has been written in the past tense. The Apollo Guidance Computer was designed, it was built, it flew, and then — as the program wound down and the machines were crated, donated, and forgotten — it stopped. For decades the AGC existed mainly as a thing you read about: a paragraph in a history of computing, a relic behind museum glass, a stack of yellowing assembly listings in an MIT basement. It had become, like the Saturn V and the lunar module, a monument rather than a machine.

This volume is about how that changed. It is about the people who refused to let the AGC stay a monument — who switched a real one back on, who typed its lost source code back into existence character by character, who built faithful simulators so that anyone with a laptop could fly a virtual descent, and who carried the thing into the popular imagination through film, photographs, and folklore. It is, in other words, about the AGC’s afterlife: the strange and genuinely moving story of a Cold War spacecraft computer becoming, in the twenty-first century, an object of open-source devotion.

It is also the bridge to the final volume. The same impulse that drove a handful of engineers to resurrect a Block II AGC in 2019, and drove a retired programmer to spend years rescuing the original code, is the impulse that puts a glowing replica DSKY on a hobbyist’s workbench today. Preservation and reproduction are the same gesture, made by the same kind of person. This volume tells how the AGC was kept alive; the next tells how you can build a piece of it yourself.

The 2019 Restoration: Switching It Back On

In 2018 a real Block II Apollo Guidance Computer — a genuine flight-type unit, not a replica — found its way into the hands of a small group of vintage-computing enthusiasts in Silicon Valley. The four principals were Marc Verdiell, a fiber-optics engineer better known to the internet as CuriousMarc; Ken Shirriff, a former Google engineer and prolific writer on the guts of old chips and computers; Carl Claunch, a retired systems specialist; and Mike Stewart, a flight-software engineer who had become one of the foremost living experts on the AGC’s internals. They had met as volunteers at the Computer History Museum in Mountain View and had already earned a reputation in the hobby with an eighteen-month restoration of a Xerox Alto. The AGC, however, was a different order of problem — and they set themselves a deadline with no give in it: to have the machine running for the fiftieth anniversary of Apollo 11, in July 2019.

What makes the feat remarkable is easy to underestimate from a distance. This was not a matter of plugging in an old computer and hoping the power supply held. The AGC had no operating manual in any practical sense; its behavior was defined by thousands of pages of MIT documentation, hand-drawn schematics, and undocumented quirks that only revealed themselves on the bench. The machine ran on supply voltages and timing that no modern equipment naturally produced. Its memory was not a chip you could read out but core rope — program data physically woven into a fabric of tiny ferrite rings, where a wire threaded through a core meant a one and a wire routed around it meant a zero. Fifty-year-old electrolytic capacitors, cold-welded connections, and components whose datasheets had long since vanished all lay between the team and a working computer.

So they built their own infrastructure around the relic. Mike Stewart recreated the original MIT/NASA ground-support and test equipment — the boxes that the AGC expected to be talking to — sometimes by reverse-engineering them from period photographs and documents, sometimes by reimplementing them in modern programmable logic. Carl Claunch built a working replica of the DSKY, the display-and-keyboard unit, so the team could see the machine’s verbs and nouns light up exactly as an astronaut would have. Ken Shirriff dug into the deepest layers — the core rope, the logic built entirely from NOR gates, the analog interfaces — and documented them in a celebrated run of long-form blog posts that became a reference work in their own right. The restoration was carried out in the open, narrated in a now-famous series of videos on the CuriousMarc YouTube channel, where viewers watched the team puzzle through failures in real time rather than seeing only a tidy finished result.

The payoff was extraordinary. They powered the AGC up. They loaded original Apollo software. They drove the DSKY and worked through real verb-noun sequences. They fed the computer simulated inputs and watched it run guidance routines — and, in the project’s emotional high point, they connected it to a lunar-module descent simulation and let the genuine fifty-year-old hardware fly a landing, throttling a virtual descent engine down toward a virtual lunar surface. To close the circle, Mike Stewart took the running computer to MIT during the anniversary and flew it there in front of some of the very engineers who had designed and programmed it half a century earlier. A machine that had been built to be used once and then retired had, against every reasonable expectation, been made to do its job again — by people who were not even born when it last did so.

The Virtual AGC Project: Rescuing the Code

Hardware was only half the resurrection. A computer is nothing without its software, and the AGC’s software had its own near-death experience.

The original guidance programs — Colossus for the command module and Luminary for the lunar module — existed by the 2000s mainly as paper: enormous assembly-language listings, printed decades earlier, surviving in a handful of archives and private collections. They were not in any usable digital form. The man who changed that is Ron Burkey, who in 2003 began what became the Virtual AGC Project, a long-running open-source effort to recreate the Apollo Guidance Computer and its software in simulation. Burkey wrote yaAGC, a CPU simulator that faithfully emulates the Block II AGC instruction-by-instruction; if you feed it the same software and the same inputs the real machine saw, it responds as the real machine did. Around it he built yaYUL (an assembler that recreates the original MIT “YUL” toolchain), a DSKY simulator, and a suite of other tools that together let a modern computer be an AGC.

But the project’s most quietly heroic act was the rescue of the code itself. To make the simulator meaningful, the original source had to exist in machine-readable form — and so it had to be transcribed, painstakingly retyped from faded printouts, listing page by listing page, then proofread against the originals until the reconstructed source assembled cleanly into the exact binary the real computer had run. This was digital archaeology in the most literal sense: rescuing a body of work from the brink of disappearing, one character at a time. The Virtual AGC repository today holds source for as many missions as could be recovered, and the cleaned-up Apollo 11 listings became famous a second time when a developer, Chris Garry, posted them to GitHub in 2016, where they could be read, forked, and marveled at by millions.

And marvel they did — because the transcribed listings carried something no specification ever captures: the voices of the people who wrote them. The original MIT programmers had filled their comments with jokes, exasperation, ’60s references, and even literary quotation, and all of it survived the transcription intact. The most celebrated example is the file that handles the lunar module’s engine ignition, headed:

BURN_BABY_BURN -- MASTER IGNITION ROUTINE

The phrase came not from the engineers’ own bravado but from the culture around them: programmer Peter Adler later explained that it echoed disc jockey Magnificent Montague’s mid-1960s catchphrase “Burn, baby! BURN!”, a slogan that by 1967 had taken on a charged second life in the news. Elsewhere a programmer, reaching for a stopgap routine, simply wrote what every coder since has felt:

# TEMPORARY, I HOPE HOPE HOPE

There is a comment that reads # OFF TO SEE THE WIZARD ..., another that asks the crew to PLEASE CRANK THE SILLY THING AROUND, and a Shakespeare allusion or two for the scholars to argue over. These lines delight modern readers precisely because they puncture the marble-monument version of Apollo. The code that landed humans on another world was written by tired, funny, human people working to a deadline — people who, it turns out, were not so different from anyone who has shipped software under pressure since.

Surviving Hardware: The AGC in Museums

Alongside the working restorations and the living code, a population of genuine AGCs and DSKYs survives behind glass, scattered across the world’s great collections.

The Smithsonian National Air and Space Museum holds the deepest trove. Its collection includes an unflown but fully functional Block I Apollo Guidance Computer transferred from NASA in 1972, along with multiple DSKY specimens — some test units, at least one of which actually flew. The museum has lent units widely; one DSKY that flew aboard Apollo 16 has been displayed on loan at the U.S. Space & Rocket Center in Huntsville, Alabama. As an institution holding thousands of Apollo-program artifacts, the Smithsonian has been the natural anchor for the AGC’s physical legacy.

The Computer History Museum in Mountain View, California, is the other essential stop — and not by coincidence the institution where the 2019 restoration team first met as volunteers. Its galleries place the AGC where it belongs in the broader story of computing: as one of the first machines to use integrated circuits in large numbers, a real-time embedded computer decades ahead of its commercial descendants. MIT, where the machine was designed at the Instrumentation Laboratory (later the Draper Laboratory), preserves both hardware and the institutional memory of the project, and was the fitting venue for the restored AGC’s anniversary homecoming. Beyond these, AGCs, DSKYs, and core-rope modules turn up in collections from the Kansas Cosmosphere to the Steven F. Udvar-Hazy Center, each a small node in a distributed monument to the program.

The AGC in Pop Culture

If museums kept the hardware, popular culture kept the story — and the AGC, improbably, became a recurring character in it.

The turning point was Ron Howard’s Apollo 13 (1995), which dramatized the 1970 near-disaster with an obsessive attention to procedure that made cockpit switch-throws and computer readouts into genuine suspense. The film taught a mass audience that spaceflight was, at bottom, a matter of people working calmly through checklists with their machines — and that the small grey box and its keypad were not set dressing but lifelines. HBO’s From the Earth to the Moon (1998), the Tom Hanks–produced miniseries, went deeper still, devoting screen time to the engineering and the ground crews and giving the guidance computer and its software something close to their due. Two decades later, Damien Chazelle’s First Man (2018) put the viewer inside the lunar module for a harrowing, rattling descent, and Apollo 11 (2019) — a documentary assembled almost entirely from restored, large-format archival footage and mission audio — let the real event speak for itself, the controllers’ voices and the DSKY’s glow needing no embellishment.

Out of that footage and folklore, two cultural artifacts in particular have outgrown the program itself.

The first is a photograph. In 1969 an MIT Instrumentation Laboratory photographer captured Margaret Hamilton, who led the laboratory’s software-engineering division, standing beside a stack of program listings as tall as she was — the printed-out flight software for which she and her team were responsible. For years it was an obscure institutional promo shot. In the 2010s it went viral, becoming one of the most shared images in the history of computing: a single, instantly legible icon of the fact that landing on the Moon was a software achievement, and that a woman led the team that wrote it. Hamilton, who helped popularize the very term “software engineering,” became through that image a folk hero of the discipline; she received the Presidential Medal of Freedom in 2016. The photograph did what no textbook had managed — it made the invisible labor of programming visible, and gave it a face.

The second artifact is a number: 1202. During Apollo 11’s final descent, the DSKY repeatedly flashed program alarms — 1202 and 1201 — as the overloaded computer shed lower-priority tasks to protect the guidance it absolutely had to keep running. The mission held because the software had been designed to fail gracefully under exactly that kind of overload, and because a young engineer named Jack Garman, on a list of memorized alarm codes, told Mission Control it was safe to go. (The full story of that design and that moment belongs to Volume 12.) In the decades since, “1202 alarm” has hardened into a piece of geek folklore — a shorthand for grace under computational pressure, the moment a computer nearly aborted the landing of the century and the engineers trusted their software enough to press on. It is the kind of detail that the AGC’s modern admirers treasure, and it explains a great deal about why the machine inspires the devotion it does.

A note on what this volume deliberately does not show: the films above are wonderful, but their posters and frames are copyrighted, and there is no need for them. The real hardware — the AGC trays, the glowing DSKY, the hand-woven core rope, the listings beside Margaret Hamilton — is more evocative than any movie still, and it belongs to all of us.

The Open-Source, Maker Ethos

Pull these threads together — the bench restoration, the rescued code, the simulators, the museum pieces, the viral photograph — and a single character emerges behind all of them. The AGC has been kept alive not by NASA, not by Raytheon, not by any institution with a budget line for it, but by enthusiasts: people who do this work for love, in the open, and who give the results away.

That ethos is now self-sustaining. Ron Burkey’s Virtual AGC is open source, so anyone can download yaAGC, assemble the original Luminary listings, and fly a descent on a laptop tonight. Chris Garry’s GitHub upload means the actual flight code — comments and all — is a few clicks away, forkable and quotable. Ken Shirriff’s and the CuriousMarc team’s documentation turned the machine’s once-secret internals into freely readable explanations. Each act of preservation lowered the barrier for the next person, and the community compounded. The AGC stopped being a thing only a museum could hold and became a thing a hobbyist could understand, simulate, and ultimately rebuild.

Which is exactly where this series has been heading all along. The same open-source maker spirit that resurrected a Block II AGC in a Silicon Valley garage, and that rescued Colossus and Luminary from the brink of oblivion, is the spirit that put an affordable, buildable DSKY replica within reach of anyone with a soldering iron and a weekend. The preservation story and the reproduction story are one story. Having seen how the original was kept alive, we are ready to build a piece of it ourselves.

Next — Volume 18: The Open DSKY — Building the Replica.