Steady Hand and the Long Climb Out of Nothing: A Hand-Built EEPROM Programmer with No CPU Inside

There is a quiet contradiction at the center of homebrew computing. People who set out to build a computer from discrete chips, to understand a machine all the way down to its gates, almost always reach for a modern laptop the moment they need to write data into memory. The EEPROM that holds the homebrew computer's first instructions gets programmed by a device orders of magnitude more complex than the thing being built. The foundation is poured using machinery nobody in the room could reproduce. Steady Hand, a project published on Codeberg by interrupt_tv, is an attempt to notice that contradiction and do something about it.

The thesis is stated plainly in the project's own framing. Steady Hand is "a digital circuit for programming EEPROMs by hand," and its defining features are stated as absences rather than capabilities: no microprocessor, no programmable logic except the EEPROM being programmed. That second clause is the interesting one. The only programmable component in the entire apparatus is the very chip you are trying to program. Everything else is fixed-function logic, passive components, switches, and displays. The tool contains no smaller version of the problem it solves.

Where the idea comes from

The project is honest about its lineage, and the two sources it cites tell you what kind of object this really is. The "how" comes from Ben Eater, whose video on building an EEPROM programmer from DIP switches and jumper wires has introduced a generation of hobbyists to the physical reality of memory. Eater's design is deliberately crude: you set an address on one bank of switches, set a byte on another, and pulse a write line. It works, and it teaches, but it is tedious in the way that flipping sixteen switches to enter a single byte is always tedious.

The "why" comes from a different and more philosophical place. The author points to Jeremiah Orians' stage0 project, which is concerned with bootstrapping a complete software environment starting from almost nothing, a tiny hex monitor that can assemble a slightly larger tool, which assembles a larger one still, climbing hand over hand from a few hundred bytes of human-entered machine code up to a full toolchain. Stage0 is about trust as much as it is about engineering. If you can build everything from a seed small enough to audit by eye, you never have to take the contents of a binary blob on faith.

Steady Hand extends that instinct one layer further down, into the hardware. Stage0 still assumes you have some way to get those first bytes into a machine. Steady Hand is a candidate answer to that assumption, a device that could, in principle, write that initial seed into an EEPROM without any pre-existing computer being involved at all. The author describes it as "a first step towards resolving this problem," and the modesty of that phrasing is appropriate, because the chain of bootstrapping has many links and this addresses only one. But it is a real link, and most people never think to question it.

How the machine is built

The ergonomics are where Steady Hand departs from its inspiration. Instead of toggling binary switches for every byte, the operator uses a hexadecimal keypad, sourced as a 4x5 matrix kit from Digicool Things. The current address, the current byte stored at that address, and the byte about to be written are each shown on seven-segment displays, so the operator always sees the state of the memory rather than working blind. Dedicated keys move to the next or previous address, which turns sequential programming into something closer to typing than to circuit assembly.

Several conveniences accumulate on top of that base. There is an auto-skip function that can jump over or jump to a byte value specified on DIP switches, useful when you are filling a region with a known pattern and want to stop at the next meaningful location. There is a jump-to-address function, again driven by DIP switches, for moving across the memory map without stepping one cell at a time. And there is a write-mode toggle, a small but telling addition, because anyone who has hand-entered data knows the particular grief of an accidental write destroying work you cannot easily reconstruct.

Getting seven-segment displays to show hexadecimal without a microcontroller forces an elegant old solution. The project converts four-bit binary input into the seven-segment patterns using a diode ROM, a read-only memory built physically out of diodes wired at the intersections where a bit should be set. The author first planned to build this on perfboard and then decided to design a dedicated PCB for it, which is a reasonable concession given how many diodes a full hex font requires. A diode ROM is memory you can see, every stored bit a component you could point at, and using one here keeps faith with the project's no-hidden-logic principle.

The build targets the AT28C256 EEPROM and reports being tested with it, while noting that the smaller AT28C16 and AT28C64 parts should work after reconfiguring a few jumper wires, though those configurations remain untested. An optional breadboard-compatible ZIF socket holds the chip, sparing the EEPROM's legs from repeated insertion.

Living with the breadboard

The schematics include a breadboard layout represented, in the author's words, as a ten-layer circuit board, with the frank advice that you will want to make extensive use of KiCad's net highlighting feature "to make sense of this mess." That candor is worth dwelling on, because it captures something true about projects at this level. A circuit with no microprocessor does not become simple; the complexity that a CPU would have absorbed into firmware has to live somewhere, and here it lives in the wiring. Steady Hand is described as more ergonomic than Eater's design but "somewhat more complex," and that trade is the honest cost of removing the programmable part. You can have a simple machine that is painful to operate, or a pleasant one whose internals sprawl. There is no free version.

The to-do list reads like an accurate self-assessment rather than a wish list. The author wants to design a proper PCB version, replace the obsolete MM74C923 key-matrix encoder with a custom encoder built from parts that are still in production, and reduce the ghosting on the seven-segment displays. That middle item is itself a small bootstrapping concern: depending on an obsolete chip to build a machine meant to free you from dependencies is its own kind of irony, and the author has clearly registered it. The project is called "complete enough for now," with a plan to revisit it, especially if loose breadboard connections start causing trouble, which on a ten-layer breadboard tangle they eventually will.

Why a hand-cranked programmer matters

It would be easy to file Steady Hand under hobbyist curiosity and move on, but the implications run a little deeper than the parts count suggests. Most of computing is built on layers we have agreed to stop examining. We trust the compiler that built the compiler, the firmware that flashed the firmware, the factory tooling behind the chip. The argument that runs from stage0 through Steady Hand is that this trust should be earnable, that for any layer of the stack there ought to exist, at least in principle, a path back to something a human could verify with their own eyes and hands. A diode ROM you can read by inspection and a programmer with no opaque processor are exactly that kind of path.

There is also a counter-perspective worth holding alongside the enthusiasm. Reducing dependency is never absolute. Steady Hand still relies on commercially manufactured logic ICs, on diodes someone fabricated, on a keypad kit ordered from a vendor, and on KiCad running atop the very kind of complex modern computer the project gestures away from when it comes to programming. The bootstrap is pushed one level lower, not eliminated, and pretending otherwise would overstate what any single device can do. The value is not in achieving purity but in shortening the chain of things you must take on faith, and in making the remaining links visible enough to argue about.

What Steady Hand demonstrates, then, is less a finished product than a stance. It says that the convenience of programming memory with a laptop has quietly obscured a question worth asking, namely whether we could do it without one, and it answers that question with a working circuit rather than an essay. The seven-segment displays showing an address you entered by hand are a small reminder that every computer's first byte had to come from somewhere, and that somewhere does not have to be a black box. The full schematics, breadboard layout, and documentation are available in the project repository on Codeberg for anyone inclined to climb down a layer and see the foundation for themselves.