Dsky · Volume 7
DSKY — Volume 7 — Block I to Block II: Evolution of the Machine
From a single-gate prototype to the computer that flew to the Moon
About This Volume
The Apollo Guidance Computer that the world remembers — the one that steered Eagle to Tranquility Base, that flashed its famous program alarms while Armstrong searched for a clear spot to land — was not the computer that the MIT Instrumentation Laboratory first designed. It was the second generation. The machine matured in two distinct iterations, known prosaically as Block I and Block II, and the distance between them is the distance between an ambitious laboratory prototype and a flight-proven spacecraft subsystem.
This volume tells that evolution story. Block I established the architecture, proved that integrated circuits could be trusted in a manned spaceflight program at all, and flew on a handful of unmanned test flights. Block II — lighter on chips but heavier on capability — inherited that architecture, doubled the erasable memory, expanded the fixed memory by half, sharpened the interfaces to the spacecraft, and became the only version any astronaut ever flew with. Sitting between the two, casting a long shadow over the schedule, is the Apollo 1 fire of January 1967.
Where this volume references the integrated-circuit story in depth, that is Volume 4; the internal architecture and word format belong to Volume 6; the software and the restart logic that exploited Block II’s hardware get their full treatment in Volume 10; and the missions these machines flew are Volumes 12–14. Here we concentrate on the hardware lineage itself: what changed, why it changed, and what it tells us about how a piece of computing history actually gets built.
Block I — The First of Its Kind
When the Instrumentation Laboratory under Charles Stark Draper committed the AGC to integrated circuits in the early 1960s, it was making a bet that almost no one else in the aerospace world was willing to make. ICs were new, expensive, and largely unproven for high-reliability work. The rival Minuteman II missile guidance computer hedged its bet by mixing several logic families. The MIT team did the opposite: it standardized on a single, dead-simple building block and bought it by the tens of thousands.
That building block, in Block I, was a three-input NOR gate — one gate per integrated-circuit package, implemented in resistor–transistor logic (RTL) by Fairchild Semiconductor and delivered in a flat-pack. The entire Block I logic was assembled from roughly 4,100 of these single-gate packages, wired together with wire-wrap interconnect that was then potted in cast epoxy to survive launch vibration. There is an austere elegance to it: a Moon-bound computer built, in effect, from one part repeated four thousand times. Standardizing on a single gate type simplified procurement, testing, and the reliability statistics that NASA cared about above all else.
Block I’s memory reflected the same period hardware. Fixed memory — the famous “core rope,” in which software was physically woven into the wiring by threading or skipping each core, and therefore could not be changed after manufacture — held roughly 24,576 words, conventionally written as 24K. Erasable memory, the read/write coincident-current core store that held variables and intermediate results, held about 1,024 words, or 1K. By the standards of 1965 this was a respectable amount of storage for a machine you could lift; by the standards of what the lunar mission would eventually demand, it was tight.
The whole assembly — logic, both memories, power supplies, and interfaces — was packaged into a sealed magnesium-alloy chassis weighing on the order of 70 pounds, drawing roughly 55 watts, and clocked from a master oscillator at 2.048 MHz. Those headline numbers, remarkably, would survive almost unchanged into Block II. The genius of the redesign was not to make the box bigger or hungrier; it was to pack far more capability into the same physical envelope.
Block I Flew — But Never With a Crew
It is a point worth stating plainly because it is so often blurred: Block I never carried astronauts. It was a test article, and it earned its place in history on a short series of unmanned flights that validated the Apollo command module, its heat shield, and the Saturn boosters before any human life was at stake.
The first to carry a Block I AGC was AS-202, a suborbital flight in August 1966 — sometimes informally called “Apollo 3” — which exercised the spacecraft and its guidance through a long ballistic arc and a demanding re-entry. The Block I computer then flew on Apollo 4 (November 1967), the first all-up test of the Saturn V, and on Apollo 6 (April 1968), the second. The flight software for these missions carried program names of its own — Corona for AS-202, Solarium for Apollo 4 and 6 — woven permanently into the rope.
Block I was, in the original plan, also slated to fly the first crewed missions: Apollo 1 and a follow-on Apollo 2 would have been Block I flights, low Earth-orbit shakedowns before the Block II spacecraft took over for the lunar campaign. History intervened.
The Apollo 1 Fire and the Program’s Reassessment
On the evening of 27 January 1967, during a “plugs-out” launch-rehearsal test on Pad 34 at Cape Kennedy, a fire broke out inside the sealed, pure-oxygen-pressurized Block I command module CM-012. It spread with terrible speed. Command Pilot Gus Grissom, Senior Pilot Ed White, and Pilot Roger Chaffee were killed. They were the prime crew of what would be designated Apollo 1, and they would have been the first men to fly the Apollo spacecraft.
It must be said clearly: the guidance computer had nothing to do with the fire. The investigation traced the disaster to a combination of factors — a probable electrical-arc ignition source amid flammable materials, a high-pressure pure-oxygen cabin atmosphere that turned ordinary materials into fierce fuel, and an inward-opening hatch that could not be opened against internal pressure in the seconds available. The AGC was a victim of the same flames, not a cause of them. We raise the episode here because of what it did to the program, and therefore to the machine.
The fire triggered an exhaustive accident investigation and a sweeping, top-to-bottom reassessment of the entire Apollo spacecraft. Crewed flights were grounded for more than eighteen months. The command module was extensively redesigned: a new outward-opening unified hatch that could be released in seconds, wholesale removal or replacement of flammable materials, protected wiring bundles, flame-resistant spacesuits, and a revised cabin atmosphere procedure for the ground. Crucially, NASA made the decision that all crewed Apollo missions would fly the Block II spacecraft — and therefore the Block II computer. The Block I crewed flights were simply cancelled. On 9 May 1967, NASA announced that the Apollo 1 backup crew would instead fly the first crewed mission aboard the redesigned Block II vehicle, a flight that would eventually become Apollo 7 in October 1968.
The redesign cost time and, briefly, confidence. But it also bought something. The eighteen-month pause gave the Instrumentation Laboratory and its manufacturing partner, Raytheon, room to finish, test, and harden Block II rather than rush a transitional design into service. The computer that emerged from that pause was materially better than the one that would have flown in 1967.
Block II — The Machine That Went to the Moon
Block II is best understood not as a clean-sheet redesign but as a consolidation and expansion of everything Block I had proven. The architecture — the 15-bit word plus parity, the instruction set, the interpreter, the central registers — carried over (these are the subjects of Volume 6). What changed was the implementation density, the memory budget, the I/O, and the resilience.
Fewer Chips, More Logic
The single most counter-intuitive fact about Block II is that it did more with fewer integrated circuits. Block I used about 4,100 packages; Block II used roughly 2,800. The trick was a better part: Fairchild’s newer dual three-input NOR gate (the 9915-type device), which put two NOR gates into a single flat-pack instead of one. Two gates per chip meant that even as the logic grew more capable, the chip count fell. A handful of expanders and sense amplifiers rounded out the parts list, but the overwhelming majority of Block II’s logic was still that one humble, repeated gate — now doubled up.
This is the heart of the Block II story and a small parable about how integrated circuits actually changed computing: not by any single dramatic leap, but by quietly packing more function into the same package, so that capability rose while size, weight, and power held flat. Block II kept the same ~70-pound, ~55-watt, 2.048-MHz envelope as Block I, yet delivered substantially more computer inside it. (The deeper IC manufacturing story — yields, packaging, and MIT’s outsized appetite for Fairchild’s output — is Volume 4.)
More Memory
Block II’s expanded memory budget is what made the lunar-landing software possible. Erasable memory doubled, from about 1,024 to 2,048 words (1K to 2K). Fixed rope memory grew by half, from about 24,576 to 36,864 words (24K to 36K). The extra fixed storage held the larger, more sophisticated flight programs — the Colossus command-module software and the Luminary lunar-module software — while the extra erasable space gave that software room to keep state, stage tables, and recover gracefully. When you read in Volume 10 about the 1201 and 1202 alarms during the Apollo 11 descent, the reason the computer could shed low-priority work and keep flying instead of crashing rests squarely on Block II’s larger erasable store and its restart machinery.
Better Interfaces, Better Restart, Better DSKY
Block II also reworked the spacecraft interface. The I/O channels were redesigned and the electrical interfaces to the rest of the command and lunar modules were cleaned up and made more robust. Most consequential for reliability was an improved restart capability: the Block II hardware and software together could detect a fault — a transient, a power glitch, an overload — restart the affected programs from protected restart points, and resume the mission rather than losing it. This software-managed resilience, leaning on hardware support that Block I lacked, is precisely what saved the first lunar landing.
The crew interface — the DSKY, the display-and-keyboard unit that is this series’ namesake — was refined as well. Beyond cosmetic and reliability improvements, the most important architectural fact is one of count: the Block II command module carried two DSKYs wired to its single AGC. One sat on the main instrument panel within easy reach of the crew; the second lived down in the lower equipment bay, beside the sextant and scanning telescope, where an astronaut performed the careful star sightings that aligned the inertial guidance platform. Two DSKYs meant the navigator could talk to the computer from whichever station the task demanded. The lunar module, by contrast, had its own AGC and a single DSKY of its own. (The DSKY itself — its electroluminescent displays, its verb-noun grammar, its keys — is the whole of Volume 8.)
Block I vs. Block II at a Glance
The table below distills the lineage. Treat the round numbers as the well-established canonical figures; sources occasionally cite small variations depending on exactly what is counted (e.g., whether expanders and sense amplifiers are folded into the IC total).
| Attribute | Block I | Block II |
|---|---|---|
| Era / role | Mid-1960s; test article | Flight machine for all crewed missions |
| Logic ICs | ≈4,100 packages | ≈2,800 packages |
| Gate per IC | Single 3-input NOR (RTL flat-pack) | Dual 3-input NOR (Fairchild 9915-type) |
| Fixed (rope) memory | ≈24,576 words (24K) | ≈36,864 words (36K) |
| Erasable (core) memory | ≈1,024 words (1K) | ≈2,048 words (2K) |
| DSKYs per AGC (CM) | One | Two (main panel + lower equipment bay) |
| Restart capability | Limited | Hardware/software restart protection |
| Spacecraft I/O | Original | Redesigned, more robust channels |
| Weight / power / clock | ≈70 lb / ≈55 W / 2.048 MHz | ≈70 lb / ≈55 W / 2.048 MHz |
| Crewed flights | None (AS-202, Apollo 4, Apollo 6 only) | Every crewed Apollo mission |
What the table does not capture is the continuity. Block II was not a repudiation of Block I; it was its vindication. The architecture held. The packaging philosophy held. The bet on a single, repeated NOR gate held — it simply got better silicon underneath it. The redesign forced by tragedy and refined during an enforced pause produced a machine that was lighter on parts, richer in memory, tougher under fault, and more closely fitted to the spacecraft it served.
Why the Evolution Matters
It is tempting, looking back, to flatten the AGC into a single iconic object. But the two-block evolution is part of what made the program succeed. Block I let MIT and Raytheon learn the hard lessons of building a real integrated-circuit computer — procurement, testing, potting, interfacing — on flights where no crew was at risk. Block II then folded those lessons, plus a better chip and the safety-driven rethink that followed Apollo 1, into the version that actually mattered.
The arithmetic of the redesign is the moral of the volume: fewer chips, more memory, more resilience, same box. That is integrated-circuit progress in miniature, and it is the reason a seventy-pound computer drawing the power of a dim lightbulb could carry human beings a quarter-million miles and bring them home. The architecture beneath it (Volume 6), the chips that made it possible (Volume 4), the software that exploited its restart logic (Volume 10), and the missions that proved it (Volumes 12–14) each pick up threads first spun here, in the quiet evolution from Block I to Block II.
Next — Volume 8: The DSKY — Display & Keyboard.