Spacelab's 128 KB of RAM Was More Than a Million Tiny Ferrite Rings

Ken Shirriff has taken apart the core memory module from a 1980 Spacelab computer, and this may be one of my favorite pieces of computer archaeology in a while.

The computer had 128 KB of RAM. Not 128 gigabytes, not 128 megabytes—128 kilobytes. And it takes up roughly a third of the computer. The reason is wonderful: every individual bit is stored in a tiny ferrite ring. One ring, one bit. You can actually look at the memory and see the bits.

Modern DRAM is so dense that the physical representation of a bit is essentially abstract. There is no useful way to point at a package and say that one right there is bit 47. Core memory is different. Each ferrite core can be magnetized in one of two directions—one direction represents a zero, the other a one. Four boards, each with 294,912 cores, add up to 1,179,648 individual rings for 128 KB of usable data, plus parity and storage-protection bits on 18-bit words. It is magnificent.

Core memory also behaves in ways that feel wonderfully alien. Reading a bit is destructive. To determine what a core contains, the hardware attempts to force it into the zero state. If it was one, its magnetic field flips and produces a tiny pulse in the sense wire—then the computer has to write the one back. Every read is effectively:

read
destroy
restore

We spend enormous effort today avoiding accidental writes to memory. These machines intentionally rewrote memory as part of reading it—and somehow we sent them to space.

You also cannot run an independent wire to a million rings. Coincident-current addressing solves that: X and Y wires through a grid, with neither current alone strong enough to flip a core, but their intersection enough to change that one ring. It is an AND gate implemented by physics. Sense wires, inhibit currents, diode matrices, and millivolt-scale signals do the rest. By 1980 semiconductor RAM had already taken over most computing, so this Spacelab design is a late, sophisticated version of a technology near the end of its life—2½D architecture, integrated drivers, clever wiring packed around those little rings.

Aerospace hung onto core longer for good reasons. It was nonvolatile—power off, magnetic state remains. It was also resistant to radiation. A memory technology where every bit is a relatively enormous chunk of magnetized ferrite is not subtle, and it is pretty difficult for a stray energetic particle to casually convince that ring it has changed its mind.

The immediate thought I had while reading this was that we should build one now. Not because it makes any practical sense—it absolutely does not, and that is part of the appeal. Something delightfully absurd like:

CPU: modern ARM
storage: NVMe
network: gigabit Ethernet
core memory: 64 bytes

And those 64 bytes would be the most interesting memory in the machine. People are already experimenting: Ben North and Oliver Nash's 32-bit Arduino shield, Han's 512-bit module around 200 kHz, a Japanese maker's 128-byte USB device on a Raspberry Pi Pico that actually moved files between two modern computers. That is only 1,024 bits. Spacelab had 128 KB. Perhaps we should start smaller.

What attracts me is that you can understand it—not merely an abstraction, but the physical thing. Here is a ring. Magnetize it this way and it means zero; the other way and it means one. These wires select it; this wire detects when it changes. Modern computers are incomparably better machines, and I am not interested in trading DDR5 for a million hand-threaded ferrite rings. But something was lost as computing became too small to see. Shirriff's teardown makes 128 KB of RAM feel extraordinary again, and now I really want a few bytes of core memory connected to something unnecessarily modern.

Read Ken Shirriff's full teardown of the Spacelab core memory system.