When Apollo 11 touched down in the Sea of Tranquility on July 20, 1969, it was more than a triumph of the human spirit, it was also the story of a cybernetic wonder called the Apollo Guidance Computer (AGC), which helped the Apollo astronauts safely navigate to the Moon and back. It was a computer so advanced for its time that the engineers who created it said they probably wouldn't have tried to do so if they'd known what they were getting themselves into.

The Apollo Guidance Computer is one of the unsung successes of the Space Race. This is probably because it was so phenomenally successful, having had very few in-flight problems – and most of those were due to human error. Carried aboard both the Command Service Module (CSM) and the Lunar Module (LM), it flew on 15 manned missions, including nine Moon flights, six lunar landings, three Skylab missions, and the Apollo-Soyuz Test Mission in 1975.

At the time it was the latest and most advanced fly-by-wire and inertial guidance system, the first digital flight computer, the most advanced miniature computer to date, the first computer to use silicon chips, and the first onboard computer where the lives of crew depended on it functioning as advertised.

Not that the Apollo Guidance Computer was much to look at. At first glance, it appeared like a brass suitcase in two parts, measuring a total of 24 × 12.5 × 6.5 in (61 × 32 × 17 cm) and weighing in at 70 lb (32 kg). Inside, it isn't even very impressive by modern computer standards, having about as much oomph as a smart bulb with a total of about 72 K of memory and a 12-microsecond clock speed.

It's also hard to make an accurate comparison with modern devices because the AGC wasn't a general purpose computer, but one that was literally hardwired for a particular task, which allowed it to perform at the level of the Commodore 64 or ZX Spectrum of the early 1980s – try to imagine getting to the Moon using a Commodore 64 to handle the navigation and not break into a cold sweat.

A job for a computer

The reason why all the Apollo missions carried at least one of these computers is that the Moon missions involved navigation problems that would have made Captain Cook go bug eyed. On Earth, navigation is, at its simplest, about finding one's way from one fixed point on the globe to another. For a trip to the Moon, it's like standing with a rifle on a turntable that's spinning at the center of a much larger turntable on which is a third turntable sitting on the rim, with all the tables spinning at different and varying speeds, and trying to hit the target by aiming at where it will be three days from now.

Given the enormous number of variables, the above analogy only gives a small taste of the complexity of the equations that need to be solved for such a journey – and even then, the result will be a series of increasingly accurate estimates rather than a certain path. But what was certain from very early in the Apollo program was that space navigation is too complex and too counterintuitive for the astronauts to handle. In private, the engineers preferred that they not be allowed to have anything to do with it at all.

On top of that, designing and building a computer for the Apollo missions began as little more than a lot of hand waving. Though the first of all the Apollo contracts to be awarded, the AGC was one of thousands of sub-projects that were all chasing after a program where the basics were still in flux and where no one even knew if it was a mission where one, two, or more spacecraft would be used for the Moon landing.

A new technology

Things were already bad enough, but the AGS was being developed at a time when not only computers, but the entire field of electronics was undergoing an astonishing evolution that no one could predict.

When the Apollo program began, computers were still gigantic machines that took up whole rooms. There were only a handful in the entire world and trying to get information into and out of one was so complex that it took a clerisy of top-level mathematicians to handle the job. However, it was a field that was fast evolving and by the time work began on the AGC, the technology was set to explode into the computer revolution that we're still trying to get a handle on today.

And it wasn't just computing technologies that were advancing apace, but basic electronics as well. In the late 1940s, transistors had sent radio valves the way of the buggy whip and the printed circuit board was conquering the old wire-and-solder circuit boards. But both of these were threatened by the integrated circuit (IC), direct ancestor to the silicon chip, that hit the scene in 1958.

All this new technology wasn't just having a synergistic effect on computer design, it was also convulsing the entire electronics industry as the IC blurred the line between electronic firms, who traditionally designed and built circuity, and component suppliers, who just made the parts. The IC threw the whole question of who was designing and who was supplying into flux.

This caused no end of trouble for the AGC. How do you design a computer that won't fly for six years when the technology keeps changing? Worse, how do you get industry support for a computer that has to remain in production and use for 10 years when the industry expects everything to change within 18 months? It did not encourage confidence.

MIT Instrumentation Laboratory

It was into the maelstrom that MIT fell in August 1961 when NASA decided to award the Apollo Guidance Computer contract to the MIT Instrumentation Laboratory instead of the agency's usual supplier, IBM. This was in large part because MIT, under Instrumentation Laboratory head Charles Stark Draper, had a strong track record in developing inertial guidance systems with Eldon C. Hall designing the latest for the US Navy's Polaris Missile Computer.

At first, there was trepidation about giving the contract to MIT, but Draper showed so much confidence that his team could deliver the computer to spec and on time that he volunteered to fly on the first mission. By 1962, it was agreed that MIT would spearhead the effort with the support of the AC Spark Plug Division of General Motors, Kollsman Instrument Corporation, and Raytheon, which would build the computer itself.

The big hurdle was that the specifications for the AGC were a blank sheet of paper. No one had built anything like this and no one had any idea of how to go about it. So, as a starting point, MIT fell back on a four-volume Mars mission study from 1958 that postulated an unmanned 150 kg (331 lb) Mars probe that could navigate autonomously using star fixes as it did a flyby of the Red Planet, took photographs, and then looped back to Earth for recovery.

This was a very long way from something suitable for a manned lunar landing, but it was a start. Soon the basic design began to emerge of a small, self-contained, low-power general computer that could handle all the navigation problems of a Moon voyage. Based on the technology from the Polaris missile, it would use a gyroscope and accelerometers combined with a sextant to fix the position of the spacecraft and keep it on course.

Beyond this, the new computer would have to conform to general Apollo specifications, It had to be rugged enough to withstand spaceflight, and use the minimum number of transistors, which were still unreliable. In addition, it needed a simple control interface for the astronauts – though the engineers would have preferred the crew to just go along for the ride.

Tyranny of hardware

It seemed like a promising start, but it didn't last. By 1966, MIT was obviously in way over its head and NASA sent in a troubleshooter named Bill Tindall, who rode the team and became notorious for his blistering "Tindalgrams." These lengthy, yet blunt missives outlined how MIT was suffering from not being a proper contractor and didn't have the requisite culture or discipline for a job like the AGC. The result was slow progress and needless duplications in the software, which was full of bugs and took up too much memory.

But not all of the problems were organizational. We mentioned software, but in 1966, "software" was a new word and many computer professionals had trouble understanding the concept. In fact, no one was exactly certain what a computer could actually do. What were its strengths? What were its weaknesses? It was learn as you go.

One of the lessons that MIT learned was that the technology was still too primitive for the machine they'd envisaged. By 1966, it was clear that the AGC was just too small with not enough memory, was too slow to handle enough tasks at one time, and it couldn't handle data the way analog circuits could.

In other words, it was a return to the tyranny of hardware. The idea of a general computer controlling the mission was abandoned and the AGC was now a specialized machine relegated to backup status. Going forward, ground computers would feed navigation data to the Apollo spacecraft while the onboard computer stood by in case there was a breakdown in the communications link.

That may seem like a big step down, but the AGC still had a vital function. Ground control might be able to handle navigation, but there was still a one-second time lag between Earth and the Moon, and when an Apollo spacecraft went behind the Moon all communications were cut off. Worse, this was during the depths of the Cold War and the Americans were worried that the Soviets would deliberately jam transmissions.

How it worked

One thing to bear in mind when looking at the AGC is that it was both cutting-edge in design and very old-fashioned in how it was built – both of which presented their own challenges. Unlike modern computers, the AGCs were all handmade in a slow, laborious process that even partial automation and new testing methods did little to speed up or make easier. In all, it took 2,000 man-years to build the computers.

One difficulty was that the AGC incorporated a lot of cutting-edge technologies, such as being the first computer to rely on chip components for its logic circuitry – specifically, a three input NOR gate. These were just coming on the market, but by 1963 the MIT Instrumentation Laboratory was buying up 60 percent of the chip production in the United States.

The computer

In its final form, the AGC was no longer a general purpose computer, but one designed to carry out specific tasks, and was wired to do so. It consisted of two metal trays – one for the memory and one for the logic circuits for a total of 30,000 components. Because of the limitations of the technology, despite its complexity, the AGC was designed to be as simple as possible, with as few parts as possible for lower weight and greater reliability.

Since the AGC had to operate a quarter of a million miles from the nearest repair shop, this reliability was a top priority. At one point, there was the suggestion of installing a duplicate computer aboard the spacecraft, but this was turned down in favor of vigorous and aggressive testing, then hermetically sealing the components to keep out dust and moisture.

Rope Memory

One major design concern was how to store programs and data in the AGC. Computer memories had come a long way from the days when data was fed in using punched paper tape or stored by sending sound waves through tubes filled with mercury, but the technology was still in its infancy and none of the current storage techniques were practical for Apollo.

Instead, MIT came up with a novel approach where the software was literally woven into the memory banks. Using a technique called "rope memory," the engineers came up with a method where tiny rings of iron had wires running through them. When a wire ran through the center of the ring, it represented the binary number 1. When it ran outside, it was 0.

To program these rope memories, MIT used what they dubbed the LOL method, for "little old ladies." This was because the programming was done by ex-textile workers, who skillfully sent wire-carrying needles through the iron rings. They were aided by an automated system that showed them which hole in the workpiece to insert the needle into, but it was still a highly skilled job that required concentration and patience.

The result was an indestructible memory that could not be erased, altered, or corrupted. The disadvantage was that producing this memory was very hard to do and even harder to correct when an error was found. However, this was also an advantage because it meant that last-minute "good ideas" could be disregarded.

Priority over time-sharing

Of course, this wasn't the only memory in the AGC. There was also a 2,000-word RAM memory bank that acted like a scratch pad for temporary data while the computer was running a program. This was particularly important because of a special safety feature of the machine.

In the 1960s, the common practice for a computer that was used by several people or ran multiple programs was time-sharing. In this, the computer would allocate microseconds of time to each of these and switch between them. This might have been fine for a university mainframe, but for Apollo it could have been fatal because the computer might end up preoccupied with trivia in a life or death situation or could crash in a manner all too familiar to computer users of today.

That was when computer pioneer Halcombe Laning came up with a solution. Instead of timesharing, the AGC was programmed for priority. In other words, each program was numbered in order of importance at any particular point in the mission timeline. If a higher priority program needed the computer, the others would simply stop and wait for it to finish, then resume. Meanwhile, the temporary memory held the data up to the point of stoppage in a way similar to that of a modern computer going into sleep mode. This not only eliminated crashes, but also allowed the crew to interrupt a running program with new data as it came in.


This data came from a number of devices, including the sextant, the telescope, the Inertial Measurement Unit (IMU) that consisted of a gyroscope and three accelerometers, the manual control used by the astronauts, the Command Module Rendezvous Radar, the Lunar Module Landing Radar, telemetry from Earth, the main engine, and the reaction control system.

But the most important of the inputs was the Display and Keyboard (DSKY) unit with which the astronauts communicated with the computer. This user interface was so bulky that many people who see it today think that it's the computer itself, but it's actually nothing more than a collection of warning and status lights, buttons, and a numeric display.

Designed by Alan Green of MIT, the DSKY seems, at first, to be very difficult to use (there are a number of simulators online, if you'd like to have a go). The astronauts thought so, too, but with practice, they were soon surprised by how good the device actually was and they became big fans of it.

What was fascinating was the unique way the DSKY worked. Instead of typing in word commands or clicking on icons, the astronauts used a special numeric language of "nouns" and "verbs." A noun was an object and a verb was an action to be taken by the object. To operate, the astronaut would first press the unlock key that prevented accidental button pressing, then enter the number code for the noun and then the code for the verb.

The result would be a command like ""display-gimbal angles" or "load-star number." If the command required the astronaut to enter data, such as the star number, the computer would flash a ready signal and wait for the data. There was even a cheat sheet printed on one of the bulkheads listing computer commands.


Of course, a computer is only as good as its software, and the AGC took 350 engineers the equivalent of 1,400 man-years to develop before the first Moon landing. The effort got off to a rocky start because the programmers hadn't any specifications, and not having a solid grasp of the concept of software didn't help.

Unlike today, the code was written by hand and then transferred to huge stacks of punch cards for testing. Despite this primitive method, the software was a huge leap forward and the first that had to handle real-time problem solving that three men's lives would depend upon.

It was basically a mix of assembly language and interpreted mathematical language that had to be constantly updated as the hardware, the mission, and the role of the astronauts continued to evolve. It was so intense a task that it became all-consuming for the MIT team and it soon took its toll as the members' personal live suffered, as evidenced by a staggering divorce rate.

The Apollo Computer in action

In practice, AGC in particular performed flawlessly on the Apollo flights, with the only problems arising from entering the wrong code or flipping the wrong switch. On Apollo 8, Command Module Pilot Jim Lovell conscientiously attended the computer as he fed in data from the CM sextant. When the spacecraft reached the Moon in December 1968, the computer and NASA agreed on Apollo 8's position to within 2.5 km (1.6 mi) and on the return trip, only one course correction was required.

But it was on Apollo 11 that the AGC really showed its stuff. During the historic descent to the Sea of Tranquility, the computer suddenly had a fit due to the rendezvous radar being accidentally left on. The radar was flooding the computer with meaningless data and in a modern computer this would have resulted in a freeze or a crash. Instead, the AGC signaled "1202" for an overload error and switched off every program except the number one priority and restarted. A possible abort avoided, Mission Commander Neil Armstrong was given the GO command to proceed with the landing.

Most people are unaware of that little story, and perhaps that is the best tribute that a computer can ever have. It did the job.

View gallery - 23 images