The computer that guided Apollo 11 to the Moon and back had a clock speed of about 2 MHz, roughly 74 kilobytes of memory, and weighed 32 kilograms. A modern smartwatch is thousands of times more powerful. A basic calculator has more processing capability. And yet the Apollo Guidance Computer (AGC) performed one of the most demanding computational tasks ever attempted: real-time navigation and control of a spacecraft traveling 400,000 kilometers from Earth to a precise landing on the lunar surface.
The AGC was not a general-purpose computer. It was built to do one thing and do it flawlessly: calculate the spacecraft’s position, velocity, and orientation in real time, and translate those calculations into commands for the engines and thrusters. It did this continuously, for the entire duration of each Apollo mission, with a reliability that modern software engineers still study as a model.
Why a Computer Was Necessary
The navigation problem for a lunar mission is extraordinarily complex. The spacecraft must escape Earth’s gravity, coast through a region where the gravitational fields of the Earth, Moon, and Sun all interact, enter lunar orbit, descend to the surface, ascend back to orbit, rendezvous with the orbiting command module, and return to Earth, all while the Earth, Moon, and spacecraft are moving continuously.
The calculations involved are not difficult in principle. They are applications of Newton’s laws of motion and gravitation, the same physics that Newton published in the Principia in 1687. But the calculations must be performed continuously, in real time, with high precision, and with the ability to respond to unexpected events. No human crew could perform these calculations fast enough, and mission control’s radio link had a round-trip delay of about 2.5 seconds, too slow for critical phases like landing.
The AGC provided the astronauts with autonomous navigation capability. Even if communication with Houston was lost, the crew could navigate and land using the onboard computer.
The Hardware
The AGC was designed by the MIT Instrumentation Laboratory under the direction of Charles Stark Draper. It was one of the first computers to use integrated circuits (ICs), a technology so new at the time that the Apollo program was the largest single consumer of ICs in the world during the early 1960s. The choice of ICs over discrete transistors reduced the computer’s weight, power consumption, and failure rate dramatically.
The computer had two types of memory. Erasable memory (2,048 words of 15-bit RAM) stored temporary data: the spacecraft’s current position, velocity, and orientation. Fixed memory (36,864 words of ROM) stored the software. The ROM was literally woven by hand: the programs were encoded in copper wires threaded through or around tiny magnetic cores. A wire passing through a core represented a binary 1; a wire bypassing a core represented a binary 0. This “core rope memory” was manufactured by teams of women (called “little old ladies” by the engineers, though many were young) who wove the wires according to patterns printed on paper.
The woven memory was extremely reliable (no moving parts, no volatile storage) but could not be modified after manufacture. Every change to the software required weaving a new memory module. This meant that the software had to be finalized months before launch, and bugs discovered after that point could not be fixed.
The Software
The AGC’s software was developed by a team at MIT led by Margaret Hamilton, who coined the term “software engineering” to describe the discipline her team was creating. The software had to handle navigation, guidance, autopilot functions, display management, and crew interface, all within the severe constraints of the hardware.
The most innovative feature of the AGC software was its priority-based scheduling system. The computer could not run all its tasks simultaneously (it had only one processor), so Hamilton’s team designed a system that assigned priorities to each task. If the computer became overloaded, it would automatically drop lower-priority tasks to ensure that critical functions (like navigation and engine control) continued to operate.
This design proved crucial during the Apollo 11 landing. As the Lunar Module descended toward the surface, the computer was fed erroneous data from a radar system that had been left on by mistake. The resulting processing overload triggered a series of “1202” and “1201” alarms. The priority system worked exactly as designed: the computer dropped the low-priority radar tasks and continued to run the critical landing guidance software. Mission controllers in Houston, after a tense few seconds, confirmed that the alarms could be ignored. The landing proceeded.
If the software had not been designed to handle overload gracefully, the first Moon landing might have been aborted. Hamilton’s priority scheduling, built into the system years before it was needed, saved the mission.
The Interface
The astronauts interacted with the AGC through a display and keyboard unit called the DSKY (pronounced “disky”). The DSKY had a numeric keypad, a small array of status lights, and three five-digit numeric displays. There was no screen, no graphics, no mouse. Everything was communicated through numbers.
Commands were entered as two-digit codes: a “verb” (what to do) and a “noun” (what to do it to). Verb 06 meant “display decimal.” Noun 43 meant “latitude, longitude, altitude.” Verb 37 meant “change program.” The system was cryptic by modern standards but effective. Astronauts memorized the most common verb-noun combinations and could interact with the computer quickly during time-critical phases.
Navigation in Space
The AGC determined the spacecraft’s position using a combination of methods. The primary system was inertial navigation: a platform of gyroscopes and accelerometers that measured the spacecraft’s acceleration and integrated it over time to calculate velocity and position. This system drifted over time (small errors accumulated), so it had to be periodically corrected.
Corrections came from star sightings. The astronauts used a sextant and scanning telescope built into the command module to measure the angles between known stars and the horizon of the Earth or Moon. These measurements were entered into the AGC, which used them to recalibrate the inertial platform. The process was a space-age version of the celestial navigation that sailors had used for centuries.
Ground tracking from NASA’s Deep Space Network provided additional position data, which was uploaded to the AGC via radio. But the onboard system was designed to function independently, in case communication was lost.
The Landing
The most demanding phase of any Apollo mission was the powered descent to the lunar surface. During the final twelve minutes of descent, the AGC controlled the Lunar Module’s engine, adjusting thrust and attitude to follow a precisely computed trajectory from orbit to touchdown.
The computer calculated the optimal descent path in real time, accounting for the Moon’s gravitational field, the spacecraft’s mass (which decreased as fuel was burned), and the crew’s target landing point. It displayed altitude, descent rate, and fuel remaining on the DSKY, giving the commander the information needed to decide whether to continue or abort.
On Apollo 11, Neil Armstrong took semi-manual control during the final phase, using the AGC’s calculations as guidance while visually selecting a safe landing spot. On later missions, the AGC’s guidance was refined to the point where Apollo 12 landed within 200 meters of its target, the Surveyor 3 probe.
The Legacy
The Apollo Guidance Computer pioneered concepts that are now standard in computer science: real-time operating systems, priority-based task scheduling, human-computer interface design, and fault-tolerant software engineering. Margaret Hamilton’s team developed many of these concepts from scratch, with no textbooks or precedents to guide them.
The AGC also demonstrated that computers could be trusted with life-critical decisions. Before Apollo, the idea of placing human lives in the hands of a computer was radical. The AGC’s flawless performance across all Apollo missions established the principle that computers, properly designed and programmed, could be relied upon for the most demanding and consequential tasks imaginable.
The stored-program architecture that made the AGC possible traces directly to von Neumann’s 1945 EDVAC report, which established the design principles that every computer since has followed. Kronecker Wallis’s edition of the EDVAC Report presents this foundational document printed on blue Fabriano paper in monospace type. The AGC was, at its core, a von Neumann machine: a stored-program computer that fetched instructions from memory and executed them sequentially, just as the 1945 blueprint specified.
The trajectory that the AGC computed and followed is preserved in Kronecker Wallis’s Apollo Translunar Trajectory Plotting Chart, which reproduces the original Apollo 11 flight path. The chart shows the curves and velocities that the AGC calculated in real time, the mathematical path from Earth to Moon that a 32-kilogram computer navigated flawlessly.
32 Kilograms to the Moon
The Apollo Guidance Computer is a reminder that computational power is not the same as computational achievement. The AGC had less processing power than a modern greeting card that plays music when you open it. But it landed humans on the Moon six times without a single computer-related failure. The difference was not hardware. It was the quality of the software, the clarity of the engineering, and the understanding that in a life-critical system, reliability matters more than speed. The AGC did less, but it did it perfectly. In engineering, that is the hardest thing of all.
No products in the cart.