Tuesday, June 02, 2026

There Are Far More Efficient Ways to Run Neural Networks

 

There Are Far More Efficient Ways to Run Neural Networks

The entire AI industry has standardized on one primitive — the dense floating-point matrix multiply — and then built a trillion-dollar edifice of GPUs, data centers, and capital around the assumption that intelligence is that primitive at scale. It is worth saying plainly: that is an assumption, not a law of computing. And it is an expensive one.

I want to make a narrow, concrete version of this argument, because the sweeping version is easy to wave away. Here it is: a neural network can run with no multiplications at all, and the arithmetic we burn most of our energy on is optional. I’ll show it running, then say where it leads.

How we got locked in

In 2012 a big neural network plus a GPU plus a large dataset worked, and the field reorganized around that fact. Every layer of the stack since then has been optimized for dense floating-point matmul: tensor cores designed to feed it, libraries tuned for it, model architectures shaped to saturate it, frameworks that assume it. The loop is self-reinforcing — hardware rewards matmul, so researchers choose matmul-shaped models, so the next hardware doubles down on matmul. After a decade it stops looking like a choice and starts looking like physics. It isn’t.

Where the waste is

The cost of inference is dominated by two things: floating-point multiply-accumulates, and moving 32-bit weights out of memory. Multiplication is among the most expensive operations a chip does; a memory fetch can cost far more than the arithmetic it feeds (see Horowitz, Computing’s Energy Problem, ISSCC 2014). A modern accelerator is a machine built to maximize exactly these operations, fed continuously from DRAM, clocked whether or not the numbers it is grinding actually matter. The brain, by contrast, runs general intelligence on roughly twenty watts — no floating-point multiplier, event-driven, sparse, with memory and compute in the same place. That is not mysticism; it is a different set of primitives.

A network that runs on pulses, not multiplies

Here is the concrete part. I built a small pulsed neural network and ran it on MNIST. It is not a ±1 “binary” network and it does no XNOR tricks. It works the way pulse-stream signal processing works: a value is a stream of pulses (its magnitude is the pulse rate), polarity is a sign clock, and each neuron simply integrates pulses and fires when its accumulator overflows a threshold — the overflow is the activation. A value×weight product becomes “deliver the input’s pulses, each adding the weight.” Sum-then-threshold becomes “accumulate until you overflow and fire.” No multiplier appears anywhere in inference.

It classifies. Trained conventionally and then run purely as pulses:

reference (floating-point) test accuracy: 94.23%

pulses/input (T)   test accuracy
         1            11.40%
         2            58.50%
         4            88.20%
         8            93.00%
        16            93.70%
        64            93.60%

As you spend more pulses, accuracy climbs from chance to within half a point of the floating-point network, and saturates around sixteen pulses per input. That curve is the whole story of rate coding: more pulses = more precision = more energy. It is a knob you control, not a fixed tax. The code is a single dependency-light file you can run yourself; the link is at the bottom.

I’ll be honest about what this does and does not prove. It proves the arithmetic is optional — the network’s function survives with pulses and overflow-firing and zero multiplies. It does not prove this is faster on your laptop. It isn’t: a CPU or GPU is the wrong machine for it, because those chips are built to do the very floating-point matmul we just removed. Emulating pulses on a GPU is slower, not faster. That is the point, not a footnote.

Why the GPU loses, and what wins

A GPU is the maximal embodiment of the old assumption: dense floating point, DRAM-fed, clock-synchronous. Every design decision that makes it superb at matrix multiplication becomes a liability the moment the workload stops being matrix multiplication. The alternatives don’t out-matmul the GPU — they make matmul irrelevant:

  • Pulsed / event-driven computation: energy proportional to activity, not to a clock. Work happens only when a pulse arrives.
  • No floating-point unit to power, because the model doesn’t need one.
  • Weights on-chip, killing the DRAM traffic that dominates the energy budget.

The clearest existing picture of this substrate is the GreenArrays GA144: 144 asynchronous cores, no floating point, picojoule-scale per operation, cores that sleep instantly when no data is flowing, and enough on-chip memory to hold a binary/pulsed model with no external weight fetches. An async, FP-free, on-chip, event-driven array is exactly the machine a pulsed network wants — and the opposite of a GPU in every design commitment.

To be careful: the GA144 energy advantage for this workload is, today, a projection from its architecture, not a benchmark I am handing you. The honest next step is to run a pulsed inference kernel on a GA144 (or its cycle-accurate simulator) and publish the measured instruction and energy counts. That is the experiment worth funding — and it costs a rounding error against what we are spending pouring concrete for matmul.

The claim

GPUs are not obsolete tomorrow, and training will live on dense hardware for a while. But the assumption that inference at planetary scale must be floating-point matrix multiplication is a 2010s artifact, and it is breaking. The arithmetic is optional; the substrate is a choice; and we have barely funded the alternatives. There are far more efficient ways to run these networks. Here is one of them, running.


Working example (MIT-licensed): a pulsed integrate-and-fire MNIST network in one file —  https://github.com/johnsokol/bnn-example   (python3 pulsed_nn.py).


© 2026 John L. Sokol.

groundbreaking new paper introduces a next-gen neuron model inspired by real cortical cells.


groundbreaking new paper introduces a next-gen neuron model inspired by real cortical cells.

Most neural nets are still based on the model of a neuron as proposed in the 1950's: u = activation(w·x + b)

In a new paper, researchers propose a more accurate model of a biological brain neuron and found that it has quite a few advantages, like needing less training data.

the classic point neuron (u = activation(w·x + b)) with a far more biologically realistic version - and it delivers:

- Higher expressivity
- Faster learning
- Better robustness
- Less memorization
- Works with less data
All without adding parameters.
The brain was right all along.

Result? More powerful, faster to train, more robust, and less data-hungry zero extra parameters. and it beats the classic version across the board Better performance

https://arxiv.org/pdf/2605.30370


see also: 


Nixie-clock using neon lamps as logic elements

copied from https://web.archive.org/web/20170824164029/https://wwwhome.ewi.utwente.nl/~ptdeboer/ham/neonclock/

see video here https://youtu.be/v3oUTgtCUb0

Nixie-clock using neon lamps as logic elements

[photo of my neon clock]
The above shows my home-built digital clock. It uses Nixie-tubes for readout. In contrast to most other nixie-clocks being built these days, my clock does not use any transistor or IC for driving the tubes. Instead, the driving logic is built from neon lamps, together with resistors, capacitors and silicon diodes.

The project started in 2002, when our university library was selling old outdated or otherwise superfluous books, and I very cheaply bought the book "Electronic Counting Circuits" by J.B. Dance, published in 1967, and apparently only ever lent three times by our library, all in 1973. It described how neon lamps can be used as logic elements in a ring counter, exploiting the fact that they need a higher voltage to ignite (the striking voltage) than to stay lit (the maintaining voltage):
[schematic from Dance's book]
Unfortunately, if one substitutes the neon bulbs that are available in electronics shops nowadays, the circuit doesn't work. Dance used lamps that were specifically manufactured for this type of application, with a large difference between their striking and maintaining voltages. Nowadays, such lamps are (presumably) no longer manufactured; the neon bulbs that are still available in shops are meant as indicator lamps, and have a much smaller difference between their striking and maintaining voltages. This required changing the circuit's resistor values, and makes its operation more critical; furthermore, the lamps need to be selected for matching characteristics.

This is one of the ring counters in my clock:
[photo of one ringcounter]
Four of these are used, to divide the 50 Hz from the mains power (see here for stability measurements) first by 10 (yielding 5 Hz), then by 5 (yielding 1 Hz, i.e., one pulse per second), then further by 10 and 6 to yield one pulse per minute. Note the paper labels still dangling at the cathode wires of the lamps: these are needed to look up the measured properties of each lamp.

Four more ring counters are used dividing by 10, 6, 10 and 3, to count the minutes, tens-of-minutes, hours and tens-of-hours and drive the Nixie tubes:
[photo of one ringcounter with LDRs]
The nixie tubes are driven through Light Dependent Resistors (LDRs): under the influence of the light from the neon lamp, their resistance lowers, connecting one nixie cathode to the negative power supply. In order for the LDR not to be influenced too much by ambient light, while still allowing the neon bulb to be visible, an optical attenuator and filter is used between them, consisting of a black cardboard disk with a small hole in it, and two layers of red foil, held together by glue and shrink tube:
[photo of one ringcounter with LDRs]

The ring counters are rather sensitive to ambient light: in complete darkness, they tend not to work. Even though there are always a few bulbs active (if only in the power supply, which is not shown in the photographs), my clock still needs a bit of external ambient light. I'm experimenting with blue LEDs for providing this extra ambient light. This seems to be quite effective: illuminated by just two blue leds, the clock ran perfectly one night long in otherwise complete darkness:
[photo of clock with 2 blue leds]
Note though that the blue in this photo is more intense than it looks like in reality: apparently the camera is more sensitive to this shade of blue than the human eye.

Some other things that I ran into while designing this clock:

  • In contrast to what Dance's book says, one can't cascade the ring counters just by connecting them (when using modern-day neon bulbs). I'm now using an extra neon bulb per counter as an amplifier: it is biased to just under its striking voltage, so a small pulse can strike it.
  • The striking and maintaining voltages of the lamps change quite much during their first hours of operation. Therefore, it is necessary to first "burn-in" (age) the lamps, before measuring their characteristics.
  • Despite selecting my lamps for matching characteristics, some still acted weird and needed to be replaced. For example, I had one which somehow didn't work reliably in the buffer stage; and another one worked reliably in a ring counter when clocked at about 1 Hz, but not when getting a pulse only once per hour. Apparently, fully characterizing the neon lamps requires more quantities than just the striking and maintaining voltages.

The clock is now electrically functional, but still some work remains to be done. The power supply needs to be built tidily, the aligator clip test leads eliminated, and the whole thing put into a (transparent) enclosure for safety.


Movie and circuit diagram

A short movie (AVI format, 10 MB) of the clock in operation is available here.

Furthermore, the circuit diagram is available in a PDF file. This schematic diagram contains some extra explanation of how specific parts work. This diagram is meant to document and explain the details of my clock, and there will probably be some minor changes made in the future. The diagram is not meant as a complete basis for building another such clock; for example, while some of the resistor values are quite uncritical and determined by what I happened to have at hand, many depend critically on the characteristics of the neon lamps used. (Hopefully needless to say, any prospective builders should take proper safety precautions for working with the high voltages involved.)


Links

  • Many people these days enjoy building Nixie clocks, though usually with modern electronics driving the tubes. See here for a gallery.
  • A mailing list on nixie clocks exists: neonixie-l at Google groups (and formerly at Yahoo).
  • Nixie clocks completely without silicon have also been built: this one and this one use vacuum tubes, and this one uses trigger tubes. Trigger tubes are actually neon lamps with a third electrode to trigger them.
  • In the November 1966 issue of Electronics Illustrated, a description was published for building an electronic calculator using neon bulbs connected as ring counters. (I've also seen reference to a 1967 issue of "Practical Electronics" as apparently containing the same or a very similar article.)

Comments are welcome at pa3fwm@amsat.org.
Copyright © 2007.
Back to my amateur radio webpage.



Monday, June 01, 2026

Laser cut , Snake Bot -

 

This is a 2 Dimensional Snake Robot that has flexible couplings between each joint so It can rest flat on the surface. There are 8 segments, made using 40mm x 40mm x 20mm metal gear High Torque servos


The is constructed from laser cut 4.7mm MDF (Medium Density Fiberboard) , press fit passive Skateboard Bearings 608zz 8mm x 22mm x 7mm. The same type used in fidget spinners.
The design is done in OpenSCAD and was inspired by Japanese woodworking styles, without screws, glue or fasteners with the exception of the RC Servo Hub.

https://github.com/johnsokol/OpenSCAD-misc-projects/tree/master/RCservo-snake


Laser cut pattern file in OpenSCAD. 



 The parts press fit over the servo.  The Bottom left piece just press fits over the servo output and the only screws are the 3mm screws that hold part on to the servo. and the Ball Bearings just press fit over the end of the t on that part. heat shrink or tape should be placed on the ball bearing to increase friction with the surface. 

When fed a sine wave it can propel across a surface with nothing driving the wheels directly. 







Movement


Snake Kinematics


Image from: Locomotion Efficiency Optimization of Biologically Inspired Snake Robots: Eleni Kelasidi, Mansoureh Jesmani , Kristin Y. Pettersen and Jan Tommy Gravdahl






Saturday, May 30, 2026

Iron, Glass, and Orange Light: A 1950s-Style Adder Built From Passive Parts

Iron, Glass, and Orange Light: A 1950s-Style Adder Built From Passive Parts

A build guide for a 4-bit visible adder using only resistors, capacitors, inductors, transformers, and neon bulbs. No transistors, no integrated circuits, no semiconductors of any kind — every active element is a piece of glowing gas, every controlled element is a piece of wound iron. The technology was buildable by the mid-1940s and would have been recognisable to anyone who worked on SAGE or the Soviet Setun. It is buildable today for under $200 in a maker space with a CO₂ laser cutter and a patient weekend of transformer winding.


The 1947 Bell Labs press conference announcing the point-contact transistor hadn’t happened yet. The engineers at MIT Lincoln Lab designing SAGE, the engineers at Penza Plant 50 designing the Setun, and the engineers at the Royal Radar Establishment designing the early ramark systems were all solving the same problem: how do you build digital logic without any active semiconductor element?

The answer they converged on — independently, on three continents — was magnetic amplifier logic, or mag-amp logic: saturating transformers with multiple windings, used as the active switching element. With appropriate biasing and a sinusoidal supply, a single small ferrite-cored transformer is a complete logic gate. Combined with neon bulbs as visible state indicators and bistable storage elements, the whole logic family falls out.

This post is the build guide. The end state is a small wooden-framed device about the size of a hardcover book, with twenty-some glowing orange neon bulbs visible across the front, an audible 60 Hz hum from the transformer in the base, and a row of brass-handled toggle switches that the operator (you, or a kid) uses to enter two 4-bit numbers. Press a “compute” lever and the answer appears as a binary pattern across the output bulbs.

Every active element glows. Every switching element is wound copper on iron. No silicon anywhere. The whole machine is buildable using techniques from 1948.

1. The constraint, and why it matters

If you’re allowed transistors and ICs, building visible adders is a solved problem — drop a 74HC283 four-bit adder on a board, wire its inputs and outputs to neon bulbs through driver transistors, done. The machine you build looks impressive but it’s a cheat: the computation happens invisibly inside a black silicon package, and the bulbs are just decoration.

If you take away the active semiconductors, the design problem becomes genuinely interesting. You have:

  • Resistors — passive voltage division, current limiting, thermal load
  • Capacitors — passive energy storage, AC coupling, time delays
  • Inductors and transformers — passive energy storage, voltage transformation, magnetic coupling between circuits
  • Neon bulbsthe only nonlinear element you’re allowed

The neon bulb is the entire reason the system works. Below about 90 V it’s an open circuit (insulator). Above 90 V it ignites and conducts at about 60 V drop with about 2 mA of current. Once lit, it stays lit until the voltage across it drops below 60 V. This hysteretic, current-limited nonlinearity is what makes logic possible.

Everything else in the circuit is linear, and linear circuits can’t make decisions. The neon bulb is where the decisions happen.

2. The physics, in 400 words

A magnetic amplifier is a transformer with a saturable ferrite core and multiple windings. The trick is that a ferrite core’s permeability collapses dramatically when the core is driven into saturation — typically by an order of magnitude or more. Two regimes:

  • Below saturation: core has high permeability, the gate winding has high inductance, AC current through it is choked off, very little current reaches the load.
  • Above saturation: core has near-vacuum permeability, the gate winding has nearly zero inductance, AC current through it flows freely, full current reaches the load.

You arrange the windings so that control currents push the core toward or away from saturation. Each control winding contributes flux proportional to its current. The sum of fluxes either pushes the core over the saturation threshold (output ON) or doesn’t (output OFF). The control inputs are now the inputs of a logic gate.

For neon-based logic, the load is a neon bulb in series with a current-limiting resistor. When the core is unsaturated, the gate winding chokes off the AC supply current and the neon doesn’t see enough current to fire (or maintain its sustaining voltage between half-cycles). When the core is saturated, the gate winding passes the AC freely, the neon fires each cycle, and the eye sees a steady orange glow (because the 60 Hz cycle is faster than visual persistence).

The control windings carry DC bias derived from upstream stages. The DC comes from earlier neon bulbs being lit or dark — the current flowing through a lit bulb is the “1” signal, the absence of current is the “0” signal.

So the architecture is:

AC supply → saturable transformer (with DC control windings from inputs) → neon bulb → DC output to next stage

Each stage’s neon is both the output indicator (visible orange glow) and the source of DC bias for the next stage’s control winding. The 60 Hz AC supply provides the natural reset every cycle. The whole logic family emerges from this one architectural pattern.

3. The gate: a single mag-amp cell in detail

Here’s the canonical mag-amp gate, drawn out:

       AC supply (100 V RMS, 60 Hz)
              │
              ▼
          ┌───────┐
          │ Gate  │  ←──┐
          │ wind. │     │  Control winding 1 (input A)
          │ N=200 │  ←──┤  Control winding 2 (input B)
          │       │     │  Reset winding (counter-flux, DC bias)
          │ ferr. │  ←──┘
          │ core  │
          └───┬───┘
              │
              ▼
     ┌────────────────┐
     │ R_limit ~10 kΩ │
     └────────┬───────┘
              │
              ▼
        ╭─────────╮
        │ NE-2    │ ← visible output bulb
        ╰────┬────╯
             │
             ▼
            ─┴─ ground (or DC bias return)
             │
             ▼
       output current
       (feeds next stage's
        control winding)

The core is a small ferrite toroid — Magnetics 0R45614TC is a workable choice, or a Fair-Rite 5961002701 in the same size range. Outer diameter about 14 mm, inner diameter about 8 mm, height 5 mm. Saturation flux density about 0.3 T, residual flux density about 0.1 T.

The gate winding is 200 turns of 32 AWG (0.2 mm) magnet wire. Each control winding is 50 turns. The “reset” winding (which counter-biases the core, holding it below saturation when no input is asserted) is 100 turns and is fed by a small bias resistor from the DC rail.

Wound up, the transformer is about the size of a fingernail. Five minutes of winding per gate, once you have the jig.

The output bulb is a generic NE-2 neon indicator. The current-limit resistor sets the steady current to about 1.5 mA when lit. The bulb glows continuously when the core is saturated (each AC half-cycle drives enough current through the neon to keep it ignited; the next half-cycle doesn’t quite extinguish it because of the dwell time of plasma deionization).

4. The basic gates, all from one trick

Different gate functions come from different winding configurations on the same basic transformer. The shared mechanism: control windings contribute flux toward or away from saturation, the threshold is set by the reset winding’s counter-bias.

AND

Two control windings of 50 turns each, both wound in the same flux direction. The reset winding is biased so the core just barely fails to saturate when one control input alone is asserted. When both control inputs are asserted, their combined flux pushes the core into saturation. Output neon fires only when both inputs are present.

OR

Same construction as AND but with the reset bias relaxed. Now one control input alone is enough to push the core into saturation. Either input alone fires the output.

NOT (inverter)

The control winding is wound in opposition to the gate winding’s flux direction. The reset winding holds the core close to saturation by default. Input current in the opposition-wound control winding removes flux from the core, pulling it away from saturation. Output neon is normally lit (input absent → core saturated → AC passes → neon fires) and dark when input is present.

NAND, NOR

AND or OR followed by NOT — but you can do this with one transformer by adding a second polarity-reversed control winding. A NAND gate is the AND configuration plus an extra reset winding driven by a constant DC bias such that the output polarity is inverted relative to AND. One transformer per NAND gate.

XOR — the hard one

There’s no single-transformer XOR configuration that works cleanly. Two practical builds:

Build A (transformer-bridge): Two mag-amp transformers wired such that the output neon sits between their two secondaries. Each transformer is configured as an asymmetric AND. The two ANDs feed the output bulb in opposite polarity. Either input alone causes one or the other AND to saturate and fire the output; both inputs cause both ANDs to fire, cancelling each other at the output node. Two transformers and one output bulb per XOR.

Build B (NAND construction): XOR(A, B) = NAND(NAND(A, NAND(A,B)), NAND(B, NAND(A,B))). Four NANDs from above. Four transformers and one output bulb per XOR, but uses the same gate topology four times — easier to fabricate identical parts.

Build A is more elegant; Build B is more “textbook computer architecture.” For a hobby build I’d pick Build B because the parts are identical and debugging is easier.

5. The supply

A linear AC supply derived from a small step-down line transformer is the right approach. You’re not allowed any active rectification or regulation, so the supply is exactly as simple as possible: line voltage in, step-down transformer, RMS output around 100 V at maybe 50 mA capacity.

Specific construction:

  • Primary: 120 V mains (or 240 V depending on region), via a fused inlet and a power switch.
  • Isolation transformer: an off-the-shelf 1:1 isolation transformer rated for 100 VA is the right first stage. Galvanic isolation from mains is non-negotiable for safety. Cost: $40-60.
  • Step-down transformer: secondary of the isolation feeds the primary of a step-down with a 120:100 ratio (so a small step-down, basically just to clean up the waveform and give you a clean sinusoidal output at the operating voltage you want). Or use a single 120:100 isolation transformer if you can find one.
  • Tank capacitor for waveform cleanup: a 1 μF / 250 V film cap across the secondary suppresses any switching noise from the wall.

The secondary feeds the gate windings of every mag-amp transformer in the device. Total current draw with all 20+ bulbs lit is around 40 mA.

A small bias DC rail for the reset windings comes from a half-wave rectified branch of the secondary — but wait, no diodes either if you’re truly strict. Two options:

  1. Allow a single Selenium rectifier stack (pre-1948 technology, no silicon involved). Cost ~$15 from electronic surplus dealers, looks gorgeous, lasts forever.
  2. Pure-passive bias via resonant LC tank tuned to the second harmonic. A simple bias network using only L and C produces a DC offset by exploiting the nonlinearity of the neon bulbs in the bias branch themselves. More elegant, harder to design.

For the build guide I’ll specify Selenium rectifiers, because they predate the transistor era by decades and the 1900s constraint allows them.

6. The 4-bit adder, fully specified

A 4-bit ripple-carry adder needs four full-adder cells. Each full-adder cell computes:

SUM   = A XOR B XOR C_in
CARRY = (A AND B) OR (C_in AND (A XOR B))

Per-bit component count using mag-amp logic with Build B XORs:

GateMag-amp transformersNeon bulbs
XOR(A, B) — 4 NANDs44
XOR(prev, C_in) — 4 NANDs44
AND(A, B)11
AND(XOR_AB, C_in)11
OR (carry parts)11
Per full-adder cell1111

For 4 bits, that’s 44 transformers and 44 output bulbs in the adder core, plus:

  • 4 + 4 = 8 input register bulbs (one per input bit of A and B), driven by toggle switches with current-limit resistors in series
  • 4 sum-output bulbs (visible answer)
  • 1 carry-out bulb (overflow indicator)
  • 1 “compute” indicator (lit while computation is active, to give the kid a sense that the machine is “thinking”)

Total visible bulbs: 58. Total mag-amp transformers: 44. Total passive components: about 200 resistors and capacitors.

This is a substantial build. About a long weekend of transformer winding once the cores arrive, plus another weekend of PCB assembly and tuning. The result is, I think, the most beautiful pure-passive computer you can build at hobby scale. Every wire that carries information is visible. Every active element glows orange. Every control signal is a current through an iron core that you wound yourself.

7. Build plan

Bill of materials

ItemQtySpecSourceCost
Ferrite toroid core5014 mm OD, FairRite 5961002701 or equivalentMouser, eBay$0.80 each
Magnet wire1 reel32 AWG (0.2 mm), 500 ftDigi-Key, Amazon$30
NE-2 neon bulb60Generic indicatorMouser, Amazon$0.30 each
1/4 W resistors100Assorted values (1 kΩ to 1 MΩ)Mouser kit$20
Film capacitors500.1 μF, 250 VMouser$0.30 each
Toggle switches (DPDT)12Brass handle, panel-mountAdafruit, eBay$4 each
Wooden enclosure130 × 20 × 8 cm hardwoodLocal woodshop, scrap$30
Brass faceplate1Laser-cut 20 × 30 cmOnline laser service$25
Isolation transformer1100 VA, 1:1eBay, surplus$50
Step-down transformer1120:100 V, 100 VASurplus$40
Selenium rectifier stack1Vintage, ~250 V at 50 mAeBay$15
Fuse holder + fuse1250 V, 250 mA slow-blowMouser$5
Power inlet (IEC C14)1With switch and fuseMouser$8
Hookup wire50 ft22 AWG stranded, multiple colorsAdafruit$20
PCB1Two-layer, 200 × 250 mmJLCPCB or OSHPark$30

Total component cost: approximately $190.

Tools

ToolWhat forCost if buying
Soldering ironThrough-hole assemblyAlready have
Winding jig (DIY)Holding the toroid while you windBuild from scrap wood and a small hand-drill chuck
MultimeterVoltage testingAlready have
Variac (variable autotransformer)Bringing up the supply gradually during first power-onBorrow from maker space, or do without
OscilloscopeWatching gate waveforms during tuningBorrow, or do without (visual inspection of bulb states works)
Hand drillWooden enclosure constructionAlready have
Wood-finishing suppliesIf you want the steampunk aesthetic$30

Winding the transformers

This is the bulk of the build. Each transformer needs:

  1. Gate winding: 200 turns of 32 AWG on the toroid. Start with a 30 cm tail, wrap 200 turns evenly distributed around the core, end with a 30 cm tail. The tails become the connections to the rest of the circuit.
  2. Control windings: 50 turns each, in the right flux direction for the gate’s logical function. Mark the direction carefully — winding direction determines whether a control input drives the core toward or away from saturation. I use a Sharpie dot on the core to indicate “start” direction.
  3. Reset winding: 100 turns, wound to oppose the control windings (so the reset bias keeps the core below saturation when no inputs are asserted). Fed by a fixed bias resistor from the DC bias rail.

A winding jig is a small handheld drill with a chuck that grips a wooden form holding the toroid. Crank the drill slowly while feeding wire. With practice you can wind a 200-turn gate winding in about 3 minutes.

Wind all 50 transformers before starting the PCB work — it’s monotonous but goes faster if you batch it.

PCB and assembly

Design the PCB in KiCad with the layout matching the logical structure of the adder. Each full-adder cell occupies a roughly 60 × 60 mm region. The transformers mount in through-holes, the neon bulbs sit in dedicated holes that come up through the brass faceplate, the resistors and caps lay flat on the board.

The aesthetic move: mount the bulbs on the underside of the brass faceplate, with the wood frame holding everything together. From the front, you see polished brass with orange-glowing holes. From the back, you see neat rows of wound iron toroids on a PCB. Both sides are photogenic.

Assembly order:

  1. Build the supply section first. Verify clean ~100 V AC and ~120 V DC bias before installing anything downstream.
  2. Build and test one full-adder cell. Verify all 8 input combinations produce the correct output. Tune the reset bias to set the threshold right.
  3. Build the remaining three cells, reusing the tested topology.
  4. Wire the ripple-carry path.
  5. Wire the input toggles and output indicator bulbs.
  6. Final assembly into the wooden case.

8. Safety

100 V AC from a transformer secondary, while much less dangerous than mains AC, is still capable of causing painful shocks and (under unusual circumstances) lethal cardiac fibrillation. Take it seriously.

Non-negotiable rules:

  1. Isolation transformer between mains and everything else. No exceptions. The whole device’s secondary side floats relative to earth ground. A single hand-to-device contact is then just a one-point contact and won’t pass current.
  2. Fuse the primary. A 250 mA slow-blow fuse in the IEC inlet protects against catastrophic failure (a shorted transformer winding could otherwise melt the supply harness and start a fire).
  3. Enclose all live conductors. The wooden case has the only user-accessible surface as the front brass plate with its toggles and bulb holes. Everything behind it should be screwed shut, not snap-fit. A determined kid with a screwdriver could still get in, but they’d have to mean it.
  4. One-handed operation rule. Anyone working on the powered device keeps one hand in their pocket. Current through the chest is the dangerous path; one-handed contact bypasses the chest entirely.
  5. Bleeder resistors across any DC capacitor. Even with no semiconductor regulation, the bias capacitor can hold a 100 V charge for minutes after disconnect. A 1 MΩ resistor across each cap drains it in seconds.
  6. Warning label. Inside the case, a label reading “100 V AC internally. Service by qualified personnel only. Disconnect mains and allow 30 seconds before opening.”

If your maker space has a hard cap at “low voltage only,” this project is over the line. Talk to leadership before starting.

9. What you’d actually see

Power on. The supply takes a couple of seconds to come up; the 60 Hz hum from the transformer is audible. The “compute” indicator bulb is dark (no compute happening). The input register bulbs reflect whatever the toggle switches are set to — flip a switch, the corresponding bulb lights orange or goes dark.

Set A = 0101 (5) and B = 0011 (3) using the toggles. Eight bulbs across the input rows are lit in the appropriate pattern.

Press the “compute” lever. The compute indicator lights. Across the adder core, you see a cascade of bulbs lighting and extinguishing as the gates resolve. The XOR cells flicker as they settle. The AND cells either light or stay dark. The OR cells in the carry chain light in sequence as the carry ripples from bit 0 to bit 1 to bit 2 to bit 3.

The whole resolution takes about 200 ms — slow enough to watch. The 60 Hz supply means each gate has to wait at least one half-cycle to resolve, and the cascade through four ripple stages adds up.

When it settles, the sum bulbs show 1000 (8) and the carry-out bulb stays dark. The compute indicator turns off after a second to indicate “done.”

Press reset. All bulbs go dark. Set new inputs. Press compute again.

This is what computation looks like when computation is slow enough to see. No abstractions. No hidden silicon. Every signal that participates in the answer is a bulb you can point at.

10. Lineage and why it matters

The technology described above existed by 1947, was used heavily in the 1950s, and lost its battle with the transistor by 1960. Specific historical artifacts:

  • The Soviet Setun ternary computer (1958) used mag-amp logic extensively. It is the most famous of the post-vacuum-tube, pre-semiconductor computers and operated until 1965. A working rebuild exists at Moscow State University.
  • The SAGE air-defense system (deployed 1958-1983) used mag-amp logic for its signal-conditioning and parts of its display electronics. The IBM AN/FSQ-7 mainframe at the heart of each SAGE site was vacuum-tube-based, but the peripherals around it were heavily mag-amped.
  • Several US Navy fire-control computers of the 1940s and 1950s (notably the Mk 56 and Mk 1A gun-director computers) used mag-amp logic combined with electromechanical resolvers. Many of these survived into the 1980s aboard cruisers and destroyers because they were genuinely irreplaceable — no transistor equivalent had been built.
  • The Bendix G-15 personal computer (1956) used a hybrid of vacuum tubes and mag-amp logic.

These machines have been forgotten in the standard “valve → transistor → IC” narrative of computing history. They were a real technology, genuinely competitive with transistors for the better part of a decade, and lost not because they were bad but because semiconductor fabrication scaled exponentially while transformer winding did not.

What you’re building is a small descendant of those machines. It uses the same principles, the same kinds of components, and produces the same kind of visible orange-glow output. It is, in its small way, a working museum piece — a thing that demonstrates a road computing history could have taken further than it did.

It is also, I think, the most beautiful homemade computer you can build without a fab. Every signal glows. Every gate is wound iron. Every wire is doing work you can see.

If a child watches it count, the lesson is the same as for the pneumatic version, but with a different aesthetic. The pneumatic version says “this is computation as moving things.” The mag-amp version says “this is computation as iron, glass, and light.” They’re both right.

11. Going further

A few directions if you finish the basic adder and want more:

  • Build it twice — two identical 4-bit adders side by side, wired so the carry-out of one feeds the carry-in of the other, gives you an 8-bit adder. Same components, double the bulbs.
  • Add a multiplier. A 4-bit × 4-bit multiplier built from shift registers and conditional adds, all in mag-amp + neon, would be the most ambitious pure-passive computer build I’m aware of in current hobbyist work.
  • Add an audio output. The 60 Hz hum from the transformer and the 60 Hz cycling of the gate windings make a natural musical signal. A small speaker coupled to the bias rail through a capacitor would produce an audible “computation hum” that shifts pitch slightly when different gates are active. Aesthetic bonus.
  • Mount it in a display case with a small explanatory placard. The whole device is a working sculpture; treat it as one. A glass-fronted oak cabinet, brass faceplate engraved with operation instructions, a small typed history of mag-amp computing on a card beside it.

Coda

The thing I love about pure-passive logic is that it can’t be opened up to reveal a layer of cheating. There is no integrated circuit hidden behind the bulbs. There is no microcontroller in the base secretly doing the work. The wound iron transformers ARE the gates. The neon bulbs ARE the storage. The wire is just wire.

A modern computer is mostly an exercise in trust. You trust that the billion transistors inside the SoC are doing what the datasheet says they’re doing. You can’t see them. You can’t probe them. You can’t verify them. The machine works because the abstractions hold all the way down.

A mag-amp neon adder is the opposite. Every part of it is visible. Every signal can be probed with a meter. Every gate’s behaviour can be watched. The whole computation is in plain sight, in plain physics, running slowly enough to think about.

I want one. If you build one, send me a photograph. If you make a kit and put it on Tindie, I’ll buy one. The space of working visible computers is small; the space of working visible passive computers is smaller still. There’s room.


Further reading

  • Magnetic Amplifiers — Theory and Application, William A. Geyger, McGraw-Hill, 1957. The textbook.
  • Saturable Reactor Computers, R. C. Booton et al., Proceedings of the IRE, March 1957. Specific to mag-amp logic.
  • Brusentsov, N. P. Setun: A Ternary Computer, Moscow State University, 1959. (Russian; partial English translations exist online.)
  • MIT Lincoln Laboratory Journal, Vol 22 No 2 (2017): historical retrospective on SAGE.
  • Neon Lamp Manual, General Electric, 1966. Chapter on relaxation oscillators and bistable circuits.
  • Loebner, E. E. Cold Cathode Glow Discharge Tubes in Digital Computers, RCA Engineer, Vol 3 No 2, 1957.
  • The Electronics of Selenium Rectifiers, M. R. Currie, Proceedings of the IRE, April 1947. For sourcing the bias supply.
  • The Computer History Museum’s collection on pre-transistor computing has working mag-amp components on display.
  • The Story of the SAGE Air Defense System, MITRE Corporation, 2005. Open-access PDF.

Comments, refutations, build photos, and corrections welcome. Especially refutations of the transformer winding counts — I haven’t prototyped this yet and the numbers may shift by 10-20% once a real build is on the bench.