If you’ve ever told yourself, “I’ll finish that project next weekend,” I have news: somewhere out there,
a relay computer has been quietly laughing at you for six years while taking up roughly 4.5 suitcases of space.
And yesthis is a compliment to the builder, not a cry for help (although the suitcases probably have feelings).

This story isn’t just about a wonderfully impractical machine. It’s about how computers actually work when you strip away
glossy chips and let the logic clack, click, and physically move. A relay computer turns invisible computation
into something you can hear, see, andif you’re not carefultrip over.

What “4.5 Suitcases” Really Means (And Why That’s Genius)

The “4.5 suitcases” detail isn’t only a fun measurement unit for nerds who travel with oscilloscopes. It points to a key idea:
modularity. Instead of building one giant monolithic cabinet, the relay computer is organized into foldable panels
that represent major computer subsystemslike memory, control logic, and processing blocks.

That design choice matters. In a classroom or demo setting, a suitcase-style layout lets people walk up to the machine and
understand it in chunks. It’s basically a computer you can “tour,” like a museum exhibit that happens to do math.

Meet MERCIA: “My Simple Relay Computer Under Construction”

The headline-worthy build is tied to a long-running relay-computer project known as MERCIAan acronym that
translates to “My Simple Relay Computer Under Construction.” It’s the rare project name that’s both honest and a little too relatable.

A build log measured in years, not weekends

Building a relay computer isn’t like assembling a desktop PC. You’re not plugging in a GPU; you’re designing a machine from the ground up
using electromechanical switches, wiring discipline, and the kind of patience usually reserved for growing bonsai trees.

Why does it take so long? Because every “tiny” design decision multiplies:
the number of relays, the wire runs, the labeling, the debugging, the physical layout, and the constant question of
“Why is THIS signal here when it should be THERE?”

Why relays (instead of chips)?

A relay is a switch controlled by an electromagnet. Give the coil power, the contacts move. Remove power, they spring back.
That physical motion is the point: a relay computer makes logic visible. Even someone who’s never coded can grasp
the concept of “this switch makes that switch change.”

Modern computers are too fast and too small to watch. Relay computers are slow enough to feel like you’re
observing thought in stop-motion animationminus the claymation, plus the glorious clicking.

How a Relay Computer Computes (Without a Single Microchip Doing the Thinking)

Relays as logic gates

Under the hood, relay logic can implement the same basic building blocks you’d find inside silicon:
AND, OR, NOT, XOR, latches, and flip-flops. The difference is that instead of transistors switching millions of times per second,
you have contacts opening and closing at human-audible speeds.

With enough relays, you can build:

• Registers to hold values (your short-term memory)
• An ALU (arithmetic logic unit) to add, subtract, compare, and combine bits
• Control logic to decide which signals activate in which order
• Memory / ROM to store instructions and constants

Timing, contact bounce, and the slow-motion CPU

A relay doesn’t switch instantly. It has a mechanical travel time and a phenomenon called contact bouncethe
contacts can “chatter” briefly as they settle. In modern electronics, you’d debounce signals with circuits or software.
In a relay computer, you plan around it: timing margins, careful sequencing, and sometimes a little “don’t touch that, it’s sensitive.”

The payoff is educational gold. When your computer is slow, you can actually understand the instruction cycle:
fetch an instruction, decode it, then execute a sequence of micro-operations.
It’s like watching a chef cook step-by-step instead of receiving a pizza via teleportation.

The Suitcase Architecture: Designing for Humans, Not Just Electrons

Panels as a physical map of the CPU

A relay computer becomes dramatically easier to explain when each subsystem is physically separated. Instead of saying,
“The CPU has a datapath and a control unit,” you can point:
“This panel stores values. This one routes signals. This one does math. This one tells the others what to do.”

That’s why the suitcase approach is more than a portability flex. It’s a teaching strategy. The machine is laid out like a diagram you can stand next to.

ROM by switches, microcode by pure determination

One of the most charming (and mildly terrifying) aspects of relay computer culture is how often instruction storage becomes physical.
Some builders use switch banks for ROM. Others use plugboards or removable modules.
The result is that programming can look like setting up a puzzle: flip switches, verify bits, run the clock, and hope you didn’t
accidentally encode “jump to chaos.”

That may sound inconvenient, and it is. But it also forces you to think like early computer pioneers:
What instructions do you really need? How do you represent them? How do you test them?

Big, Loud, and Surprisingly Honest: The Tradeoffs of Relay Computing

Speed: not great, not the point

Relay computers are slow compared to modern electronics. That’s not a flawit’s the feature.
A slow clock makes the internal state observable, which makes the learning real.

If a modern CPU is a hummingbird, a relay computer is a thoughtful tortoise wearing a toolbelt.
It won’t run modern apps, but it will teach you what an app is really asking the hardware to do.

Power and heat: manageable, but not “tiny”

Relays require coil current to stay energized (unless they’re latching relays). Multiply that by hundreds or thousands,
and power design becomes part of the architecture discussion. You’re not just building logicyou’re building a system
that must survive continuous operation without turning your workshop into a space heater.

Reliability: mechanical reality checks

Mechanical contacts wear. Coils heat. Connections loosen. The wiring harness can become a detective novel.
But this is also where relay computers shine as teaching tools: you learn that a computer is not magic.
It’s a carefully coordinated physical system.

From Mark I to MERCIA: A Very Short Relay-Computer Timeline

Zuse Z3: relays doing real work

Relay computers aren’t just a hobbyist stunt; they’re part of computing history.
Konrad Zuse’s Z3 (completed in 1941) used thousands of relays and is widely recognized as an early
programmable, fully automatic digital computer. That’s a reminder that the “clicky” approach once sat at the frontier of engineering.

Harvard Mark I: the giant relay machine era

The Harvard Mark I (also known as the IBM Automatic Sequence Controlled Calculator) was a massive electromechanical machine
built from an enormous collection of componentsrelays, counters, switches, and moreassembled into a calculator-sized wall of ambition.
It did serious work, including lengthy computations that would have been brutal by hand.

The Mark II “moth” moment

Relay computers also gave us one of computing’s greatest stories: the 1947 incident where a moth was found stuck in a relay in the
Harvard Mark II. The bug was taped into a logbook and became a lasting symbol of debuggingproving that sometimes the problem really is… a bug.

What Builders and Students Actually Learn from a Suitcase Relay Computer

You learn that “architecture” is not a buzzword

When you build at this level, you can’t hide behind abstractions. You must decide:
How wide is the data bus? How do you address memory? What is the instruction format? How do you branch or loop?
Even if the machine is “simple,” those decisions are the bones of computer design.

Debugging becomes physical

In software, a bug is often invisible. In a relay computer, a bug can be a wire swapped, a relay stuck, a contact bouncing,
or a timing assumption that was “probably fine” until it absolutely wasn’t.

And the funny part? You can often hear the problem.
A healthy machine has a rhythm. A confused machine develops a stutter. It’s like listening to a drummer miss a beatexcept the drummer is your control logic.

You get a deeper respect for modern simplicity

After you’ve spent time labeling wires and tracing signals, “just write a program” feels like a miracle.
Relay computers teach gratitude. They also teach humility, because every success is earned one click at a time.

If You Wanted to Build One, Start Smaller (Your Future Self Will Thank You)

MERCIA-scale projects are inspiringbut you don’t need 4.5 suitcases to learn the core lessons.
If you’re tempted to build your own relay computer, try a staged approach:

Step 1: Build one logic block

• A 1-bit adder with carry
• A simple latch (store a single bit)
• A clocked register (store a few bits)

Step 2: Combine into a tiny datapath

Make a 4-bit ALU that can add and subtract. Add indicator lights for each bit.
Now you have a machine you can demonstrate in minuteswithout needing a moving truck.

Step 3: Add control and an instruction format

Create a small instruction set: LOAD, STORE, ADD, JUMP, HALT. Even a handful of instructions is enough to teach
the difference between data and control, and why sequencing matters.

Step 4: Treat wiring like a first-class feature

Color-code signals. Label everything. Build test points. Write a simple checklist for every change.
In relay computing, “organization” isn’t a personality traitit’s a survival strategy.

Closing Thoughts: The Beauty of Slow, Clicky Truth

“Relay Computer Consumes Six Years And 4.5 Suitcases” is a hilarious headline, but it’s also a powerful idea:
you can build a computer out of understandable parts and use it to teach real architecture.
MERCIA doesn’t compete with modern machines on speed. It competes on clarity.

In a world where technology is increasingly invisible, there’s something refreshing about a computer that announces every decision with a click.
It’s computation you can witnesslike the curtain finally pulled back on the wizard.

Experiences: What It’s Like Living With a Relay Computer Project

The first experience you have with a relay computer is emotional whiplash. One moment you’re proud because you made a relay click on command.
The next moment you realize you just built the world’s loudest, slowest, most determined light switchand you still have about 9,999 clicks to go
before it resembles anything you’d call a computer.

Then comes the wiring era, which is less of a phase and more of a lifestyle. You start labeling wires with a seriousness usually reserved for
aerospace engineering. You develop opinions about cable ties. You buy more markers. You lose the markers. You find the markers in your pocket.
The project quietly trains you to become the kind of person who says, “Waitwas that the green-with-white-stripe or the white-with-green-stripe?”
and means it.

Debugging is where relay computing feels most different from modern work. In software, you can add a print statement. In a relay machine,
your “print statement” is often a lamp, a meter, or simply listening. When something is wrong, the machine’s rhythm changes.
It might click too fast (a loop you didn’t intend), click too slow (a relay not pulling in), or click in a pattern that sounds like it’s
arguing with itself. You end up diagnosing logic the way a mechanic diagnoses an engineby smell, sound, and a growing suspicion that
the problem is one millimeter away from where you’ve been staring for an hour.

The strangest joy is watching someone else understand it instantly. A student who doesn’t care about CPUs can still understand “this relay moves
that contact.” They can see cause and effect. They can trace a signal like it’s a story. When the machine finally performs a small programmaybe
adding two numbers, stepping through a sequence, or branching correctlypeople react like it’s alive. Not because it’s fast, but because
it’s legible. It’s computation you can follow with your finger.

Another experience: you learn to respect timing in a way that textbooks rarely deliver. Contact bounce stops being a definition and becomes a
real villain. You discover that “this should be fine” is not a design method. You find yourself adding margin, staging signals,
and thinking about what must happen first, second, and third. That mental model transfers everywhere: to programming, to electronics, to how you plan.
A relay computer makes you think in sequences and dependencies. It turns architecture into something your hands can’t ignore.

You also learn the art of incremental victory. Nobody finishes a relay computer in one heroic weekend montage.
You finish tiny parts: a stable clock, a clean latch, a register that holds steady, an adder that works every time.
You celebrate ridiculous milestones like “the carry bit didn’t betray me today.” Over time, those victories stack up into a system.
The machine teaches persistence without giving motivational speeches. It just sits there like a patient teacher and says, with every click,
“Try again, but this time, do it properly.”

And yesthe suitcases. Eventually you understand why someone would package a relay computer into foldable panels.
When your project grows, it doesn’t just take space; it takes presence. A suitcase modular build is a way of saying:
“This is big, but it’s organized. This is complex, but it’s explainable. And if I need to move it, I’m not calling a forklift.”
The suitcases become part of the story, and the story becomes part of the lesson.

In the end, the most memorable experience is the moment you realize the machine is doing exactly what you told it to doeven when that’s wrong.
That’s the honest relationship relay computing offers. It doesn’t guess. It doesn’t optimize. It doesn’t hide.
It just executes, click by click, until you learn how to speak its language clearly.