homelabprivacy

Build a DIY 16-bit Magnetic Core Memory Module

🤖 Researched and drafted automatically from the official docs, and reviewed before publishing. Commands are taken from the source projects — but always sanity-check before running anything on your own hardware.

Magnetic core memory was the standard for computers from the 1950s through the 1970s. Unlike modern DRAM, it’s non-volatile, mechanally robust, and completely immune to electromagnetic interference. Building a working 16-bit core memory module teaches you how early computers actually stored data—and you can hold the result in your hand.

This guide walks you through assembling a functional core memory array based on the Maxim SAM (Simple As Possible) Computer reference design. You’ll hand-wind toroids, thread cores, and wire a complete read-write system. No simulation; this runs real hardware.

What You’re Building

A 16-bit x 1-bit core memory plane: 256 ferrite cores arranged in a 16×16 grid, with sense and drive windings that let you read and write data using pulse-addressed selection. The SAM design includes all the pulse generation and decode logic you need.

Gather Your Materials

  1. Ferrite cores: You need 256 cores. The SAM reference design specifies small toroidal cores (typically 0.5–1 inch OD, 0.25–0.5 inch ID). Surplus stock from old core memory arrays is your best source—search eBay or electronics surplus dealers for “core memory” or “ferrite toroid 16”. New cores are expensive; used ones are pennies each.

  2. Wire: 28–32 AWG magnet wire for threading and windings. You’ll need roughly 500 feet total—plan for waste.

  3. PCB or wire-wrap board: The SAM design uses a single-sided PCB, but you can hand-build on perfboard or wire-wrap if you prefer. Maxim provides PCB Gerber files on the reference design page.

  4. Pulse transformers and driver ICs: The SAM uses small signal transformers for the X and Y select lines, and standard logic ICs (74-series TTL) for decode and timing. See the schematic on the Maxim page for exact part numbers.

  5. Power supply: 5V for logic, ±12V or similar for the sense amplifier. A basic lab supply works fine.

  6. Hand tools: Needle-nose pliers, wire strippers, small screwdrivers, and patience.

Step 1: Prepare the Core Array Frame

You need a rigid structure to hold 256 cores in a 16×16 grid. Options:

  • PCB approach: Order the SAM Gerber files from Maxim and have a board house fabricate it. This is the fastest and most reliable.
  • Hand-built approach: Use a perforated aluminum or plastic frame, or carefully glue cores into a wooden grid with 0.5-inch spacing.

If you go hand-built, use a jig—drill or mark holes precisely. Cores must be aligned so wires thread cleanly. Test-fit a few cores before committing to the full 256.

Step 2: Thread the Sense and Drive Lines

The core array has four sets of wires running through all cores:

  • X-select line: One wire through all cores in each of 16 rows. Thread this wire through the center of all 16 cores in row 1, then row 2, and so on. Use 30 AWG wire; twist it gently to avoid damaging cores.
  • Y-select line: One wire through all cores in each of 16 columns. Thread perpendicular to X.
  • Sense line: One wire threaded through all 256 cores, usually in a serpentine pattern to pick up magnetic flux changes.
  • Inhibit line (optional): Allows selective write inhibition; thread like sense.

Work slowly. A single break or short ruins the line. Use a wire guide (a small tube or needle) if threading is tight. Plan 4–6 hours for this step alone.

Step 3: Build the Drive and Decode Logic

The SAM design includes:

  • X and Y decoders: 4-to-16 decoders (74154 or similar) that select one row and one column based on a 4-bit address.
  • Pulse generators: Small signal transformers and driver ICs that create the ~300 mA current pulses needed to flip core magnetization.
  • Sense amplifier: A low-noise amplifier that detects the voltage induced in the sense line when cores flip.
  • Timing and control: Simple logic to sequence read and write operations.

Build this on your PCB or perfboard following the schematic. Use a logic analyzer or oscilloscope to verify pulse timing and amplitude as you go. The SAM reference design includes timing diagrams; match them.

Step 4: Test Read and Write

Once wired:

  1. Apply power to the logic and sense amplifier. Do not apply drive current yet.
  2. Use a function generator to manually clock the decode logic and fire one X and one Y select line. Measure the current pulse with an oscilloscope—it should be ~300 mA for ~1 µs.
  3. Observe the sense line with an oscilloscope. You should see a small (~50 mV) pulse when a core flips.
  4. Write a test pattern: Select one core, apply a write pulse, then read it back. You should see a sense pulse.
  5. Repeat for a few cores to confirm the array is working.

Step 5: Verify the Full 16-Bit Plane

Once single-core tests pass:

  1. Write a known pattern across all 16 bits in one address (e.g., 0xAAAA).
  2. Read it back. All 16 sense lines should show pulses for the bits you wrote.
  3. Write a different address and verify the old data is still there.
  4. Perform a few hundred read-write cycles to check for reliability.

If any core fails to flip or sense, check for open wires or shorted turns. A multimeter across the drive lines will show shorts; a visual inspection under magnification will catch broken threads.

Honest Reality Check

This project is slow, fiddly, and teaches you nothing about modern computing. But it teaches you everything about how computers worked when they were built by hand. You’ll understand why core memory persisted for 20 years—it’s reliable, simple, and works in ways that feel almost mechanical.

If you want a working retro computer, this is overkill; emulation is faster. If you want to understand the physics and engineering of early computing, and you don’t mind spending 20–30 hours on a 16-bit memory array, this is unbeatable. The SAM design is well-documented and genuinely functional. You’ll have a piece of hardware that still works the way computers worked in 1960.

Keep this on the bench. It’s not a networked device, so no LAN or VPN needed—just don’t connect it to anything you care about until you’ve tested it thoroughly.

Is It Worth It?

Yes, if you’re building it to learn. No, if you’re building it to compute. The value is in your hands and your understanding.

Related video

New self-hosted AI & homelab shorts, daily.

Subscribe on YouTube

Related guides

← All guides