This computer changed the world—and you’ve never heard about it

NASA needed a supercomputer to get us to the Moon, and it had to be generations ahead of the state of the art at the time.

This computer changed the world—and you’ve never heard about it
[Photos: Courtesy the Charles Stark Draper Laboratory (Apollo guidance computer; NASA (moon)]

This is the 12th in an exclusive series of 50 articles, one published each day until July 20, exploring the 50th anniversary of the first-ever Moon landing. You can check out 50 Days to the Moon here every day. 


Your dishwasher has more brain power than the computer that flew the Apollo astronauts to the Moon.

But don’t let your dishwasher take control of your spaceship anytime soon. That’s not a measure of how basic the Apollo computers were, but rather how much the engineers and programmers in the 1960s were able to do with the modest computing power that was available to them.

The computer they created was a marvel, and its impact is all around us, even though we don’t notice.

NASA knew just how hard it was going to be to navigate through three-dimensional space from the Earth to the Moon: the speeds, the relative motions, the necessary precision, the math, and the speed with which all that math had to be done.

The contract to design the Apollo guidance computer was the first one of the entire project—before the rockets, spaceships, or spacesuits—coming just 10 weeks after President John F. Kennedy’s speech challenging Americans to go to the Moon.


MIT had a division called the Instrumentation Lab, run by a man named Charles Stark Draper who was both a genius and a larger-than-life personality (when he wasn’t designing advanced navigation systems, he was winning ballroom dancing contests). The Instrumentation Lab had 20 years of history designing increasingly sophisticated and precise navigation systems. A staff member had been on the first nuclear submarine to navigate its way under the North Pole, because MIT had designed the submarine’s system to be able to navigate for days while remaining submerged under the waters of the Arctic. If anyone could design the computer and instruments to fly to the Moon, NASA thought, it was MIT.

The challenge was remarkable, starting with the computer at the heart of the system. In the early 1960s, even “small” computers were the size of refrigerators, maybe a couple, lined up next to each other. The Apollo computer would need to be the size of a briefcase.

Computers then required you to submit your programs on stacks of punchcards, then wait hours, or days, for the results. The Apollo computer would need to work instantly—in “real-time” as people started to call it. And the computer would need to have a keyboard and a display, because the astronauts weren’t taking punchcards to the Moon.

At that time, the people using a computer didn’t interact with it. That was the point of the punchcards. Which meant that the people running the computer weren’t really using it. The Apollo computer would need to be designed so the astronauts could run it themselves.

The computers of the day mostly did math of various kinds. The Apollo computer would end up having 200 inputs and outputs; it would be taking in data from sensors, from radar, from Mission Control itself. It would be running the engines and thrusters of the spaceships, constantly understanding where the ship was in space, and then telling the astronauts what was happening via the display. The Apollo computer would sit at the heart of the Apollo spacecraft, both the command module and the lunar module. If it failed, there would be no way to fly either one. The computer not only needed to work; it needed to work perfectly. The very lives of the astronauts depended on it.


It was an astonishing set of requirements. MIT needed to design and program what would turn out to be the smallest, fastest, most nimble, and most reliable computer ever created. It would then be tested not with some reasonable task—running the elevators in a skyscraper, say, or operating a chemical plant. It would be tested with the hardest and most unforgiving thing people had ever done.

The race to the Moon in the 1960s is often described as an engineering effort, because it didn’t require the kind of dramatic breakthroughs of fundamental science, on a deadline, that the atomic bomb required during the Manhattan Project. But Apollo required literally thousands of breakthroughs that pushed the limits of science, engineering, manufacturing, and reliability—in the engines, in the spacesuits, in the lunar module.

And especially vividly, in the computer.

The scientists at MIT didn’t just figure out how to give the astronauts a computer they needed, but a computer they could use. The keys on the keyboard, for instance, were oversized, so they could easily be typed on while wearing spacesuit gloves.

Then, in a leap of programming insight and boldness, they gave the computer two qualities that, again, we take for granted today but were wholly novel in the mid-1960s.


The Apollo computer had built-in decision-making ability. It was programmed in such a way that it could look at all the work that needed to be done to fly the lunar module at any given millisecond—and do the most important work first.

Modern computers, right down to the smartphones in our pockets, make dozens, even hundreds of decisions every second about what task to do and in what order. But in 1969, a computer that made its own decisions was unique.

Second, the Apollo computer could fail gracefully and fully recover, almost without missing a beat—as a result, say, of a brief spacecraft power interruption. The Apollo computer kept track of what it was working on at all times, and if something bad happened, it wiped its working memory clean and restarted seamlessly in ways that modern computers don’t do a particularly good job of (as anyone who has lost pages of a memo they were working on well knows).

Both those masterstrokes of programming would prove indispensable—saving missions from failure, including the very first Moon landing by Apollo 11, when the computer rebooted itself five times in four minutes, because of problems elsewhere in the lunar module, just as Neil Armstrong and Buzz Aldrin were in the last minutes of landing Eagle at Tranquility Base.

At MIT, designing and programming the computer required the work of hundreds of people for more than eight years (the computer was actually manufactured by Raytheon, in a hand-crafted process that was astonishing).


It was, in fact, the first big, broadly interconnected software coding effort in history.

It was not without bumps. At one point in 1966, MIT engineers had written 40% more software than the computer could handle, and the effort was so behind schedule that NASA feared that the computer, instead of flying Apollo to the Moon, would be the reason the astronauts didn’t make it, at least not by 1969.

But the scientists, engineers and programmers at MIT’s Instrumentation Lab were not going to be the reason Apollo didn’t make it to the Moon. In the end, the computer they created was just the opposite.

It had just 73 kB of memory, and it took up exactly one cubic foot of space. But in 2,504 hours of Apollo space flight—more than 100 days in space—there was not a single recorded software error or hardware glitch. It wasn’t just the smallest, fastest, most nimble computer of its era, it was also the most reliable.

When the computer was first discussed with the Apollo astronauts in the early 1960s by MIT, the astronauts thought it would stay off most of the time, and that they would turn it on when they needed it. In the end, it became an always-on sentinel for the astronauts, a kind of fail-safe.


It was so indispensable that some at MIT and NASA called it “the fourth crew member.”

The Apollo computer would turn out to have a big impact back on Earth, although not an impact that is widely understood or acknowledged. Which we’ll explain tomorrow, in the next installment.

Charles Fishman, who has written for Fast Company since its inception, has spent the last four years researching and writing One Giant Leap, a book about how it took 400,000 people, 20,000 companies, and one federal government to get 27 people to the Moon. (You can order it here.)

For each of the next 50 days, we’ll be posting a new story from Fishman—one you’ve likely never heard before—about the first effort to get to the Moon that illuminates both the historical effort and the current ones. New posts will appear here daily as well as be distributed via Fast Company’s social media. (Follow along at #50DaysToTheMoon).

About the author

Charles Fishman, an award-winning Fast Company contributor, is the author of One Giant Leap: The Impossible Mission that Flew Us to the Moon. His exclusive 50-part series, 50 Days to the Moon, will appear here between June 1 and July 20.