The software that landed the Eagle on the Moon wasn’t stored on a chip. It was a physical object you could hold, built by women threading wire through rings by hand.
On July 16, 1969, a Saturn V rocket carrying Neil Armstrong, Michael Collins, and Buzz Aldrin lifted off from Cape Kennedy, guided in part by a pair of onboard computers that ran on software unlike anything a modern engineer would recognize as code.
The Apollo Guidance Computer, or AGC, one aboard the command module and another in the lunar module, didn’t load its core program from a disk or a chip.
Most of it existed as a physical arrangement of copper wire threaded through tiny magnetic rings, built by hand at a Raytheon factory outside Boston, largely by women hired specifically because they already had experience in the textile industry.
A computer built to fit in a cubic foot
The AGC was designed at the MIT Instrumentation Laboratory under engineer Eldon Hall, at a time when most computers filled entire climate-controlled rooms. The AGC did the opposite: it fit into a volume of less than one cubic foot, weighed around 32 kilograms, and ran on just 55 watts of power.
According to MIT’s own account of the program, the Block II version used on Apollo 11 carried roughly 36,864 words of fixed memory and 2,048 words of erasable memory.
The two kinds of memory did very different jobs: erasable memory held the numbers that changed constantly during flight, things like position, velocity, and the results of ongoing calculations, while fixed memory held the actual instructions and constants the computer needed to run its programs at all.
The AGC wasn’t trying to do everything a modern computer does. It handled a narrow, carefully prioritized set of navigation, control, and communication tasks, and little else.
How a piece of wire became a line of code
The fixed memory that carried most of the AGC’s actual program used a technology called core rope memory, and it worked on a genuinely different principle than the erasable memory sitting right next to it in the same machine.
In ordinary magnetic core memory, each tiny ferrite ring could be magnetized in one of two directions to represent a 1 or a 0, and reading that value required a pulse that erased and then rewrote it, a real read-write cycle.
Core rope memory skipped that mechanism entirely. What mattered wasn’t which way a ring was magnetized, but which way the wire physically ran relative to it: if a sense wire passed through the center of a core, the circuit read one value, and if the wire looped around the outside of that same core, it read the opposite.
String enough of these wire-and-core intersections together in the right pattern, and the physical object itself became the program.
That design packed a lot of instructions into a small space and made it essentially impossible for a stray electrical glitch to accidentally overwrite the flight software mid-mission, since there was nothing electronic left to overwrite.
It came with an obvious cost, though: changing even a single bit of the fixed program meant physically rebuilding part of the memory’s structure, not editing a file.
According to a detailed technical history of the process, wiring a single core rope module by hand took roughly eight weeks and cost about $15,000, which meant Apollo’s flight code had to be finalized and frozen months before launch, with essentially no possibility of a last-minute software patch in the way modern engineers would understand the term.
The women who turned code into a physical object
MIT’s programmers wrote, tested, and formally approved each version of the software before sending the finished configuration off to be manufactured. At Raytheon’s Waltham, Massachusetts plant, skilled workers, many hired directly from the local textile industry for their precision sewing and weaving experience, physically routed the wires through the exact pattern that configuration required.
The comparison to weaving isn’t just a poetic flourish; it’s close to a literal description of the manufacturing process, though the underlying work amounted to genuinely high-precision electronics assembly, since a single misrouted wire could silently alter an instruction or a critical constant buried inside the program.
The process wasn’t entirely manual. Raytheon fed the approved program through an assembler called YUL, which produced a punched Mylar tape that an automated system used to mechanically position each core in sequence, while a human worker still had to thread the actual sense wire through or around that core by hand before the machine advanced to the next one.
Every finished module then had to be tested against the original approved pattern before it was cleared for installation. Mary Lou Rogers, one of the Apollo-era weavers, later recalled just how many checks that involved: each component, she said, had to be reviewed by three or four separate people before it was signed off, and federal inspectors visited regularly to audit the work directly.
Inside the program, MIT engineers reportedly had an informal nickname for this workforce: the “LOL” method, short for “Little Old Ladies,” a phrase that shows up in some remembered accounts from the era, including from Margaret Hamilton’s own team, alongside other bits of lab slang from the period.
How widely that specific nickname was actually used at the time, rather than attached to the story in later retellings, is genuinely disputed by researchers who’ve studied the program’s history closely, and it’s worth holding onto that uncertainty rather than repeating the nickname as settled fact.
What isn’t in dispute is that the women doing this work were skilled technical employees carrying out one of the most consequential and least error-tolerant manufacturing jobs in the entire Apollo program.
A program that could still be patched, carefully
The core rope itself genuinely couldn’t be rewritten once it was built and installed, but that didn’t make the AGC’s software completely fixed for the rest of a mission. The computer’s erasable memory could also run instructions, which opened a narrow, deliberate path for correcting the software after the fixed program had already been manufactured.
The best-known case of this came during Apollo 14, when astronauts manually entered a sequence of commands specifically designed to prevent a malfunctioning abort switch from prematurely halting the lunar descent, a workaround made possible only because the erasable side of the computer’s memory remained genuinely editable in flight.
What the woven memory actually did on July 20, 1969
That underlying architecture mattered in a very concrete way during Apollo 11’s actual descent to the surface. As the lunar module Eagle approached the Moon on July 20, 1969, its guidance computer began throwing alarms, first a 1202, then a 1201, both signaling that the AGC was being asked to process more than it could handle at that exact moment.
The call went to Steve Bales, the guidance officer at Mission Control, who immediately checked with Jack Garman, a member of the support team who had specifically prepared a reference list of what different alarm codes meant in advance.
Garman recognized the 1202 as a temporary computational overload rather than a critical failure and gave the go-ahead to continue the descent, a call Bales then passed up the chain.
What actually happened inside the computer wasn’t simply ignoring the excess workload. The AGC’s software rebooted itself, recovered its necessary state, and resumed only the essential programs, the ones controlling the descent engine and the astronauts’ primary display, while deliberately not restarting lower-priority tasks tied to the rendezvous radar that weren’t needed for landing.
The mission didn’t survive that moment because the woven memory was somehow indestructible. It survived because the program physically encoded inside that memory had been built with a specific priority and recovery structure meant to protect the most critical tasks during exactly this kind of overload.
A story usually left out of the popular version
Magnetic core memory in general stayed in wide use across the computing industry into the 1970s, before cheaper semiconductor memory eventually replaced it, but core rope memory specifically had a shorter working life, valuable mainly for the unusual combination it offered Apollo: high data density, permanence, and near-total resistance to accidental in-flight corruption. The scale of the technological leap involved is easy to lose sight of.
On December 17, 1903, Orville Wright’s first powered flight lasted 12 seconds and covered about 120 feet, according to the National Park Service’s own account at the Wright Brothers National Memorial. Less than 66 years later, two people descended to the surface of the Moon guided in part by a computer whose program had been physically woven into copper and ferrite by hand.
Popular retellings of Apollo tend to center on the astronauts, the MIT engineers, and the consoles at Mission Control, and all of that attention is genuinely earned.
But before any of the AGC’s software could actually guide the Eagle down, its instructions had to be converted into a physical object capable of surviving the trip, and that conversion happened at a Raytheon factory, largely at the hands of women threading wire through magnetic rings, one connection at a time, until an abstract sequence of ones and zeros became something solid enough to leave the Earth.