On 20 July 1969, roughly seven minutes before touchdown, alarms began flashing on the Apollo 11 lunar module’s guidance computer. Codes 1201 and 1202 meant the machine was overloaded, dumping lower-priority tasks to keep the essential ones alive. Neil Armstrong kept descending. The computer — a boxy grey unit weighing about 32 kilograms and running on the equivalent of 64 kilobytes of memory — sorted its own priorities and delivered him to the Sea of Tranquility with roughly 25 seconds of fuel to spare. What almost nobody watching on television knew was that the software making those decisions had been physically woven, thread by thread, by women sitting at looms in a Massachusetts factory.
The Apollo Guidance Computer (AGC) was designed at MIT’s Instrumentation Laboratory and manufactured by Raytheon. By modern standards its specifications are almost comically modest: a 2.048 MHz clock, 2,048 words of erasable magnetic-core RAM, and 36,864 words of read-only memory — roughly 4 kilobytes and 72 kilobytes respectively in modern terms, and identical across the command module and lunar module machines. A single modern smartphone photograph is larger than every program the AGC ever ran. Yet the Block II version that flew on Apollo 11, built from about 2,800 dual three-input NOR gate chips supplied by Fairchild Semiconductor, navigated to another world.
Software you could hold in your hands
The read-only memory that held Apollo’s flight software was a technology called core rope memory. Instead of storing data on magnetic disks or in silicon, engineers used tiny iron-ferrite rings — the “cores” — each about a millimetre across. To encode a binary 1, a copper wire was threaded through the centre of a core. To encode a 0, the wire went around the outside. When the computer pulsed current through a sense line, the wire’s path through or around each core produced the pattern of ones and zeros that made up the program.
The elegance of the scheme was density. Where conventional core memory stored one bit per ring, core rope threaded 192 sense wires through each core, packing twelve 16-bit words — 192 bits — into a single ferrite ring. That let the Apollo team cram what was, for 1969, an enormous body of code into a package small and rugged enough to survive launch, vacuum, and lunar landing. The trade-off was that once the ropes were woven, the program could not be changed. Every module had to be perfect before it left the factory.
The women at the loom
Raytheon’s manufacturing plant in Waltham, Massachusetts, employed skilled textile workers — many of them recruited from the local mills and from the recently closed Waltham Watch Company — to weave the ropes. NASA engineers, only half-jokingly, called the process “LOL memory,” for “Little Old Lady” memory. The women sat in pairs at specially built fixtures resembling looms, passing a hollow needle carrying the copper wire back and forth through a grid of ferrite cores according to instructions printed out from MIT’s Cambridge offices. A single mistake — one wire threaded through a core that should have been bypassed — would flip a bit and could crash the program in flight.
The work was slow. A complete rope module took roughly eight weeks to assemble and cost about $15,000 in 1960s dollars. The AGC held six of these modules, meaning that the code had to be frozen months before launch to give the weavers time to finish. Once a wire was threaded, it was permanent; if MIT wanted to change an instruction, the affected rope had to be scrapped and rewoven from scratch. The pressure on the programmers to get it right the first time — and on the weavers to execute without a single error — was immense.
Margaret Hamilton and the code that saved the landing
The lead software engineer on the AGC project was Margaret Hamilton, who ran the Software Engineering Division at MIT’s Instrumentation Laboratory and is often credited with popularising the term “software engineering” itself. Hamilton and her team wrote the guidance and navigation programs — Colossus for the command module, Luminary for the lunar module — that would eventually be turned into rope.
Hamilton had insisted, over some internal resistance, that the AGC be built with an asynchronous executive that could juggle multiple tasks by priority and shed low-priority ones under load. That decision is what saved Apollo 11. When the 1201 and 1202 alarms fired, they were being triggered by the lunar module’s rendezvous radar dumping data the computer didn’t need during descent, saturating its processor. Because Hamilton’s executive was designed to protect the mission-critical work, it discarded the unnecessary tasks and kept the landing guidance running. Armstrong never lost control.
A now-famous photograph from 1969 shows Hamilton standing beside a stack of listings — the printed source code for Apollo — that reaches roughly her own height. Every character in that tower had to be transcribed into copper and iron before it could fly.
Why hand-woven memory made sense
From a modern vantage point, weaving software sounds absurd. In the mid-1960s, when the Block II AGC was being finalised, it was the best available answer to a hard set of constraints. Semiconductor read-only memory of adequate density did not yet exist in a form NASA trusted for spaceflight. Magnetic tape and disks were too fragile and too slow. Core rope was extraordinarily reliable: the ferrite rings were essentially indestructible, immune to cosmic-ray upsets that could flip bits in early transistor memory, and stable across the temperature swings of a lunar mission.
The AGC was also one of the first computers to use silicon integrated circuits at scale. NASA’s willingness to buy thousands of chips at a time from Fairchild Semiconductor — at a moment when the commercial market was still tiny — is often credited with helping bootstrap the entire integrated-circuit industry. The machine that had its programs sewn by hand also helped create the conditions for the microchips that would eventually make sewing them obsolete.
What the AGC actually did
During the descent to the Moon, the AGC ran programs called P63, and later P64 and P66, that continuously solved the equations of motion for the lunar module — reading accelerometers, firing thrusters, gimballing the descent engine, and updating the display for the astronauts roughly once a second. Buzz Aldrin punched instructions into the computer using a small keypad called the DSKY, entering two-digit “verb” and “noun” codes that told the AGC what to do and what data to show.
The full flight software for Luminary 1A, the version that flew on Apollo 11, has since been transcribed and published on GitHub, where anyone can read the comments left by Hamilton’s team — including the famous line “TEMPORARY, I HOPE HOPE HOPE” above one particularly nervous section, and a routine labelled “BURN_BABY_BURN — MASTER IGNITION ROUTINE.”
An artefact of an unrepeatable moment
Core rope memory disappeared quickly after Apollo. By the mid-1970s, semiconductor ROMs had become cheap and dense enough that no serious program would ever be woven again. The surviving rope modules now sit in museums — the Smithsonian, the Computer History Museum in Mountain View, the MIT Museum — small grey blocks that look, from the outside, like nothing at all.
Inside each one, though, is a program written in copper. Someone sat at a loom in Waltham in 1968 and, following instructions printed from a mainframe, threaded a wire through a ferrite ring about a millimetre across. That wire told a computer, six months later and 384,000 kilometres away, when to fire its engine. Software has never been more literal, and probably never will be again.
For a comparable story of a spacecraft’s software refusing to quit, Voyager 1 is still transmitting from interstellar space on hardware even older than the AGC. And for an older episode of the same lineage — engineers reaching into a machine to fix it by hand — see how in September 1947 Harvard engineers pulled a moth from a relay inside the Mark II computer.
