John Sokol's Blog

There Are Far More Efficient Ways to Run Neural Networks

2026-06-02T21:46:15.293-07:00

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).

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

2026-06-02T07:26:21.716-07:00

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

Nixie-clock using neon lamps as logic elements

2026-06-02T01:52:36.406-07:00

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

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):

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:

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:

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:

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:

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.)

Laser cut , Snake Bot -

2026-06-01T20:35:38.673-07:00

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.

https://www.youtube.com/watch?v=9scTZW8f14I

https://www.youtube.com/watch?v=cNn-HVFAm0c

Movement

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

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

2026-05-30T01:02:00.873-07:00

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 bulbs — the 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:

Allow a single Selenium rectifier stack (pre-1948 technology, no silicon involved). Cost ~$15 from electronic surplus dealers, looks gorgeous, lasts forever.
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:

Gate	Mag-amp transformers	Neon bulbs
XOR(A, B) — 4 NANDs	4	4
XOR(prev, C_in) — 4 NANDs	4	4
AND(A, B)	1	1
AND(XOR_AB, C_in)	1	1
OR (carry parts)	1	1
Per full-adder cell	11	11

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

Item	Qty	Spec	Source	Cost
Ferrite toroid core	50	14 mm OD, FairRite 5961002701 or equivalent	Mouser, eBay	$0.80 each
Magnet wire	1 reel	32 AWG (0.2 mm), 500 ft	Digi-Key, Amazon	$30
NE-2 neon bulb	60	Generic indicator	Mouser, Amazon	$0.30 each
1/4 W resistors	100	Assorted values (1 kΩ to 1 MΩ)	Mouser kit	$20
Film capacitors	50	0.1 μF, 250 V	Mouser	$0.30 each
Toggle switches (DPDT)	12	Brass handle, panel-mount	Adafruit, eBay	$4 each
Wooden enclosure	1	30 × 20 × 8 cm hardwood	Local woodshop, scrap	$30
Brass faceplate	1	Laser-cut 20 × 30 cm	Online laser service	$25
Isolation transformer	1	100 VA, 1:1	eBay, surplus	$50
Step-down transformer	1	120:100 V, 100 VA	Surplus	$40
Selenium rectifier stack	1	Vintage, ~250 V at 50 mA	eBay	$15
Fuse holder + fuse	1	250 V, 250 mA slow-blow	Mouser	$5
Power inlet (IEC C14)	1	With switch and fuse	Mouser	$8
Hookup wire	50 ft	22 AWG stranded, multiple colors	Adafruit	$20
PCB	1	Two-layer, 200 × 250 mm	JLCPCB or OSHPark	$30

Total component cost: approximately $190.

Tools

Tool	What for	Cost if buying
Soldering iron	Through-hole assembly	Already have
Winding jig (DIY)	Holding the toroid while you wind	Build from scrap wood and a small hand-drill chuck
Multimeter	Voltage testing	Already have
Variac (variable autotransformer)	Bringing up the supply gradually during first power-on	Borrow from maker space, or do without
Oscilloscope	Watching gate waveforms during tuning	Borrow, or do without (visual inspection of bulb states works)
Hand drill	Wooden enclosure construction	Already have
Wood-finishing supplies	If you want the steampunk aesthetic	$30

Winding the transformers

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

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.
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.
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:

Build the supply section first. Verify clean ~100 V AC and ~120 V DC bias before installing anything downstream.
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.
Build the remaining three cells, reusing the tested topology.
Wire the ripple-carry path.
Wire the input toggles and output indicator bulbs.
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:

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.
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).
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.
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.
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.
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.

Building Neon Logic Gates: A Practical Maker’s Guide

2026-05-29T23:33:36.963-07:00

Building Neon Logic Gates: A Practical Maker’s Guide

Companion to the pneumatic computer essay. This one is the how-to. If the pneumatic post asked “could a kid watch a computer think?”, this one is the answer for adults willing to handle a few hundred volts. The result: a clear-glass-and-acrylic stack with orange glowing cells that act as 1-bit memory, wired through a PCB underneath into anything from a single visible bit to a four-bit counter. Aesthetic of 1950s computer; build cost of a long weekend.

⚠️ This project uses 150–180 V DC at low current. It’s not as dangerous as mains AC at the same voltage, but it can hurt you and in unusual circumstances kill you. Section 11 covers what you need to do to keep it safe. Read it before you build anything. If you are not already comfortable building HV circuits with current limiting and bleeder resistors, build the all-acrylic pneumatic version instead — it’s the same pedagogy and you can’t electrocute yourself with air.

1. What you’re building

A single cell is a small glass-and-acrylic sandwich about the size of a postage stamp, holding 5-15 torr of neon, with two or three metal electrodes passing through the glass into the chamber. Apply ~90 V across the main electrodes, pulse a third “trigger” electrode, and the gas ignites into a visible orange glow. The cell stays lit until you drop the supply voltage below the sustaining threshold of ~65 V. One cell is a 1-bit memory you can see.

A row of eight cells, mounted on a PCB that handles the supply routing and the trigger pulses, is a visible 8-bit register. You load a number into it by sequentially pulsing the trigger inputs. You read the number off the front by which cells are glowing.

A few rows of cells wired with appropriate cross-couplings is a visible counter or, with more care, a visible adder. The final device is a small wooden-and-glass box about the size of a hardcover book, sitting on a table at the front of a classroom or maker space, glowing softly orange while it counts.

The whole thing runs on a wall transformer, draws under 10 watts, and sits silently. Compared to the pneumatic version: no moving parts, no compressor noise, faster operation (milliseconds per bit, not half-seconds), and the aesthetic is straight out of 2001.

2. How the cell works, in 500 words

Low-pressure neon has a useful property called the Townsend breakdown that makes it behave as a natural bistable element.

Below a critical voltage (the ignition voltage, typically 80-100 V for a 5-10 mm electrode gap at 5-15 torr neon), the gas in the chamber is electrically neutral and effectively an insulator. No current flows. The chamber is dark.

Above the ignition voltage, an avalanche of ionisation starts: a stray free electron is accelerated, collides with a neon atom, liberates more electrons and ions, and the cascade runs away until the chamber is full of plasma. Current flows freely. The chamber glows orange (specifically at 585.2, 614.3, and 640.2 nm — the strong visible neon lines).

Critically, once ignited, the voltage required to sustain the discharge is much lower than the ignition voltage — typically 60-70 V. The cell exhibits hysteresis: it stays lit until the supply voltage drops below the sustaining threshold, at which point the plasma deionises and the cell goes dark.

This hysteresis is what makes the cell a 1-bit memory. Sit the supply voltage at ~75 V — between ignition and sustain — and the cell is stable in either state. If you push the supply momentarily above 90 V (or, equivalently, momentarily lower the effective ignition threshold by injecting electrons via a third electrode), the cell ignites and stays lit at 75 V. If you push the supply momentarily below 60 V, the cell goes dark and stays dark at 75 V. The cell remembers.

The third electrode — the trigger — is the practical knob you control. A small voltage pulse on the trigger (typically 20-30 V on top of the cathode reference) creates a small auxiliary discharge that seeds the main chamber with enough ions to lower the ignition threshold below the running supply voltage. The main discharge fires. After the trigger pulse ends, the main discharge sustains itself.

The whole cycle is fast: ignition takes microseconds, sustained operation is steady, and extinction (when you drop the supply) takes hundreds of microseconds while the plasma recombines.

For logic, the trigger structure gives you natural building blocks:

Bit storage — one cell with a single trigger is a 1-bit memory.
OR gate — two triggers on the same cell, either one fires it.
Set-Reset latch — one cell for the set, one for the reset, cross-coupled supply lines.
Sequential logic — multiple cells wired to fire in sequence via shared trigger lines and capacitive coupling.

Combinational AND/XOR are awkward in pure neon logic and were historically done with diodes in front of the trigger inputs. You’ll do the same.

3. Bill of materials

For a build that produces one working cell plus the supply infrastructure to drive it, expect to spend about $400-500 in materials and $200-400 in tools (most of which you can borrow or already have).

Materials for one cell

Item	Spec	Source	Cost
Cast acrylic sheet	3 mm clear	Local plastics supplier, TAP Plastics, Home Depot	$5/sheet (12×12”)
Float glass	3 mm clear, ≥4×4”	Glass shop scraps, eBay, hobby store	$3/piece
Stainless steel pin stock	1 mm dia × 50 mm	McMaster 90145A115	$0.50/pin (need 3)
Buna-N O-ring sheet	1.5 mm thick	McMaster 8634K12	$25/sheet (enough for 50 cells)
Torr Seal epoxy	Two-part	Edwards Vacuum, Kurt J. Lesker	$45/kit
Apiezon Q wax	Vacuum sealing	Kurt J. Lesker, eBay	$25/stick

Gas-handling and electrical infrastructure

Item	Spec	Source	Cost
Single-stage rotary vane pump	≥10 L/min, can hit 10⁻² torr	eBay used (Edwards E2M5, Welch 1400)	$150-300
Neon lecture bottle	99.99%, 1.7 L at 1700 psi	Praxair, Airgas, AGSI	$80-120
Pressure regulator for neon	Dual-stage, 0-30 psi outlet	Praxair, eBay	$80 used
Pirani gauge + readout	Range 10⁻³ to 10² torr	eBay used (Granville-Phillips 275)	$80
Vacuum tubing	6 mm OD nylon or 1/4” copper	Hardware store	$30
Compression fittings	1/4” Swagelok-compatible	McMaster, eBay	$40
Needle valve	1/4” Swagelok	McMaster 4901K23	$35
HV DC supply	0-250 V adjustable, 50 mA, with current limit	XP Power AHV28-P50 or build from voltage doubler	$80 module, $30 DIY
HV trigger pulse driver	One MOSFET HV pulse generator per cell	DIY from CD4093 + IRF830	$5/cell
HV current-limit resistors	100 kΩ, 5 W wirewound	Mouser, Digi-Key	$3 each
Bleeder resistor	470 kΩ, 5 W	Mouser	$2
FR-4 PCB	Custom, two-layer	JLCPCB, OSHPark	$5 for 10 boards

Tools

Tool	What for	Cost if buying
CO₂ laser cutter, ≥40 W	Cutting acrylic and gaskets	Hacker space access
Drill press + 1 mm + 3 mm bits	Through-holes in glass for electrode pass-throughs	Hacker space access
Glass-drilling diamond bits	If drilling glass yourself	$20 set
Toaster oven	Bakeout at 60-70 °C	$40
Small vacuum desiccator or bell jar	Bakeout chamber	$50 used
Multimeter that handles 250 V DC	Voltage testing	Already have
100 MΩ HV probe (or 10:1 divider)	Measuring supply voltage on a meter	$40
Soldering iron, basic electronics tools	Wiring	Already have

The biggest single-item cost is the rotary vane pump. You can avoid the pump entirely by going to a vintage TIG-welder distributor and asking for a used pump from a refrigeration shop — they’re $50-100 and work fine for this pressure range. Or borrow from a university physics lab.

4. Designing the cell

The cell geometry is constrained by three things:

Paschen’s law sets the relationship between pressure, electrode gap, and ignition voltage. At ~10 torr neon, the ignition voltage minimum is around 80 V at a gap of ~5 mm. Smaller or larger gaps raise the ignition voltage.
Visibility wants the glow region as large as possible, so a bigger chamber is better aesthetically.
Power dissipation wants the chamber small. At 75 V sustained and 2 mA, each cell dissipates 150 mW continuously. A four-bit register with all bits lit dissipates 0.6 W, plus another ~10 W in the HV supply and current-limit resistors.

The cell I recommend for a first build:

Chamber size: 15 mm × 15 mm × 2 mm deep
Electrode gap: main electrodes 8 mm apart, both 1 mm pins
Trigger electrode: 1 mm pin, located 3 mm from the cathode and 3 mm offset from the main discharge axis
Glass plates: 25 mm × 25 mm × 3 mm
Acrylic spacer: 25 mm × 25 mm × 2 mm, with the chamber cut out and a 1 mm wide × 1 mm deep O-ring groove cut around the chamber perimeter

At ~10 torr neon, this geometry gives an ignition voltage around 90 V and sustains at 65 V. The glow fills the chamber visibly — bright enough to read by in a darkened room, soft enough that you don’t need to dim the room lights to see it.

For the laser cutter, draw the acrylic spacer as a single 25 mm square with:

A 15 mm × 15 mm cutout for the chamber
A continuous 1 mm × 1 mm groove around the chamber for the O-ring
Three 1.5 mm holes for the electrode pins (slightly oversized to allow alignment slop)

Cut at standard acrylic settings (50% power, 30 mm/s on a 60 W laser). The O-ring groove is cut as a separate engrave step at 20% power, single pass — this gives you a slot the O-ring can sit in.

5. Bakeout

This is the step you do before assembly. The purpose is to drive adsorbed water and volatiles out of the acrylic so the cell holds its gas composition for weeks instead of hours.

Procedure:

Cut all your acrylic pieces fresh — don’t bake them, cut them, then leave them in air. The fresh-cut surface re-adsorbs water within minutes. Cut just before bakeout.
Place the pieces in a small vacuum desiccator inside a toaster oven.
Connect the desiccator to the rotary pump via a vacuum hose.
Turn on the pump first. Let it pump down to <0.1 torr. Then turn on the toaster oven and set it to 60-65 °C. Do not exceed 70 °C — cast acrylic softens above this temperature and your O-ring grooves will distort.
Let it bake at temperature under continuous pumping for 48 hours minimum, 72 hours preferred. The outgassing rate drops by about a factor of ten every 24 hours during this period.
Cool to room temperature under vacuum. Vent the desiccator with dry nitrogen or filtered argon slowly — fast venting can re-deposit moisture from any condensation on cold surfaces.
Use the parts within a few hours of bakeout. Don’t leave them in open air overnight before assembly.

A small humidity-indicator card inside the desiccator is a useful sanity check: it should remain blue throughout the bakeout.

The same bakeout applies to the O-ring sheet (if it’s Buna-N — Viton is fine without bakeout) and to anything else organic that will be inside the sealed volume.

6. Assembly

You’ll need: baked acrylic spacer, two pieces of glass, three stainless pins, O-ring stock, Torr Seal, and a small flat surface clean enough to work on.

Drill the glass. The bottom glass piece needs three 1.5 mm holes for the electrode pins, located to match the spacer’s pin holes. Use a diamond bit at low RPM with water cooling. Take your time; cracked glass is the most common assembly failure.
Cut the O-ring. Cut a length of Buna-N stock to fit the groove in the acrylic spacer. Join the ends with a single drop of cyanoacrylate (super glue) to form a closed loop. The O-ring should sit slightly proud of the groove surface when placed in.
Set the electrodes. Push the three 1 mm stainless pins through the holes in the bottom glass, leaving about 3 mm protruding into what will be the chamber and about 10 mm protruding below for external connection. Seal each pin to the glass with a small dab of Torr Seal mixed per the package instructions. Cure 24 hours. This is your single hardest seal — take care.
Build the stack. - Bottom glass (with pins) face up - Acrylic spacer (with O-ring in groove) - Top glass - Sandwich the whole thing between two metal plates (aluminum is fine) with nylon bolts at the four corners. - Tighten the bolts evenly until the O-ring is compressed to about 50% of its uncompressed thickness. Do not over-tighten — you’ll crack the glass.
Mount the gas connection. The top glass needs one more small hole, off to the side of the chamber, where the gas-fill tube enters. Pre-glue a short length of 3 mm OD glass or metal tubing into this hole with Torr Seal before final assembly. The tube extends ~10 mm above the top glass for connection to the gas manifold.
Check the seal. Connect the cell’s fill tube via flexible tubing to the rotary pump. Pump down. Watch the Pirani gauge — it should read down to ~10⁻² torr within a minute or two. If it plateaus at higher pressure, you have a leak. The leak is almost always at one of the electrode pins or at the O-ring (which means it wasn’t compressed evenly).
Fill with neon. Once the cell pumps down cleanly, close the pump valve, open the neon supply via the needle valve, and let the cell pressure rise to 10 torr. Close the needle valve. Disconnect from the gas manifold by pinching off the fill tube with a small metal clamp (the tube can be permanently sealed later by heating and crimping, or by gluing the clamp on).

Total assembly time per cell: ~3 hours including epoxy cure (which you do overnight). With practice you can build five cells in parallel in roughly the same time.

7. The HV supply

You need a DC supply that delivers 0-180 V at up to 50 mA, with current limit and a bleeder resistor.

The cheap path: a 0-30 V variable DC bench supply driving a 6:1 voltage doubler made from off-the-shelf parts. Two 1 µF/400 V electrolytic capacitors, two 1N4007 diodes, configured as a Cockcroft- Walton ladder. Input 24 V AC (from a small line transformer), output ~150 V DC. Add a 100 kΩ series resistor for current limit and a 470 kΩ bleeder across the output.

The cleaner path: buy an XP Power AHV series module or equivalent. They cost ~$80 and give you a clean 0-250 V variable output with built-in current limit.

Either way, always include the bleeder resistor. When you turn the supply off, the capacitors retain charge for many minutes otherwise. The bleeder drains them within 10 seconds.

For the trigger circuit, you need a 30 V pulse, ~10 ms duration, floating reference, into the trigger electrode. Easiest implementation: a CD4093 Schmitt-trigger NAND gate driving an IRF830 MOSFET that switches a small 30 V supply onto the trigger pin via a 10 kΩ resistor. The MOSFET is rated for 500 V, so even if the cell shorts to its trigger you don’t kill the driver. One driver per trigger input.

Lay all of this out on a single board underneath the cell array. Through-hole construction, generous spacing between high-voltage traces (≥3 mm), and a clear silkscreen showing which traces are at which voltage. Mount the supply on the underside of the wooden case, behind a barrier so nobody’s fingers can reach the live nodes.

8. First light

You’ve built one cell. You’ve built the supply. Time to make it glow.

Confirm the cell has the right gas pressure with the Pirani gauge.
Connect the cathode pin to the supply ground via a 1 kΩ resistor (this provides a small reference and limits any transient).
Connect the anode pin to the supply positive via a 100 kΩ series resistor.
Bring the supply up slowly from 0 V. Watch the cell.
At around 85-95 V, the cell will spontaneously ignite — a sudden orange glow filling the chamber. The supply current will jump to 1-2 mA.
Lower the supply slowly. The cell will continue glowing down to about 60-65 V, then suddenly extinguish.
Note both voltages. These are your cell’s actual ignition and sustaining voltages. They’ll vary a few volts cell-to-cell.

If it doesn’t ignite by 100 V: the gas pressure is too low or too high (Paschen curve has a minimum), or the gap is too small. If the pressure is way off, vent the cell and refill more carefully.

If it ignites way below 80 V: the gas is contaminated with moisture or air (so you have a higher proportion of nitrogen, which ionises more easily). Pump and refill.

If the glow is white/pink instead of orange: definitely contamination, probably nitrogen from a leak. Pump down, refill.

If it ignites but flickers: could be a leak (slow contamination changing breakdown voltage), or could be supply ripple. Add a 1 µF cap across the supply output.

Once you have stable orange glow with reproducible ignition/sustain voltages, set the supply at the midpoint (typically ~75 V) and verify the cell sits stable in either lit or dark state for at least 60 seconds. That’s your working bistable.

9. Triggering for memory operation

With the supply at 75 V (between ignition and sustain), you want to flip the cell between lit and dark with pulses.

To set (light up): pulse the trigger electrode to +30 V relative to the cathode for ~10 ms. The trigger creates a small auxiliary discharge in the chamber that locally lowers the ionisation threshold for the main gap. The main discharge fires. After the trigger pulse ends, the main discharge sustains itself.

To reset (extinguish): pulse the supply briefly below the sustaining voltage. The simplest way is to put a small MOSFET in series with the supply line that briefly drops it (a “kill switch”) for ~1 ms. The plasma deionises and the cell goes dark.

With the set and reset capabilities wired to two pushbuttons on the front panel, you have a manually-operated 1-bit memory you can flick on and off and watch. It’s already a satisfying object at this point. Put it on a shelf for a day and look at it from time to time. Verify it holds state for hours without drifting (it should).

10. Building out to a register

For an 8-bit register, you build 8 cells side-by-side on one PCB and wire them with shared supply, shared reset bus (kills all bits simultaneously when you want to clear), and individual trigger inputs (one per bit).

The PCB layout puts the cells in a 1×8 row, 30 mm apart, with the HV supply rail running along the top edge and the cathode-ground rail along the bottom. Each cell’s anode connects to the HV supply via a shared current-limit resistor (or, more conservatively, individual resistors so a failed cell doesn’t take out the supply).

Mount the trigger pulse drivers on the underside of the same PCB, one per cell. Bring the trigger inputs out to a header connector on the back. Drive them from a microcontroller — an Arduino Nano works fine — that sequences the trigger pulses according to whatever pattern you want to load.

An 8-bit binary counter is the simplest demonstration: the Arduino counts internally and on each tick re-loads the register with the new value, displayed as glowing bits. Counts up from 0 to 255 over four minutes if you tick once per second. Watching the bits propagate is the entire point.

A visible adder is more elaborate. You build two 4-bit input registers, the adder logic (NAND gates in solid-state, not in the neon — the neon is for the visible state), and a 4-bit output register. Set the inputs by flipping switches that pulse the trigger inputs. Press a “compute” button. The adder logic computes A+B and triggers the appropriate output bits. The output register shows the sum.

The neon cells are the display + state memory. The combinational logic in between is solid-state. This is exactly how the Harwell WITCH (1949) worked: dekatrons for storage and visible display, relays for the actual logic. You’re recreating that architecture at maker scale.

11. Safety

The non-negotiable rules.

Bleeder resistors on every capacitor in the supply. A 470 kΩ / 5 W resistor across the main output capacitor drains it to <30 V within 10 seconds of power-off. Without it, the supply caps can hold a hazardous charge for 30+ minutes.
Current limiting on every cell. The supply itself should have a hard current limit at ~50 mA. Each cell should also have a series resistor (100 kΩ or higher) so that even if a cell shorts, the steady-state current is limited to <2 mA.
Live conductors behind glass or behind a barrier. Nothing conductive at >40 V should be touchable from the outside. The front of the device is glass over the cells. The back of the device is a wooden panel or a perforated metal cover with the high-voltage routing inside.
One-handed operation rule. When the device is powered on, keep one hand in your pocket. If you must touch anything, only do so with one hand. This prevents current paths through your chest.
Verify dead before touching. Before working on the powered-off device, measure the supply rail with a multimeter to confirm <10 V. The bleeder resistor should make this automatic but verify.
Mains isolation. The HV supply should be galvanically isolated from the mains via a line-frequency transformer or an off-the-shelf isolated module. Don’t use a mains-rectified supply without isolation.
Plug-in warning label. A small label on the back of the device saying “180 V DC inside. Service by qualified personnel only. Allow 30 seconds after disconnect before opening.” Yes, the bleeders drain it in 10 seconds; the label says 30 to be conservative.
No kids inside. Children can interact with the front of the device — toggles, pushbuttons, watching the glow. They should never have access to the back. This means either screwed-shut panels (not snap-on covers a curious 8-year-old can pop off) or a key-locked back panel.

At 150-180 V DC with ~50 mA current limit, this device is in the “will hurt, very unlikely to kill” range for a healthy adult under dry conditions. With the safeguards above it’s roughly as dangerous as the inside of an open CRT TV from the 1990s, which is to say: respect it, but don’t be paralysed by it.

If your maker space’s safety policy has a hard cap at “low voltage DC only,” this project is over that line and you need to talk to your space’s leadership before starting.

12. Troubleshooting

Cell ignites at the wrong voltage. Almost always gas pressure or gas purity. Pump down to <10⁻² torr (verify with the Pirani gauge), hold for 10 minutes to let outgassing equilibrate, refill with fresh neon. If pressure is the problem, you’re hitting the wrong part of the Paschen curve — go up or down 5 torr and re-test.

Cell ignites OK initially but extinguishes after a few seconds. Current limit is too aggressive. Drop the series resistor from 100 kΩ to 50 kΩ.

Cell ignites and won’t extinguish. Current limit is too loose, or the supply voltage is too high. The sustaining voltage is fundamental to the cell — if your supply is above it, the cell stays lit. Drop the supply 10 V.

Glow is purple/pink instead of orange. Air leak. Nitrogen contamination glows pink. Find the leak by squirting isopropyl alcohol on suspect seams while pumping — IPA’s vapour pressure changes the Pirani reading at the leak point.

Glow is bright orange but flickers. Supply ripple. Add filtering caps to the supply (1 µF / 400 V across the output, plus a small 100 nF ceramic for high-frequency noise).

Glow is dim and uneven. Either pressure is too high (most likely) or the chamber is too deep relative to the electrode gap. Re-pump and re-fill at lower pressure (try 5 torr).

Trigger doesn’t fire the cell reliably. Trigger pulse amplitude too low or duration too short. Increase to 50 V / 50 ms and retest. If still unreliable, the trigger electrode is too far from the main discharge path — re-make the cell with the trigger closer to the cathode (within 3 mm).

Cells holding state become unreliable after a few weeks. Outgassing. Re-pump and refill. If happening within days, you have a slow leak — find it via the IPA technique.

13. Going further

Things you can build on top of the basic cell:

A multi-decade counter. Use commercial dekatrons (eBay) as the counter elements; use your custom cells as the visible “active” bit indicator showing which decade is at non-zero. A 4-decade counter counts to 9999, fits in a hardcover-book-sized case, and runs indefinitely from a wall transformer.

A self-clocking ring oscillator. Two cross-coupled cells with an RC delay between them will oscillate at a frequency set by the RC time constant. Build a chain of these as a visible clock generator, each cell flashing in turn at a rate the kid can see.

A visible shift register. N cells in a row, with each cell’s trigger connected to the previous cell’s anode via a capacitor. A pulse on the first trigger propagates down the register at a rate set by the capacitor values. Watch a single lit bit walk down the row.

A pneumatic-and-neon hybrid. Connect the output of the pneumatic adder to the trigger inputs of an 8-bit neon register. The mechanical computer feeds its answer into the visible electronic display. Two substrates, one demonstration. Worth the extra weekend.

A teaching kit. Once you have a stable cell design, document it as a kit and put it on Tindie or Crowd Supply. The market is small but loyal — Nixie-tube clock builders are a real subculture and they will find this and love it. Open-source the PCB and laser-cut files on GitHub; build a small business selling the consumables (electrodes, gas cylinders, O-ring stock).

Coda

The neon logic gate is one of the few projects where the way the device looks while operating is also exactly how it operates. A transistor is just a black SOIC package and you have to take the datasheet’s word for it. A neon cell is a chamber where you can literally see the plasma. The pedagogy and the aesthetic are the same thing.

The 1950s knew this. The Harwell WITCH, on display now at the National Museum of Computing at Bletchley Park, has been running since 1951 and is still pulled out for demonstrations. Visitors don’t remember the relays; they remember the dekatrons, glowing as they count.

What you’ll build is in that lineage. Smaller, simpler, less ambitious, but the same idea. Computation you can see.

If you build one, send me a photo.

A Computer Children Can See: A Clear-Plastic Pneumatic Adder

2026-05-29T23:14:46.799-07:00

A Computer Children Can See: A Clear-Plastic Pneumatic Adder

This essay is the follow-through on a one-line note I wrote to myself on the front page of my wiki in October 2019 and never came back to. The note said: “Build laser cut Pneumatic computer. Slide valves, and other air flow in layers laser cut materials. Can I build an Adder? Latches, flip flops?” The answer to all three questions is yes, and the result would be a small clear-plastic box, illuminated from below, that adds numbers slowly enough for a child to watch each bit propagate. This essay is the design.

The Hacker Dojo had a laser cutter. So did half the maker spaces I’ve ever joined. The laser cutter sits in the corner, somebody pays the power bill, and every couple of weeks one of the members loses an afternoon to “what should I build with the laser cutter that justifies the membership fee.” The output of that question is mostly small boxes, lamp shades, jigsaw puzzles, and signs.

The 2019 note was the answer to that question, on one particular afternoon. I wanted to build something that a kid could look at and understand. Something where computation, normally hidden inside silicon at gigahertz speeds invisible to anyone, would be slow enough and visible enough that a child could point at a part of it and say “that bit is on right now and now it’s off and look the next one is turning on.” I wanted addition to be a thing you could watch happen.

The mechanism I had in mind was pneumatic. Air through channels carved into stacked sheets of clear acrylic. Slide valves visible from above through the top sheet. Each output bit indicated by a little ball floating in a column — high when the bit was 1, low when it was 0. A 4-bit input set by toggling four little plastic switches; the result of input + 1 (or input + input, depending on the wiring) appearing on four output columns about a second later, the carry rippling visibly from low bit to high bit on the way.

That was the idea. I never built it. This essay is what it would take, why the parts work the way they do, and a plan a maker space could actually follow.

1. Why a visible computer matters

A kid born in 2026 will grow up surrounded by computation, none of which is visible. The phone is a slab. The laptop is a slab. The hearing aid, the doorbell, the elevator, the car, the toaster — all slabs, all opaque. Computers are not, to a modern child, things that do anything visible. They’re things that show things on screens about what they’ve already done.

I think this is bad for intuitions. Computation isn’t magic. It’s a sequence of small mechanical decisions: this bit, then this bit, then this bit, with logic governing each step. When the decisions happen at a billion times per second inside a slab, you cannot watch them, and the abstraction layer between “I press a key” and “a character appears” feels like sorcery.

But computation runs at any speed you build it for. If you slow it down to one decision per second, in a medium you can see, kids understand it. I have watched this happen with Lego Mindstorms, with the Phillips Hydraulic Computer demos at LSE, with the Antikythera replicas at the museum in Athens, with the Z3 reconstruction at the Deutsches Museum. The reaction is the same: when a child can see a machine deciding things, they get it. The mystery evaporates. They don’t think it’s stupid; they think it’s cool. The slowness is the feature.

A pneumatic computer in clear acrylic is the maker-space version of that pedagogy. You can build one with a $5,000 laser cutter and $300 worth of materials, in maybe four weekends, and afterwards it sits in the front of a classroom or the kids’ room of a maker space and does one job, well, forever: it adds numbers slowly enough that you can see it think.

2. The 2019 note in context

I scribbled the note down because I had three things converging at once.

I had a laser cutter handy. Laser cutters do one thing brilliantly: they cut precise 2D shapes out of flat material. Stacking those 2D shapes turns them into 3D channels for whatever fluid you want to push through. The features can be small (well under a millimetre), the materials are cheap (acrylic at a few dollars a sheet), and the cycle from “design change” to “new test piece” is an afternoon.

I had been reading old computing history. The Phillips Hydraulic Computer (1949, LSE) modelled the UK economy with water flowing through transparent perspex tanks. Konrad Zuse’s relay computers clicked their way through addition in the 1940s. There was a whole era when computers were visibly mechanical things, and the abstractions we now take for granted — bit, register, gate — were literally pieces of metal you could touch.

And I had been thinking about kids. Specifically, about how kids encounter the word “computer” before they have any model of what one does, and how the gap between “computer” the magical box and “computation” the precise mechanical sequence is one of the worst educational gaps in modern STEM. Whatever closes that gap is a public good.

The note was the intersection. Laser cutter plus old fluidic-logic history plus pedagogy of visible computation equals: clear-plastic adder. Six years later I still think it’s the right answer.

3. Fluidic logic is a real thing, and it used to be a serious field

The thing I half-knew in 2019 and fully understood by writing this essay: people built actual working computers out of air in the 1960s. Not toys. Not demos. Industrially-supported, multi-thousand-gate, production hardware.

The seed event is Raymond “Billy” Horton’s 1960 fluidic amplifier, developed at the U.S. Army’s Harry Diamond Laboratories in Washington, D.C. Horton showed that a small jet of air, deflected by the Coanda effect, could behave as a bistable element — a flip-flop with no moving parts. The paper landed in Control Engineering and the field exploded. Within five years there were dedicated conferences, commercial fabrication houses (Bowles Engineering being the biggest), multiple competing gate geometries, and Air Force programs funding the development of entirely-fluidic computers as candidates for high-radiation, high-vibration, high-EMP environments where electronics couldn’t survive.

The flagship build was Norden Systems’ MOD-A, around 1966 — a general-purpose digital computer made entirely of air channels. It worked. It was slow (kilohertz, not gigahertz) and big (room-sized, not chip-sized) but it computed, in the same way a contemporary electronic mainframe computed, with no electrical components anywhere.

Then ICs got cheaper. By 1975 a TTL flip-flop cost a few cents; a fluidic flip-flop cost a few dollars and was a thousand times slower. The economics collapsed. The Air Force funding dried up. Bowles Engineering eventually went under. The conferences shrank. “Fluidic logic” became a forgotten word.

There was a quiet survival in two specialist domains: gas-turbine controllers (where the working fluid is already there) and high-rad environments. But the general-purpose fluidic-logic research programme died on schedule, around the time of the first 8-bit microprocessor.

What brought it back, decades later, is soft robotics. Around 2015 George Whitesides’s group at Harvard demonstrated soft robots whose control logic was implemented in pneumatic gates inside the robot’s own body — no electronics, no batteries, just compressed air driving a small fluidic computer that decided how the robot would move. Daniel Preston’s group at Rice and Rob Wood’s group at Harvard extended this. The application is robots that can operate inside the body during surgery, or in vibration-sensitive environments, or untethered in places where batteries fail. It’s a real and active field again.

For a kids’-education pneumatic computer, none of those advanced techniques matter. The 1960s-vintage slide valves, scaled up to human-visible size and cut from clear acrylic, are exactly the right choice.

4. How a fluidic gate works, mechanically

There are two families of fluidic gates and you choose based on what matters to you.

The Coanda-effect gate has no moving parts. You shape a chamber so a jet of air naturally attaches to one of two walls. A small sideways control jet can detach it and shove it to the other wall, where it stays. Output flips. It’s elegant, it’s fast, and it’s fussy: the chamber geometry has to be right to a few percent, the pressures have to be tuned, and watching it work requires a smoke generator because the air is invisible.

The slide-valve gate uses a small moving piece — a spool, a piston, a membrane — that physically shifts position when pressure changes on one side versus the other. The spool either connects or disconnects two channels, depending on which way it’s sitting. It’s slower, mechanically more visible, and much easier to design and debug because the logic is literally the visible mechanics. You can watch the spool move.

For a clear-acrylic kids’ build, the slide-valve approach is the obviously right one. The bits are moving things. You can see them. A flip-flop is two small pieces of plastic, one in each “remembered” position. A NAND gate is a piece of plastic that slides one way when both inputs are pressurised and another way when either isn’t. The mechanism is the lesson.

For the indicators on the output, I’d use little vertical glass or clear-plastic tubes with a coloured ball inside. When the bit is 1, air pressure lifts the ball to the top of the tube. When the bit is 0, the ball sits at the bottom. The output is four (or eight) coloured balls arranged in a row, and the result of the addition is a binary number you read by which balls are up. With a small reference card (“0001 = 1, 0010 = 2, …”), a kid translates the binary into a decimal answer in their head. That little act of decoding is itself pedagogy — they’re decoding binary, which is what the machine is.

5. Laser-cut layered construction

This is the practical move that makes the project achievable at hobby gauge.

A fluidic gate is mostly geometry. The interesting features are channels and chambers, both two-dimensional in cross-section. You can fabricate a complete gate by:

Designing the layout as a stack of 2D layers in Inkscape, Solvespace, or Onshape. Each layer is one slice through the device. Some layers are channel layers (with the channels cut out). Some are cover layers (with just port holes). Some are spacer layers.
Cutting each layer out of clear acrylic on the laser cutter. A 3 mm cast-acrylic sheet cuts in about 30 mm/s at 60 W. A layer with a couple of dozen gate features cuts in 20-30 seconds.
Stacking the layers in order, with a thin film of acrylic solvent (dichloromethane, a.k.a. “weld-on”) between them.
Pressing the stack under weight overnight while the solvent chemically welds the layers into a single block.
Drilling input/output ports through the top sheet and attaching pneumatic tubing with barbed fittings.

Channel features down to about 100 μm are routine on a hobby laser cutter. With care and a focused beam you can hit 25 μm. Hobby fluidic gates work fine at channel widths of 0.5 to 2 mm — luxuriously large, high yield on the first cut.

The aesthetic bonus is that the finished stack is transparent. You can see every channel, every chamber, every slide valve. A small LED panel underneath illuminates the whole device from below, and the channels glow when air flows through them (more so if you fog the air with a trace of theatrical haze, but even dry air shows up because of the slight density difference between fast-moving and still air). The thing looks like a piece of glass with a circuit diagram trapped inside it, and the circuit moves.

6. Can you build an adder?

This was the empirical question the 2019 note ended on. The answer is yes, and walking through it is the way to see whether the project is actually feasible at the home-laser-cutter gauge.

NAND is universal. If you have a NAND gate you can build any digital logic. So we’ll build a NAND and then use it everywhere.

A NAND gate in slide-valve fluidics is, mechanically, two small spools in series with a pull-up channel from the air supply. Default state: output is pressurised (= 1) because the pull-up channel feeds it. When both inputs are pressurised, both spools shift to a position that opens a vent path from the output to atmosphere, so the output goes to 0. When either input is at atmospheric pressure, its spool stays in the default position, keeping the vent closed, so the output stays at 1. Standard NAND truth table:

A	B	NAND(A,B)
0	0	1
0	1	1
1	0	1
1	1	0

About 2 cm × 1 cm of acrylic real estate per gate, four ports, two moving spools.

A half-adder from NANDs is two outputs: SUM = A XOR B and CARRY = A AND B. Built entirely from NAND gates that’s 5-6 gates total if you share the inner subexpression, 8 if you don’t.

A full adder is two half-adders plus an OR gate (for the carry-out), and OR is three NANDs. Total: about 12-15 NAND gates per bit of addition.

A 4-bit ripple-carry adder is four full adders chained, so about 50-60 NAND gates total.

At 2 cm × 1 cm per gate plus some routing space, the whole adder fits comfortably on a piece of acrylic about 20 cm × 30 cm. That’s the size of a typical laser-cutter bed. Six or eight 3 mm sheets stacked = about 25 mm thick. The whole device is the size of a hardcover book.

Speed: about half a second per addition. Slide-valve fluidics at hobby scale switches in 10-50 ms per gate, and the carry has to ripple through four full adders, so end-to-end maybe 200-500 ms. The kid can watch the result settle. The slowness is the entire point.

Latches and flip-flops are similar: an SR latch is two cross-coupled NAND gates (so 4 spools), a D flip-flop is a few more. With latches you can build registers, and with registers you could build a small accumulator that adds successive inputs over time. The 4-bit incrementer (counts up by 1 each time you push a button) is the right starting point: simpler than a general adder and just as educational.

7. The educational design

This is where the kid-pedagogy details matter, and where the project goes from “interesting maker project” to “actually-pedagogical artifact.”

Big inputs. Four big plastic toggle switches across the front, labeled bit 0 through bit 3. The kid sets the input by physically clicking them up and down. Tactile, deliberate, the input is a thing they did.

Big indicator balls. Four (or eight, if you want to show input and output) tall clear tubes across the top of the device, with brightly-coloured ping-pong-ball-sized indicators inside. High = 1, low = 0. The kid sees four balls do their thing every time.

A small reference card. “0000 = 0. 0001 = 1. 0010 = 2…” laminated and Velcro’d to the side of the device. The kid translates the binary output into a decimal answer. The reference card is part of the learning.

Visible carry. The wiring between full-adder cells should be visibly distinct — different channel colour, brighter LED behind it, something — so that when the carry ripples from bit 0 to bit 1 to bit 2 to bit 3 over the course of half a second, the kid can see the ripple happening. The carry is the thing that makes addition interesting (it’s why 9 + 1 = 10, why kids learn carrying in second grade), and being able to point at the carry physically moving through the machine is the moment the pedagogy lands.

A reset button. Big, red, satisfying. Vents the entire device. The balls fall back to zero. The kid does it again.

No electronics anywhere visible. Yes, you might use a small microcontroller to drive solenoids on the input toggles (so the device can demo itself in a loop unattended), but the microcontroller lives inside the base, and from the kid’s perspective the whole computer is the transparent block. The point is that a thing made of nothing but air and plastic does math.

An information sign. A small placard near the device with a two-paragraph “what is this” — enough that a teacher or parent can read it and explain. The placard should say what NAND means, what addition in binary looks like, and that the entire computer in your phone is just an enormous and very fast version of this. The intellectual jump from “this slow plastic adder” to “the phone in your pocket” is the headline lesson.

8. Why this hasn’t been built much

A handful of YouTube videos and Hackaday articles exist of hobbyist fluidic-logic projects. The Hackaday piece by Jenny List from 2018 is a fair survey. Most of these build a single gate or a 1-bit demonstrator and stop. Almost nobody has built a working multi-gate fluidic adder at hobby scale and posted about it.

I think the reasons are:

The application case is invisible. If your goal is “build a computer,” then a fluidic computer is a thousand times slower than the microcontroller in your phone, and roughly nobody who knows enough to build the fluidic computer is unconvinced of the microcontroller’s superiority. The “what is it for” question kills most attempts.
The pedagogical case is right there but undersold. If you reframe the goal as “build a thing kids can understand,” the slowness becomes a feature and the application case becomes “in the corner of a classroom or a maker space, for years, doing one job well.” Nobody seems to have led with this framing in public.
It’s a real project. A weekend isn’t enough. Four to six weekends is realistic, plus a couple of iteration cycles where gates don’t quite work. The maker who decides to do it has to commit to seeing it through. Most maker projects are afternoons.
Pneumatic stuff is loud. A workshop compressor isn’t suited to a classroom. The fix is to drive the demo with a small quiet diaphragm pump or a battery-powered miniature compressor running intermittently. Whitesides Lab’s soft-robotics work has good examples here.

None of these are unfixable. They just need someone to take the pedagogical framing seriously and put in the four weekends.

9. The plan

Concrete enough to start tomorrow.

MVP: a 4-bit incrementer. Takes a 4-bit input (set by four toggles), outputs input+1 (on four balls). About 50 fluidic gates. Carry ripples visibly from low bit to high bit. Reset button vents the device. Half a second per operation. A small placard explains.

Materials:

6 sheets of clear cast acrylic, 3 mm thick, roughly 30 × 30 cm. About $50.
A roll of 0.5 mm latex sheet for slide-valve seals. About $10.
Dichloromethane acrylic cement. About $15.
Pneumatic tubing (4 mm OD) and a bag of barbed fittings. About $30.
A bag of clear plastic ping-pong balls and clear acrylic tubing for the output indicators. About $20.
A small quiet diaphragm pump or a 12 V mini-compressor with a tank. About $80.
An LED panel for backlighting. About $40.
A laser-cut wooden base to mount it all in. About $30.

Total: about $275 in materials.

Tools:

A 60 W or 80 W CO₂ laser cutter (Hacker Dojo, TechShop, your friend’s garage, the local fab lab).
Inkscape or Solvespace for the layout. Solvespace is better because the constraint solver lets you parameterise channel widths once and recut quickly.
A drill press for the input/output ports.
Generic workshop tools (clamps, sandpaper, isopropyl alcohol for cleaning between weld steps).

Build cycle:

Weekend 1: Design and cut a single NAND gate. Test it on the bench with a hand pump. Iterate the channel geometry once or twice until it switches cleanly. Document the working geometry as a reusable cell.
Weekend 2: Tile the NAND cell into a full-adder block. Six NAND gates wired into half-adder + half-adder + OR. Test all 8 input combinations. Time it.
Weekend 3: Lay out and cut the 4-bit incrementer — four full-adder cells in a row, plus the input toggle interface and the output indicator manifold. Assemble.
Weekend 4: Build the wooden mounting base. Wire the toggles to the inputs. Tune the pump pressure (probably 5-10 psi). Add the LED panel. Add the reset button. Photograph the whole thing in action. Write up the build guide and put it on GitHub.

Optional, weekend 5-6: Add a small Arduino in the base that can demo the device unattended — cycle through inputs 0 through 15 every ten seconds so visitors who walk by can watch it count.

Open-source the whole thing. Solvespace files, BOM, build guide, photos. The point is that the second one of these costs four weekends; the hundredth one costs an afternoon because somebody has done the laser-cut layout work already.

The end state is a transparent acrylic block on a wooden base, about the size of a hardcover book, sitting on a table at the front of a classroom or in the kids’ corner of a maker space. Coloured balls across the top. Toggle switches across the front. Reset button on the side. A small placard. A child walks up, flips a few toggles, watches the bits ripple across the device, reads the answer, smiles.

That is what I had in mind in 2019. The note didn’t say so explicitly because it was a note to myself, but that’s the project.

10. Why this is worth a weekend

I’m going to be direct. The world has plenty of educational kits for kids that purport to teach computation. Most of them are LEDs on breadboards driven by an Arduino, where the Arduino is a black box doing the actual work and the LEDs are decoration. The lesson the kid walks away with is “I plugged things in and they lit up.” That isn’t computation pedagogy. That’s plumbing.

A pneumatic adder is different. There is no Arduino doing the work in secret. The plastic block is the computer. Every bit visible. Every gate visible. Carry visibly rippling. The kid who watches it has, in some real sense, watched a computer add. They can take that mental model with them into every screen they ever look at afterwards, and the screen will be less mysterious.

That’s worth the weekend.

It’s also, by the way, a beautiful object. Multi-layer clear acrylic with channels carved into it, illuminated from below, coloured balls bobbing on top, makes for a striking display piece. The aesthetic case is not nothing. Maker spaces compete for foot traffic and the “oh, what’s that” reaction is real. A pneumatic computer in the front window gets people to walk in.

So this is the design. The cost is $275 and four weekends. The output is a transparent device that adds binary numbers in plain sight at half a second per operation. The audience is every kid who walks past it for the next five years.

I’m going to build it. If you have a laser cutter and four weekends of your own to spare, you should too.

The Weirdness of Water: A Field Guide

2026-05-29T18:34:11.964-07:00

The Weirdness of Water: A Field Guide

Water is the most-studied liquid in the world. We drink it, swim in it, weather forecasts hinge on its phase changes, and roughly two-thirds of the human body is made of it. And yet, walk into any condensed matter physics department in 2026 and you will find people still arguing about what it is.

Most liquids are boring in the sense that they obey the same handful of generalizations: they contract when they freeze, their density rises monotonically as you cool them, their heat capacity is some unremarkable multiple of the universal gas constant. Water obeys almost none of those generalizations. Martin Chaplin’s catalogue at London South Bank University lists at least seventy distinct anomalies. Some are textbook; some are still actively researched; a couple have been the focus of papers, patents, and entire pseudoscientific movements. This essay is a tour of the ones I keep returning to — first the textbook surprises, then the active frontiers, then the macroscopic phenomena that have engineering consequences, then water in space, in biology, and finally the famous controversies that the field has had to spend energy debunking.

Throughout, the same protagonist is doing the work: a small, bent, polar molecule with two electron lone pairs and the ability to donate and accept hydrogen bonds in every direction. Almost every weird property of water can be traced back to the hydrogen-bond network, which is simultaneously strong (about 20 kJ/mol per bond, an order of magnitude above van der Waals) and labile (rearranging on picosecond timescales). The combination produces a substance that behaves like a solid and a liquid at the same time, and one for which “solid” itself takes more than twenty distinct forms.

Part 1 — The textbook anomalies

Density maximum at 4 °C, and ice that floats

The single most famous water anomaly is so familiar that we forget it is strange: liquid water reaches its maximum density at 3.984 °C, not at the freezing point. Cool fresh water from room temperature and it gets denser until you hit roughly four degrees Celsius, after which it gets lighter. Continue past zero and it freezes into ice Ih (ordinary hexagonal ice), which is lighter again — about 917 kg/m³ versus the liquid’s ~1000 kg/m³.

Almost no other common substance does this. Most liquids contract on freezing because the molecules pack tighter into a crystal than they do in disordered motion. Water’s hydrogen-bond geometry insists on a tetrahedral arrangement around every oxygen atom, and the resulting open lattice of ice Ih is roughly 9% less dense than the liquid it came from. The biological consequence is that lakes and oceans freeze from the top down. Ice forms on the surface, insulates the liquid below, and life carries on at the bottom. A planet whose ice sank would freeze solid from the floor up the first time it got cold enough — and probably would not host fish.

Highest specific heat capacity of any common liquid

Water absorbs and releases heat very reluctantly. Its specific heat capacity is about 4.184 J/g·K — roughly twice that of olive oil, an order of magnitude above most metals, and the highest of any familiar liquid that is not chemically exotic (liquid ammonia and liquid hydrogen do better). The reason, once again, is the hydrogen-bond network: heat that would normally go into translational and rotational degrees of freedom in a simple liquid instead goes into librational modes and into making and breaking bonds.

This is why oceans buffer climate, why coastal cities have milder winters and cooler summers than inland ones at the same latitude, and why “heat content” rather than “surface temperature” is the right way to think about global warming. The world ocean has stored over 90% of the excess energy trapped by anthropogenic greenhouse gases, and we measure the difference in tenths of a degree across many cubic kilometres.

Surface tension high enough to walk on

At 20 °C water has a surface tension of about 72.8 mN/m, more than three times that of typical organic solvents. The same hydrogen-bond cohesion that makes water reluctant to heat up makes its surface reluctant to be breached. Water striders walk on ponds because their weight per leg cannot overcome the cohesive force holding the surface together. The “pinned” contact angle on a hydrophobic surface, the meniscus you see in a glass capillary, and the upward transpiration of water through a redwood from roots to needles — over a hundred metres against gravity — all flow from the same property.

The redwood case is worth dwelling on. The transpiration column is held together by cohesion (water to water, via hydrogen bonding) and adhesion (water to cellulose-lined xylem walls). The column is under enormous tension — a redwood is, in effect, pulling a several-megapascal-suction straw a hundred metres tall — and only the strength of water’s hydrogen-bond network and the narrowness of the conduits keep cavitation from rupturing the column. When droughts get severe enough to push xylem into cavitation, trees die.

Dielectric constant high enough to be a universal solvent

Water’s static dielectric constant at room temperature is about 78.5, which is huge. It means an ionic compound dissolved in water sees its internal Coulomb attraction reduced by a factor of nearly eighty, which is why salts that would never come apart in vacuum dissociate freely in solution. Combine that with the molecule’s polarity, its ability to act as both proton donor and proton acceptor, and the small molecular size that lets it nestle into solvation shells, and you get the “universal solvent” of the chemistry textbook.

It is, however, not actually universal. Water is a very bad solvent for nonpolar substances — oils, fats, atmospheric gases other than CO₂, most hydrocarbons. The hydrophobic effect, which drives lipid membranes to self-assemble and protein hydrophobic cores to fold inward, is essentially the consequence of water’s preference for hydrogen-bonding with itself rather than wasting bonds on a nonpolar guest molecule. Life on Earth as we know it is structured around the boundary between things that water loves and things it does not.

Part 2 — The phase diagram is wild

Water has more solid phases than any other known pure substance. The IUPAC list as of 2026 stands at roughly twenty: ice Ih (ordinary hexagonal ice), ice Ic (a metastable cubic form found in upper-atmosphere ice clouds), and ices II through XIX in various crystalline forms, plus at least three distinct amorphous forms — low-density (LDA), high-density (HDA), and very-high-density (VHDA) amorphous ice. Different combinations of pressure and temperature stabilise different stacking arrangements of the tetrahedral hydrogen-bond network, sometimes proton-ordered (every hydrogen position fixed) and sometimes proton-disordered (hydrogen positions fluctuating subject to the ice rules).

Phase	Stability conditions	Notable features
Ih	0 °C to −200 °C, ambient pressure	Normal ice; hexagonal; what you see in your freezer
Ic	130–220 K, low pressure	Cubic; metastable; in mesospheric clouds
II	190–210 K, 0.3 GPa	Rhombohedral, fully ordered
III	≥ 0.3 GPa, ~250 K	Tetragonal
V, VI	Higher pressures, 200–270 K	Monoclinic / tetragonal
VII	3 GPa+, room temp	Hydrogen-disordered cubic; included in diamond inclusions
VIII	Cold version of VII	Hydrogen-ordered
IX	165–208 K, 0.2–0.4 GPa	Ordered form of III
X	~70 GPa	Proton-symmetric ice
XI	240 K, low pressure	Ferroelectric, very slow-forming, found in old Antarctic ice
XII	High-density metastable	From heating HDA
XIII–XV	Ordered counterparts of V, VI, XII
XVI	Empty clathrate framework	Least dense crystalline ice
XVII	Hydrogen-filled clathrate residue	Discovered ~2016
XVIII	~100–400 GPa, 3000–5000 K	Superionic ice
XIX	~2 GPa, 100 K	Ordered counterpart of VI; described ~2021
LDA, HDA, VHDA	Amorphous	Glassy ices; LDA may relate to LDL liquid water

That last entry hides the biggest open question in the field, which I’ll get to in the next section.

Superionic ice

Superionic ice (ice XVIII) is what happens when you compress water to between roughly 100 and 400 GPa and heat it to a few thousand kelvin simultaneously. Above the transition, the oxygen atoms remain locked in a body-centred cubic lattice, but the hydrogen nuclei (bare protons, essentially) de-localise and flow through the lattice like a liquid. The result is a solid by some definitions and a liquid by others — a crystal that conducts electricity through proton diffusion. Marius Millot and collaborators at the Omega laser facility at the University of Rochester’s Laboratory for Laser Energetics demonstrated superionic ice experimentally in 2019, using ramped laser shocks to compress thin layers of water to the relevant conditions for billionths of a second and using X-ray diffraction to confirm the body-centred cubic oxygen lattice. The result had been predicted by Pierfranco Demontis and colleagues in 1988, which is a respectable 31 years of waiting for experimental confirmation.

Superionic ice is not laboratory exotica. It is believed to comprise the bulk of the interiors of Uranus and Neptune. Both of those planets have strange, multipolar, off-centre magnetic fields that have never made sense in a conventional dynamo picture; an electrically-conducting superionic mantle, in contrast to a small dynamo region near the surface, is a leading candidate for the geometry that produces them. The chemistry of life happens in liquid water; the chemistry of ice-giant magnetism may happen in a solid one.

Hot ice in carbon nanotubes

In 2016, Michael Strano’s group at MIT reported that water confined inside carbon nanotubes a few angstroms in diameter could exist as a solid at room temperature and even above the normal boiling point. The phase transition temperature shifted by an enormous margin — over 100 °C in some cases — depending on the exact diameter of the tube. The mechanism is geometric: when the channel is narrow enough that the water column has only one or two molecules across, the bulk hydrogen-bond network collapses into a strictly one-dimensional motif, and that motif has its own thermodynamics in which the entropy gain on melting is much smaller than in bulk. The freezing transition becomes more favourable. Hot ice in a straw.

The same group and others have shown that water transport through carbon nanotubes is enormously faster than classical hydrodynamics predicts — several orders of magnitude — while the tubes simultaneously reject ions almost completely. This is one of the bases for graphene-oxide membrane desalination, an active engineering area that could in principle produce fresh water from seawater at a fraction of current energy costs.

The no-man’s-land

In the supercooled regime, between roughly −38 °C (where homogeneous nucleation of ice Ih becomes unavoidable in bulk water) and roughly −123 °C (where amorphous water reverts to a liquid on heating), water is nearly impossible to study because it crystallises faster than any ordinary experimental technique can probe. This is the “no-man’s-land,” and it is exactly where the most interesting open questions live. New techniques — ultrafast laser heating of HDA ice, microfluidic confinement that suppresses nucleation, X-ray free-electron laser pulses shorter than the crystallisation time — have begun to crack the region open over the last decade. What they appear to be finding is the subject of the next section.

Part 3 — Active research frontiers

Two-state model: LDL and HDL liquid water

The most provocative current idea is that liquid water is actually a fluctuating mixture of two distinct local structures: a low-density liquid (LDL), open and tetrahedral and ice-Ih-like, and a high-density liquid (HDL), more closely packed and disordered, related to the high-density amorphous ice. The two-state model is associated with H. Eugene Stanley and Pradeep Kumar and was put on rigorous footing by computer simulations of the ST2 and TIP4P water models throughout the 1990s and 2000s. It predicts that there exists a second critical point of water, deep in the no-man’s-land at perhaps 220 K and 100 MPa, where the LDL/HDL distinction becomes a continuous transition.

Until recently this was almost entirely a theoretical proposal. Within the last few years, experiments using femtosecond X-ray scattering at free-electron laser facilities — much of it from Anders Nilsson’s group at Stockholm and SLAC — have produced strong evidence that supercooled water genuinely does fluctuate between two distinct structural populations. Erik Lascaris’s PhD thesis, which the wiki citation links to, covers the simulation side of this in detail; it remains one of the more readable surveys.

If the picture holds up, then the explanation for all of water’s textbook anomalies (density max, expansion on freezing, anomalous compressibility) becomes much cleaner: the unique behaviour is the macroscopic shadow of that buried two-state structure.

Mpemba effect

Hot water sometimes freezes faster than cold water. The observation is ancient — Aristotle mentions it — but the modern revival is due to a Tanzanian schoolboy, Erasto Mpemba, who in 1963 noticed that his hotter ice-cream base froze faster than his cooler classmates’ and refused to be laughed out of the room about it. He and Denis Osborne published the effect in Physics Education in 1969.

The Mpemba effect has been replicated under controlled conditions and is also stubbornly difficult to pin down. Different experiments report it in different temperature ranges, with different container geometries, and different proposed mechanisms — evaporation, convection, dissolved-gas content, supercooling differences, frost-layer formation, even hydrogen-bond network “memory” of the warmer state. A 2017 paper by Lasanta and collaborators put forward a thermodynamic framework based on Markovian master equations that gives the effect a general (and counterintuitive) home: under some non-equilibrium conditions, a system can reach a lower temperature faster from a higher starting point. So the effect is plausibly real, plausibly explained, and still hard to demonstrate reproducibly. A 2020 study questioned whether the canonical “hot freezes faster” experiment ever passes a rigorous reproducibility test in bulk water; current consensus seems to be “in granular media yes, in water sometimes but fragilely.”

Ortho and para water

Like H₂ and a handful of other molecules with equivalent hydrogen nuclei, water comes in two nuclear-spin isomers. Ortho-water has the two proton spins aligned parallel (total nuclear spin I = 1); para-water has them antiparallel (I = 0). The two isomers cannot interconvert without flipping a nuclear spin, which is slow under normal conditions. They have different rotational ground states, slightly different infrared spectra, and — most strikingly — slightly different chemical reactivities. Pure para-water has been produced and trapped at cryogenic temperatures, and its reactivity in cold molecular collisions has been measured to be distinguishable from ortho-water’s. At room temperature the equilibrium ratio is 3:1 ortho-to-para, set by the spin-statistical weights, but that ratio drifts at lower temperatures and may matter in astrochemistry, where cold molecular clouds preserve non-equilibrium ortho/para ratios that record the history of the water-ice grains.

Pressure-induced metallization

Push water hard enough and it stops being an insulator. Theoretical predictions and shock-compression experiments suggest that at pressures on the order of 50 megabars (5,000 GPa), water becomes metallic — that is, its band gap closes and it conducts via delocalised electrons rather than via proton hopping. This is well beyond what diamond anvil cells reach, but laser-driven shocks and isentropic compression at facilities like LLE and the National Ignition Facility have started to probe the relevant regime. Metallic water (or its sibling, metallic hydrogen) is again of planetary interest: deeper into the Uranian and Neptunian interiors, conditions may favour electronic rather than ionic conduction, and the difference matters for understanding planetary magnetic dynamos.

Part 4 — Macroscopic phenomena

Cavitation and sonoluminescence

A water-handling engineer’s nightmare is cavitation: when local pressure in a pump or propeller drops below the vapour pressure, bubbles of vapour nucleate, are carried into a higher-pressure region, and collapse with enough violence to pit metal surfaces. The collapse is supersonic on its inner surface and concentrates an extraordinary amount of energy in a very small volume.

How much energy is in question. Under acoustic forcing — driving a single bubble to oscillate in a standing sound wave in a flask of degassed water — the collapse produces a flash of light. The phenomenon is called sonoluminescence and was discovered by Frenzel and Schultes in 1934 in the context of submarine sonar research. The temperatures inferred from the blackbody spectrum of the flash are tens of thousands of kelvin; some experiments have argued for hundreds of thousands. There are theoretical proposals — never confirmed and now generally regarded as implausible — that a sufficiently violent collapse could produce a brief fusion event. What is certain is that a centimetre-scale chunk of water sitting in a flask can be coaxed into producing a glowing point that, at its centre during the collapse, is hotter than the surface of the Sun for about a hundred picoseconds. Whatever the exact mechanism, it is a spectacular concentration of energy.

Solitons, rogue waves, and the canal at Hermiston

In August 1834, the Scottish engineer John Scott Russell was riding along the Union Canal near Edinburgh observing a barge being towed by a pair of horses. The barge suddenly stopped, but the bow wave it had been pushing kept going — as a single, smooth, round-topped wave of fixed shape, travelling at about eight miles an hour. Russell rode after it on horseback for nearly two miles, until the wave finally dissipated in the shallows. He named it the “wave of translation.”

The wave of translation was a solitary nonlinear wave: a soliton. Russell spent decades trying to convince the British mathematical establishment that what he had seen was real. He built tanks in his back garden and demonstrated solitons in them. His contemporaries, Airy among them, insisted that according to linear wave theory no such thing could exist. The Korteweg-de Vries equation, published in 1895, finally provided the mathematical framework that vindicated him. We now know that solitons appear in optical fibres, in plasmas, in Bose-Einstein condensates, and in oceans, and the field of integrable systems they spawned occupies a substantial corner of modern mathematical physics.

The closely related Peregrine soliton, predicted in 1983 and experimentally demonstrated in water tanks around 2010, is a candidate model for ocean rogue waves: rare, transient walls of water several times larger than the surrounding sea state that have sunk ships and which were dismissed as sailor tales until well-instrumented oil platforms started recording them in the 1990s. A rogue wave is, in this model, a nonlinear focusing of the surrounding wave field that concentrates energy from a much wider region into a single peak.

Armstrong’s water bridge

Put two beakers of pure water close together but not touching. Apply a high voltage — about 15 kilovolts — between them. Touch the water surfaces with the electrode tips to start, then slowly pull the beakers apart. A horizontal water bridge forms between the two beakers, suspended in air across the gap, sometimes maintaining itself across 25 mm or more. The phenomenon was first reported by Sir William George Armstrong in 1893 and has been periodically rediscovered since. Modern investigations (Fuchs and colleagues, 2007 onward) have measured the bridge’s birefringence, indicating partial alignment of water molecules along the field direction, and have inferred a slight density increase relative to bulk water. The proposed mechanism is some combination of dielectric polarisation, surface tension, and electro-hydrodynamic flow, but a fully quantitative theory has not, as far as I know, been settled. It remains the kind of demonstration that gets passed around physics departments on slow afternoons.

Why ice is slippery

You would think, after a few centuries of skating and curling, that we would know the answer to this. We did not, for most of those centuries. The traditional textbook explanation — that pressure from a skate blade melts the ice locally because of the negative slope of water’s solid-liquid phase boundary — is wrong by about an order of magnitude. A skater’s weight on a thin blade is not enough to depress the melting point by more than a fraction of a degree, far less than the slipperiness you actually observe at, say, −20 °C.

The right answer, settled mostly in the last decade, is that the surface of ice is intrinsically pre-melted. A few nanometres of “quasi-liquid” water exist on ice surfaces at temperatures well below the bulk freezing point — a consequence of the fact that the cost of an incomplete hydrogen-bond network is paid at any free surface and that water “pays” that cost by being locally disordered. The thickness of the quasi-liquid layer increases as temperature approaches 0 °C, which is why ice gets slipperier near the freezing point. The phenomenon has been imaged with atomic-force microscopy, characterised by sum-frequency generation spectroscopy, and simulated to death; physical reviews on the topic appeared throughout the late 2010s.

Clathrate hydrates

A clathrate hydrate is a crystalline lattice of water molecules whose cages enclose guest molecules — methane, CO₂, hydrogen, noble gases — that the water network grows around. The most famous variety is methane hydrate, vast quantities of which exist on continental shelves and in permafrost regions. A chunk of methane hydrate looks like dirty ice but will catch fire if you put a match to it: the methane is released as the cage destabilises, and burns. “Burning ice.”

The total amount of carbon locked up in marine methane hydrates is enormous — comparable to or exceeding all known conventional fossil-fuel reserves. This has been periodically eyed as a potential energy source (Japan and China have run extraction trials) and is correspondingly periodically eyed as a major climate hazard: a destabilising release of seafloor methane during a warming event is a candidate trigger for the Paleocene-Eocene Thermal Maximum 56 million years ago, and the analogous event under a different climate forcing today is the kind of thing climate scientists lose sleep over.

Empty clathrate frameworks — ice XVI in the IUPAC list — are themselves the least dense known crystalline ice and can in principle be filled with arbitrary guests. There is real research on hydrogen-storage clathrates as a transportation fuel medium.

Plasma-activated water

Strike an electrical discharge in or just above water and you get water populated by short-lived reactive species — hydroxyl radicals, atomic oxygen, hydrogen peroxide, nitric oxide derivatives, hydrogen radicals. This “plasma-activated water” (PAW) is a real area of agricultural and medical chemistry: the radicals are strong oxidants and have been used for surface sterilisation, wastewater treatment, and crop disease control. Paul Leenders, mentioned on the wiki, has run a Dutch consortium on agricultural PAW; the IEEE Xplore citation on the page covers the electrochemistry. As a substitute for synthetic pesticides, PAW has genuine promise. As a snake-oil sold by “vitalised water” merchants, it has also been periodically misused. The chemistry is sound; the marketing varies.

Part 5 — Cosmic and planetary water

Subsurface oceans

The biggest astronomical story about water in the last twenty years is that liquid water is far less rare than we thought. The Galileo mission returned magnetometer signatures from Europa, Ganymede, and Callisto that are most easily explained by salty conducting layers under their icy crusts. Cassini’s flybys of Enceladus, the small Saturnian moon, directly sampled water-ice plumes erupting from the south polar region, finding organic molecules, hydrogen, and silica grains consistent with ongoing hydrothermal activity at the rocky core. Hubble and JWST have observed plume-like behaviour on Europa. The Juno mission has hinted at similar things at Io’s nearest cousins. Subsurface oceans appear to be common on the icy moons of Jupiter and Saturn, plausibly on Triton, and arguably on Pluto.

This matters for astrobiology because liquid water plus chemistry plus energy is the recipe we have for the only biosphere we know about. None of these moons gets significant sunlight, but tidal heating from the parent planet, plus chemistry at hydrothermal vents, can plausibly drive a biosphere chemically. Europa Clipper, which arrived in Jupiter orbit in the early 2030s, is specifically designed to test the habitability of Europa’s ocean.

Where did Earth’s water come from?

Deuterium-to-hydrogen ratios are a fingerprint. Different reservoirs in the early solar system formed with different D/H ratios depending on their temperature and chemistry, and water that condensed in those reservoirs retains the ratio it had when it froze out. The D/H ratio of Earth’s ocean water (the so-called Vienna Standard Mean Ocean Water, about 156 ppm) is a clue to where it came from.

For decades, the leading hypothesis was that Earth’s oceans came mostly from cometary impacts during the late heavy bombardment. The Rosetta mission’s measurements of D/H in the coma of comet 67P/Churyumov-Gerasimenko, published 2014, threw a wrench in this story: 67P’s water was three times the Earth-ocean ratio, far higher than expected and inconsistent with comets having delivered the bulk of Earth’s water. The current preferred picture is that most of Earth’s water came from carbonaceous chondrite-like asteroids whose D/H ratios are much closer to ocean water, with comets contributing a minority. That isn’t settled — Hartley 2 had an Earth-like D/H, individual comets vary — but it is the cleanest explanation we have at the moment.

Mars and the water that nearly was

Mars had liquid surface water for at least a billion years in its early history. The geological record is unambiguous: ancient river deltas, shorelines, evaporite deposits, hydrated minerals. The atmosphere was thicker and warmer, the magnetic field was active enough to shield the surface, and water was stable as a liquid in places. Then the core dynamo shut down, the solar wind stripped most of the atmosphere over hundreds of millions of years, and the planet froze.

What is left today is mostly ice, much of it polar, much of it subsurface. Curiosity and Perseverance keep finding evidence of recurrent slope lineae and brine flows; perchlorate salts depress the local freezing point enough that transient liquid water on the modern surface is plausible in some seasons. Mars Reconnaissance Orbiter’s SHARAD radar has located a candidate subglacial liquid lake beneath the south polar cap, though that result has been contested and may turn out to be hydrated clay rather than liquid. The story of Mars is, in a sense, a counterfactual for Earth: what happens when a rocky planet loses its magnetic field and slowly loses its atmosphere. Water is the marker we use to read that history.

Part 6 — Biological water

The water inside a living cell does not behave like the water in a beaker. Within a few angstroms of any protein surface, water molecules are oriented, their hydrogen-bond network biased by the local chemistry of the protein, their rotational reorientation times stretched from a couple of picoseconds in bulk to tens of picoseconds. Two-dimensional infrared spectroscopy and ultrafast pump-probe techniques over the last two decades have made this “biological water” or “hydration water” something that can actually be measured. It is not the mystical “structured water” of pseudoscience; it is a measurable, computable layer that decays with distance from the surface over a few angstroms. But it is also not the same as bulk water, and a lot of biophysics depends on the difference. Protein folding, ligand binding, allostery, even the diffusion of small molecules across membranes are all modulated by the local properties of the hydration shell.

Then there are organisms that engineer water at the macroscopic level. Antarctic notothenioid fish, snow fleas, several insects, and a number of overwintering plants secrete antifreeze proteins — molecules that bind to nascent ice crystal surfaces and pin further growth, depressing the freezing point of the organism’s body fluids by several degrees without affecting the equilibrium melting point. The bound proteins distort the ice surface such that further water addition is thermodynamically unfavourable. This is “thermal hysteresis,” and it lets the fish in question swim around in seawater at −2 °C without turning into a popsicle. The same trick is now being applied in food science to keep ice cream smooth.

A small detour into the hydrophobic effect, which I mentioned earlier: when an oil droplet sits in water, the water molecules at the interface must arrange themselves to satisfy as many hydrogen bonds as possible despite the oil being unable to participate. This forces them into a more ordered “iceberg” arrangement that costs entropy. The system can recover that entropy by pushing oil droplets together so the total interfacial area shrinks — and that is the driving force of the hydrophobic effect. Lipid bilayer self-assembly, micelle formation, and the burial of nonpolar amino acid side chains in protein cores all run on the entropy of water surrounding hydrophobic things, not on any direct attraction between hydrophobic objects themselves. Life is, in a real sense, a phenomenon that emerges from water’s preferences.

Part 7 — Fringe and pseudoscience

Water’s genuinely strange behaviour has, predictably, attracted a parade of claims that are not strange in the right way. A few are worth naming explicitly, partly because anyone reading about real water anomalies will eventually run into them, and partly because the debunking process itself is interesting.

Polywater

In 1962 the Soviet chemist Nikolai Fedyakin reported that water condensed in narrow quartz capillaries had unusual properties: higher density, higher viscosity, a different freezing point. Boris Derjaguin took up the work, named the substance “anomalous water” (later “polywater”), and proposed it was a polymerised form of H₂O. The claim spread to the West in the late 1960s and produced hundreds of papers, including breathless speculation that if polywater escaped the laboratory it might seed normal water into the polymerised form and end life on Earth — an Ice-nine scenario in real time.

The whole thing collapsed by about 1973 when better analytical techniques showed that the “polywater” samples were heavily contaminated with silica leached from the quartz, plus various organic impurities. Polywater was an artifact. The episode is now standard reading in philosophy-of-science courses as a worked example of confirmation bias, the social dynamics of an emerging research community, and how fragile-but-cheap measurements can hold a whole field hostage. Felix Franks’s 1981 book Polywater is the canonical history.

Water memory

In 1988, the immunologist Jacques Benveniste published a paper in Nature claiming that human basophil cells responded to extremely dilute solutions of anti-IgE antibody — so dilute that, by elementary stoichiometry, not a single antibody molecule should remain. The implication was that water somehow retained a “memory” of the antibody. The paper was published with an editorial note from Nature that it would be independently investigated, and a delegation including James Randi visited Benveniste’s lab. The follow-up investigation found systematic problems with the blinding protocol and could not replicate the result.

“Water memory” became, and remains, the central scientific argument underpinning homeopathy. Independent replications continue to fail. The field has periodically been revisited — most notably by Luc Montagnier in the 2000s, with similarly non-replicable results — and remains outside the mainstream. The textbook objection is that hydrogen bonds in liquid water rearrange on the order of picoseconds: any hypothetical “structure” imprinted on bulk water by a solute would dissolve essentially instantaneously into thermal motion. There is no known mechanism by which liquid water could retain a chemical memory on biologically-relevant timescales.

EZ water and the “fourth phase”

Gerald Pollack’s group at the University of Washington has reported that water adjacent to certain hydrophilic surfaces (Nafion membranes, for example) forms a layer hundreds of micrometres thick that excludes dyes and other solutes — the “exclusion zone” or EZ water. Pollack interprets this as a “fourth phase” of water, with a stoichiometry of H₃O₂ and distinct optical, electrical, and chemical properties.

The exclusion-zone observation itself is real and reproducible: there is indeed a region near hydrophilic surfaces in which solutes are depleted and the water has slightly different properties from bulk. The mainstream explanation is electrokinetic — surface charges on the membrane drive ion gradients and a long-range diffusive depletion zone — and does not require any new phase of water. Pollack’s broader claims (that EZ water charges itself by absorbing infrared radiation, that it explains how blood circulates without a heart pump, that drinking it has health benefits) have not been independently replicated and have moved progressively away from peer-reviewed venues. The 2013 popular book The Fourth Phase of Water is widely cited by alternative-health marketers selling “structured water” devices.

Hexagonal water, vitalised water, structured water

A large and lucrative industry sells filters, vortexers, and magnets that claim to produce “hexagonal,” “structured,” or “energised” water with health benefits. None of these claims has survived independent testing. The molecular structure of liquid water at room temperature is a dynamic mixture of locally-tetrahedral arrangements that interchange on picosecond timescales; no plumbing device can impose a persistent “hexagonal” structure on it that would survive being drunk. The marketing trades on the fact that ice Ih really is hexagonal, that water really has unusual properties, and that the underlying physics is sufficiently complicated that a vague rhetoric of “structure” sounds plausible to a non-specialist.

The genuine weirdness of water is the perfect breeding ground for this sort of thing. The defence is, as always, to insist on the same standards of replication, blinding, and mechanism for water claims as for any other physical claim. The actual physics is strange enough.

Part 8 — Historical asides

Brownian motion

In 1827, the Scottish botanist Robert Brown was looking through a microscope at pollen grains suspended in water, trying to figure out the mechanics of plant fertilisation. He noticed that the tiny pollen grains were perpetually jiggling. He showed the same thing happened with inert dust and with finely-ground inorganic matter; it was not a biological phenomenon. He had no theory for what the jiggling was.

It took until 1905 for Einstein, in one of his annus mirabilis papers, to derive the diffusive motion of the pollen grains as the consequence of repeated random kicks from the surrounding water molecules. Jean Perrin’s experimental verification in 1908 nailed down Avogadro’s number and Boltzmann’s constant simultaneously, won Perrin a Nobel in 1926, and — among many other things — silenced the remaining sceptics of the atomic hypothesis. The first observed evidence that matter is made of atoms came from a botanist looking at pollen in a drop of water.

Heavy water and the Norwegian sabotage

Deuterium oxide, D₂O, is chemically almost identical to ordinary water but has a higher boiling point, a slightly different freezing point, and a different refractive index. It also slows neutrons in a nuclear reactor better than ordinary water does. During World War II, the Vemork hydroelectric plant in Norway, operated by Norsk Hydro, was the only large industrial producer of heavy water in Europe. The German nuclear weapons programme depended on Vemork’s output.

A series of British and Norwegian commando raids over 1942–1943 culminated in Operation Gunnerside in February 1943, in which a small team of Norwegian SOE-trained operatives skied across the Hardangervidda plateau in winter conditions, descended a ravine that the German garrison had judged unscaleable, and destroyed the heavy water cell room with explosive charges. A follow-up sabotage in February 1944 sank the ferry Hydro carrying the remaining heavy water inventory to Germany. The German nuclear programme was set back substantially. The 1965 film The Heroes of Telemark covers the story, somewhat romanticised. It remains, depending on how you count, one of the most consequential commando operations of the war.

Closing

After all of that, what is left?

A lot. We still do not have a fully accepted theory of the supercooled regime. We do not know whether the proposed second critical point of water genuinely exists, or whether the two-state picture survives more stringent tests, or how to reconcile the diverse experimental probes of the LDL/HDL distinction with each other. We do not have a clean microscopic theory of sonoluminescence. We do not have a satisfactory quantitative account of Armstrong’s water bridge. We are still arguing about which planetary bodies harbour subsurface oceans liquid enough to host chemistry. We are still, after decades, finding new crystalline ice phases.

Water is the textbook example of how a chemically simple molecule, given enough degrees of freedom in its hydrogen-bond network, can produce phenomena that span centuries of physics. It is also the textbook example of how genuine scientific weirdness is a magnet for less-disciplined imitations, and of how a research community has to keep adjudicating the boundary between the two. Martin Chaplin’s catalogue of seventy anomalies is a fine place to lose an afternoon; Lascaris’s thesis is a fine place to lose a week. The whole subject has the rare quality, in 2026, of being a thing every human encounters every day and that science has not finished explaining.

References and further reading

Chaplin, M. Water Structure and Science. London South Bank University. https://water.lsbu.ac.uk/water/ — the canonical online catalogue, including the seventy-anomalies list.
Lascaris, E. Liquid-Liquid Phase Transitions and Water-Like Anomalies in Liquids. PhD thesis, Boston University, 2014. https://physics.bu.edu/~erikl/research/Lascaris_PhD-defense_09july2014.pdf
Millot, M. et al. “Nanosecond X-ray diffraction of shock-compressed superionic water ice.” Nature 569, 2019. Phys.org coverage: https://phys.org/news/2019-05-giant-lasers-crystallize-shockwaves-revealing.html
Pollack, G. The Fourth Phase of Water (2013). TEDxGuelphU lecture: https://youtu.be/i-T7tCMUDXU. See independent review for the controversy.
Stanley, H. E.; Kumar, P.; et al. Many papers on the two-state hypothesis through the 1990s and 2000s; the Stockholm/SLAC group (Nilsson, Pettersson) provided the modern experimental backbone.
Nilsson, A. SLAC public lecture, “Water: the Strangest Liquid” (24 February 2009). https://youtu.be/7hGqlEpvODw
Barbosa, M. “The weirdness of water could be the answer.” TEDxCERN. https://www.youtube.com/watch?v=-OLFwkfPxCg
Lasanta, A.; Vega Reyes, F.; Prados, A.; Santos, A. “When the hotter cools more quickly: Mpemba effect in granular fluids.” Phys. Rev. Lett. 119, 2017.
Strano, M. et al. “Anomalous freezing of water confined in carbon nanotubes.” 2016. MIT news release: https://news.mit.edu/2016/carbon-nanotubes-water-solid-boiling-1128
Salzmann, C. G.; Rosu-Finsen, A. et al. on ice XIX and related newly-described crystalline phases, ~2021.
Russell, J. S. Report on Waves (1844), British Association for the Advancement of Science. The Union Canal observation is in §1.
Kirby, B.; et al. on the rogue-wave / Peregrine-soliton analogy in water tanks. https://www.nature.com/articles/nphys1740
Franks, F. Polywater. MIT Press, 1981.
Maddox, J.; Randi, J.; Stewart, W. “‘High-dilution’ experiments a delusion.” Nature 334, 1988 — the Benveniste investigation.
Mpemba, E. B.; Osborne, D. G. “Cool?” Physics Education 4, 1969.
The Heroes of Telemark (1965) — dramatised but readable take on Operation Gunnerside.

Comments, corrections, additional anomalies welcome.

BNN on the GA144: Forth, Hamming Distance, and Picojoules

2026-05-29T01:35:29.753-07:00

BNN on the GA144: Forth, Hamming Distance, and Picojoules

Fifth in a series. The earlier four (water anomalies, if water were the computer, the third replicator, anagrams as source code) were about substrates — physical, quantum, cultural, statistical. This one is about a piece of silicon that nobody has used in anger and the operation it was accidentally optimised for: Hamming distance. Which is also the only operation a binary neural network actually needs.

In 2008, GreenArrays released the GA144: a single chip with 144 independent 18-bit dual-stack Forth cores arranged in a 12×12 mesh, each core with 64 words of RAM and 64 words of ROM, communicating with its four nearest neighbors through blocking register-to-register transfers, asynchronous, no global clock, retailing for about $20, consuming microwatts at idle and roughly 7 picojoules per instruction when active. It was designed by Chuck Moore, the inventor of Forth, and it is the most power-efficient general-purpose computer ever shipped commercially. It has also, in the decade and a half since it appeared, been used for almost nothing.

This essay is the argument for what it should be used for. The short version: binary neural network inference. The longer version is that this isn’t a coincidence — the GA144’s architectural choices, the constraints that have kept it out of mainstream use, and the mathematical structure of BNN inference fit together in a way that looks designed even though it isn’t. The bridge between them is one specific operation, Hamming distance, that I have been computing on various pieces of silicon since 1996 for completely unrelated reasons. The pieces start to look like the same problem only in retrospect.

1. The GA144, briefly

Chuck Moore is the inventor of the Forth programming language. He has been designing minimalist stack-based processors to run Forth natively since at least 1985 (the Novix NC4016), through the RTX2000 (1988), the ShBoom (1990s), and a sequence of MISC and MuP21-line chips at iTV Corporation and later GreenArrays. The GA144 is the seventh or eighth chip in this lineage. The design principle is consistent across all of them and is not the design principle of mainstream processor architecture: do less per cycle, fit more cores on the die, let them communicate directly, run them asynchronously, and reach the power-efficiency frontier by not having any of the global infrastructure that most processors burn watts maintaining.

Each F18A core inside a GA144 looks, by mainstream standards, like a toy:

18-bit word size (not 16, not 32, not 64 — 18, chosen because it cleanly subdivides into three 5-bit instruction slots plus a 3-bit slot, fitting four instructions per word).
64 words of RAM, 64 words of ROM. That is 1,152 bits of writable state per core. There is no cache, no MMU, no DRAM. A program has to be tiny.
Dual-stack architecture — a data stack and a return stack — with the top three of each stack as named registers and the rest in a small circular buffer. Forth conventions throughout.
Minimal instruction set — about 32 instructions, all single-cycle, including XOR, NOT, AND, ADD, shifts, conditionals, returns, and communication primitives for the four neighbour ports.
No clock. The core advances when its inputs are ready. When it has nothing to do, it stops drawing power. When a neighbour sends data, it wakes.

The 144 cores are wired in a 12×12 grid. A core can read from and write to its north, south, east, and west neighbours through register-mapped ports. There is no broadcast bus, no shared memory, no cache coherence. If two cores on opposite sides of the chip need to talk, the message has to be relayed by the cores in between.

The GA144 ships at around $20 per chip, draws single-digit milliwatts at full load and microwatts at idle, and aggregates to roughly 700 MIPS across the whole die. By any metric except power-per-instruction it is uncompetitive with a modern Cortex-M0, let alone an x86 core. By the power-per-instruction metric it is unmatched.

Why has nobody used it? Three reasons:

The 64-word RAM limit per core. You cannot run a normal program. You have to break the problem into pieces that fit. This is the objection that keeps mainstream developers off the chip.
It runs Forth. Stack-based, postfix, no types, you-edit-with- colorForth-or-arrayForth. The Forth tradition is small, devout, and epistemically incompatible with the C tradition. Most engineers have never written Forth and don’t want to start.
The benchmarks aren’t there. The chip would crush at the things it was designed for, except that “the things it was designed for” is not a category that mainstream processor reviews evaluate. It loses on SPECint by orders of magnitude, because SPECint is not what the GA144 is for.

The thesis of this essay is that BNN inference at the edge is what the GA144 is for, and that the constraints which have kept it unfashionable turn out to be the exact properties that make BNN inference work on it.

2. BNNs, briefly

A standard neural network computes, at every neuron, a sum of products: take each input, multiply by a learned weight, add up the products, pass through a nonlinearity. With 32-bit floating-point weights and activations, that multiply-add is roughly 50 picojoules on a modern CPU — a number dominated by the floating-point unit and the memory bandwidth required to move the weights in and out.

A Binary Neural Network constrains both the weights and the activations to two values, +1 and −1. The training story (which I’ll mostly skip here; the canonical paper is Courbariaux et al. 2016) is that you can train with the standard floating-point backprop but apply a sign() activation at inference time and the resulting binary-weight model loses only a few percentage points of accuracy on most problems that a small MLP can do at all. Larq, the open-source BNN training framework, ships with reference implementations.

The interesting part is what happens at inference time when everything is one bit. Encode +1 as 1 and −1 as 0. Then the multiplication of a weight bit w by an activation bit a produces:

w	a	w · a	encoded
+1 (1)	+1 (1)	+1	1
+1 (1)	−1 (0)	−1	0
−1 (0)	+1 (1)	−1	0
−1 (0)	−1 (0)	+1	1

That’s the XNOR truth table. Multiplication has become XNOR.

Summing the products is then just counting the 1-bits in the XNOR result and adjusting for sign. If N is the vector length and p = popcount(XNOR(W, A)), then:

dot(W, A) = 2 * p - N

Equivalently, since XNOR = NOT(XOR):

dot(W, A) = N - 2 * popcount(XOR(W, A))
         = N - 2 * hamming_distance(W, A)

The dot product of two binary vectors is a closed-form function of their Hamming distance. Neural network inference, the multiply-accumulate that the deep learning revolution scaled up by fifteen orders of magnitude, reduces to Hamming distance once you binarise.

On a modern CPU, this means you can compute 64 multiplications and their sum with one XOR instruction, one popcount instruction, and a subtract. The whole tightly-coded inner loop is three or four instructions. The energy savings over a floating-point MAC are between one and three orders of magnitude. The memory savings — because each weight is one bit instead of 32 — are exactly 32×.

The drawbacks are also real. You lose some accuracy. You cannot use a BNN where a floating-point ResNet is required. The technique works for small-to-medium classification, keyword spotting, gesture recognition, simple object detection. Not Stable Diffusion. Not GPT-4. But for the long tail of edge AI applications — the hearing aid, the doorbell camera, the always-on sensor — the trade is a clear win.

3. Why the match is so clean

Now the alignment. Take each of the GA144’s “limitations” and ask what BNN inference does with it.

3.1 Memory

The GA144 has 64 words of RAM per core. That is the single most quoted reason the chip is unusable: you cannot fit a normal program in 1,152 bits.

In binary: 1,152 bits is 1,152 weights. A small dense layer (say, 32 inputs × 32 outputs) needs exactly 1,024 weight bits. One core fits one small layer with room to spare. Across the chip:

Encoding	Bits per weight	Weights per core	Weights per chip
FP32	32	36	5,184
INT8	8	144	20,736
Binary	1	1,152	165,888

165,888 weight parameters is enough for a meaningful classifier. A keyword-spotter “hey siri” style network is in the 100K-parameter range. Many gesture-recognition models fit. A small image classifier on 32×32 inputs fits.

The constraint that kept the GA144 out of general-purpose computing has the opposite sign for BNN inference. The chip has exactly the amount of memory you need.

3.2 The 18-bit word

The F18A’s 18-bit word holds 18 binary products per XNOR. That’s narrower than AVX-512’s 512-bit lanes and yes, this is the GA144’s weakest dimension — bit-for-bit it loses to wider SIMD. But the GA144 is not competing on aggregate throughput, it is competing on ops per joule, and 144 cores each doing 18 bits at 700 MHz adds up. The aggregate XNOR rate is around 2 trillion bit-products per second across the chip, an order of magnitude below a high-end Xeon but at less than 1% of the power.

The 18-bit width also has a useful side effect for popcount, which the F18A does not have as a native instruction. A 9-bit lookup table — 512 entries — fits inside the ROM budget if you partition it across cores, and popcount of an 18-bit word becomes two table lookups plus an add. Three instructions.

3.3 The instruction set

The F18A’s minimal instruction set already contains what BNN inference needs.

XOR — single-cycle native. Combined with NOT (also single cycle) you have XNOR in two cycles.
Popcount — not native, but the lookup-table approach above runs in three cycles for an 18-bit chunk.
Sign activation — just a comparison against a threshold, which the F18A handles with conditional skip.

The inner loop for one neuron is roughly:

@a   ( fetch activation word from north port )
@w   ( fetch weight word from local memory )
xor  ( XOR them — XNOR after one more NOT )
-not ( invert: now we have XNOR in the top of stack )
pop  ( table lookup for popcount )
+    ( accumulate into running sum )

That’s six F18A instructions per 18 binary products. At ~700 MHz single-cycle execution per core, you get something like 100 million 18-bit XNOR-popcount-accumulate operations per core per second, or roughly 2 billion per core per second of bit-level operations. Times 144 cores, that’s about 2.5 trillion binary ops per second on the whole chip. At an estimated 0.15 W power draw, that’s approximately 17 trillion binary ops per joule.

The comparison chart that this lives in:

Platform	Binary ops/sec	Power	Ops/joule
Intel Xeon (AVX-512)	~200 G	~150 W	~1.3 G
ARM Cortex-A72 (NEON)	~30 G	~3 W	~10 G
ARM Cortex-M4	~500 M	~50 mW	~10 G
GA144 (projected)	~2.5 T	~150 mW	~17 T

The GA144 is roughly three orders of magnitude better than a Xeon on ops-per-joule for this specific workload, and a thousand times more energy-efficient than a Cortex-M4. The Xeon delivers more total throughput, but at a hundred to a thousand times the power. That ratio is exactly the trade-off the edge inference market is shaped around.

3.4 The mesh

A 12×12 mesh of cores with neighbour-only communication looks, on first contact, like a bug. You cannot do arbitrary point-to-point routing without intermediate cores. You cannot broadcast. You cannot gather from arbitrary locations.

A neural network layer, structurally, is a sequence of neighbour-only transformations. The activations of layer N feed only into layer N+1; there are no skip connections in a vanilla MLP, and even in architectures with residuals the connections are local. The natural mapping is:

Each row of cores = one layer, with cores in the row processing different output neurons of that layer.
Activations flow east-to-west or north-to-south between layers, using the inter-core ports.
Weights are static, loaded once at boot from external flash into each core’s RAM.
Pipelining is automatic. As soon as a core finishes computing its output activation, it streams the result to its neighbour and starts on the next input. The asynchronous design means there is no global pipeline stall; cores wake and sleep individually based on data availability.

The chip is, essentially, a piece of hardware whose dataflow graph matches a layered feedforward network’s dataflow graph. Mainstream processors have to emulate this with shared memory, cache hierarchy, and software pipelining. The GA144 just is this dataflow.

3.5 Asynchronous wake-on-data

This is the property that nothing else matches. A core that has no input to process is drawing essentially zero current. A clocked processor at the same idle state is still burning the clock distribution tree, the cache refresh, the PLLs, the voltage regulators. The GA144’s asynchronous design means a sparse neural network — one where many activations are zero — costs zero energy on the zero-activation cores. Sparsity becomes a hardware property, not an algorithmic optimisation.

4. Hamming distance: the throughline

I started thinking seriously about this because I have been computing Hamming distances on various pieces of silicon for thirty years for completely unrelated reasons, and I noticed the same operation kept showing up.

In 1996 I was working on what became ECIP — Error Correcting Internet Protocol — an early implementation of forward error correction for real-time UDP streaming. The motivation was that Internet packet loss is an erasure channel: packets either arrive intact or they don’t arrive at all. There’s no need to detect corruption inside a packet (UDP checksums do that). What you need is to recover entire missing packets from redundancy in the surrounding ones, and the math for that uses block codes whose optimality is determined by the minimum Hamming distance between codewords.

To find good codes I wrote a brute-force search program, ecc4.c, that for a given block size enumerates candidate codewords, checks the Hamming distance from each candidate to every codeword already accepted, and keeps the candidates that maintain a minimum distance above some threshold. The inner loop is identical to BNN inference: a XOR between two bit-vectors, a popcount of the result, a compare against a threshold.

Around 1998 the program got rewritten as a portable CPU benchmark and distributed to contributors, who ran it on every x86 generation from the 386 onward. I called it Budmark (long story). The data collected between 1996 and 2002 was, in retrospect, a longitudinal study of how processor architectures handled the XOR-popcount primitive across nearly fifteen years of x86 evolution.

The most interesting result was the Pentium 4. The P4 was running at 2.26 GHz — almost four times the clock speed of the Pentium II Xeon at 600 MHz. On any benchmark Intel marketed at the time, the P4 crushed. On Budmark, the P4 was only 66.7% as efficient per cycle as the P3, meaning that despite its enormous clock advantage it finished a Budmark run only about 1.5× faster than the older chip. I didn’t know at the time, but Budmark was measuring exactly the operations that the P4’s NetBurst architecture had deprioritised — pipeline-unfriendly tight loops on small bit operations. The benchmark predicted Intel’s architectural dead end a couple of years before Intel acknowledged it and went back to the Pentium-Pro lineage that became Core.

The connection to BNN didn’t exist then. It exists now. Every processor that did well on Budmark would do well on BNN inference, and every processor that did badly would do badly, because the fundamental operation is the same. Hamming distance is the unifying primitive across:

Error-correcting codes — minimum Hamming distance between codewords determines correction capability.
Binary neural networks — dot product equals length minus twice Hamming distance.
Locality-sensitive hashing — near-duplicate detection rides on Hamming distance over fingerprint bits.
Cryptanalysis — many cipher attacks reduce to Hamming-weight analyses of the key schedule.
Binary feature matching — ORB, BRIEF, FREAK descriptors all compare via Hamming distance.

Once you see the primitive everywhere, designing for it stops feeling specialised and starts feeling general. The GA144 is a chip designed for Hamming distance computation, accidentally and brilliantly. It was designed for Forth and for power efficiency. It happened to land in the same architectural neighbourhood as the right shape for BNN inference because the underlying problem — extracting decisions from sparse bit-level patterns at low energy cost — is structurally the same problem across all these domains.

5. The Palmo echo

Before BNNs had the name, I was building one. In 1994 I started a project I called Palmo — “palm” + “mo” for “motion” — to do real-time hand-gesture recognition from video on 486-class machines. Memory was tight (target was sub-megabyte footprint) and CPU was tight (a 486 at 66 MHz delivered maybe 25 MIPS). The only way to make a neural network fit in those constraints was to binarise the weights and activations and exploit the resulting bit-parallelism.

Palmo’s architecture was distributed across maybe 100,000 FreeBSD machines volunteer-connected over the Internet, each running small networks and communicating via compressed binary activation packets. Three things made it work:

Compressed bit packets for inter-node communication: 1,000 binary activations fit in 125 bytes instead of 4,000 bytes of float, a 32× bandwidth reduction.
Lazy neuron evaluation in a linked list: neurons updated only when their inputs changed, using timestamp-based decay instead of continuous evaluation.
Threshold-based firing as the only nonlinearity, computable in one compare.

These are exactly the techniques that resurfaced 20 years later as BinaryConnect (2015) and XNOR-Net (2016). I shelved Palmo in 1996 because the GPU revolution made floating-point cheap, the deep learning community standardised on float, and there was no commercial interest in binary approaches. The 2015-onward BNN renaissance felt, when I lived through it, like watching someone re-derive your abandoned PhD thesis from first principles.

The reason this matters here: the GA144 is “Palmo on a chip.” Take the distributed-100k-FreeBSD-machines architecture, miniaturise it by six orders of magnitude, swap TCP/IP for register-to-register neighbour transfers, swap millisecond network latency for nanosecond wire latency, and you have the GA144. The architectural principles are identical. The Palmo project ran the experiment at the distributed-system scale and the GA144 packages the result at the silicon scale. Nobody noticed because the two communities — Forth hardware people and binary neural network people — don’t talk to each other.

6. Why this hasn’t happened yet

The honest accounting: the GA144 has been available since around 2010 or 2011. BinaryConnect and XNOR-Net are nine and eight years old respectively. The energy advantage I’m describing has been on the table the whole time. Why has nobody shipped a GA144-based BNN inference engine?

A few reasons:

The Forth barrier. Programming a GA144 requires colorForth or arrayForth, both of which look alien to anyone trained on C/Python. The toolchain is small, the documentation is sparse, and the community is a few hundred people worldwide. Getting a working F18A-port of a BNN inference loop is a week of work for someone fluent in Forth and a month for someone who isn’t.

The mainstream-benchmark gap. Processor reviews don’t measure edge-AI inference energy. They measure SPECint, Geekbench, AI-bench on giant networks. The GA144 loses on every one of those and wins on none of them. There has never been a high-profile public benchmark that would have surfaced its actual strengths.

The deployment story. Mainstream MCU programmers reach for an STM32 or an ESP32 or a Cortex-M0 because the toolchain is familiar, the ecosystem is huge, and the chip is available everywhere. The GA144 is single-sourced from GreenArrays, who make it in small batches. There is no Arduino-style ecosystem. There is no TensorFlow Lite backend.

The accuracy ceiling. BNNs do well on small classification but they cannot do everything a floating-point network can. If your edge application needs the last 5% of accuracy that the FP32 model gets and the BNN doesn’t, you’re going to ship a Cortex-M4 with INT8 quantised weights and you’re going to take the power hit. The market for chips that are only good at the BNN workload has been small.

All four reasons are softening. Forth toolchains are getting better (there are now Python-based F18A simulators that let you prototype without the colorForth learning cliff). Edge AI is exploding as a deployment category and per-inference energy is starting to matter more than absolute accuracy. The BNN accuracy story is improving as training techniques mature. And the energy budget of LLM-driven applications has gotten so large that even mainstream attention is turning to the bottom of the inference market.

The GA144 is, in 2026, approximately ten years too early or three years too late depending on how you count. The case for porting a keyword-spotter or a gesture-recognition model to it is now defensible in a way it wasn’t even five years ago.

7. What edge AI is actually measured in

The mainstream AI conversation is measured in TFLOPS, in tokens-per-second, in dollars per million tokens. None of those metrics apply to the edge. At the edge the relevant units are:

Inferences per millijoule — battery-powered devices live or die by this.
Latency from sensor wake to decision — for always-on listeners, motion detectors, fall sensors.
Memory footprint that fits in on-chip RAM — because going off-chip to DRAM dominates the energy budget.
Cost per chip in volume — embedded sensor markets are extremely price-sensitive.

On all four metrics the GA144 looks competitive or better. On inferences per millijoule for a binary classifier of reasonable size, the projected numbers put it at roughly one to three orders of magnitude ahead of conventional MCUs. On latency, the asynchronous design means a wake-on-data inference can complete in microseconds. On memory footprint, by definition, anything that fits at all fits entirely on chip. On cost, $20 is not great for an MCU role but is not catastrophic for a specialised edge inference accelerator.

The chip is not for everything. It is for the specific case where the network is small enough to fit, the input cadence is intermittent enough that asynchronous wake-on-data wins, and the energy budget is tight enough that the picojoule-per-instruction matters. That case exists. Hearing aids. Implantable sensors. Long-battery industrial sensors. Solar-powered wildlife cameras with on-board species classification. The list is shorter than the LLM list but it’s not empty, and it’s getting longer.

8. What a port would actually look like

Sketching the minimum viable demonstration:

Pick a small BNN — the canonical 784→256→128→10 MNIST MLP I already have running in C and AVX2 (see bnn1 in the parent repo). 165,888 binary weights chip-wide; the MNIST MLP needs ~233K binary weights total, so it would need either compression or a slightly smaller architecture (say 784→128→64→10, which has ~108K weights and fits comfortably).
Allocate cores by layer. With 144 cores and three layers, the natural mapping is: top row(s) handle layer 1, middle row(s) handle layer 2, bottom row(s) handle layer 3. Each row pipelines its outputs to the next.
Implement the inner loop in F18A assembly. The XNOR-popcount- accumulate inner loop is six instructions per 18 bits. A 32-wide input layer takes two iterations.
Build a host-side driver that streams MNIST images into the north edge of the mesh and reads classifications from the south edge. The host can be an ordinary Cortex-M running on the same board.
Measure. Inferences per second, energy per inference, latency from input to output. Compare against the existing AVX2 reference implementation and against a Cortex-M4 INT8 quantised implementation as the relevant baselines.

A working demo of this would take, by my estimate, a focused month for someone fluent in F18A Forth and roughly three months for someone coming from C. The result would be the world’s first published GA144 BNN inference engine and would, if my numbers are roughly right, establish a power-efficiency record for the workload that would be hard to beat without designing custom silicon.

9. The deeper claim

If you’ve read the other essays in this series, the structure of this argument is familiar. There is an information-processing substrate (Forth-style minimal-stack cores in a 2D mesh), there is an information-processing problem (BNN inference at the edge), and the substrate and the problem fit together in a way that nobody designed for explicitly but that falls out cleanly once you see the underlying operation.

That underlying operation, in this case, is Hamming distance — popcount of a XOR. It is the same operation I was running on Pentium II Xeons in 1998 to find error-correcting codes, the same operation modern locality-sensitive hashing rides on, the same operation BinaryConnect-era researchers re-derived from neural network quantisation. Substrates change. Problems change. The operation doesn’t.

Chuck Moore designed the GA144 because he was committed to an architectural philosophy nobody else followed — minimalist, async, mesh-connected, Forth-native — and trusted that the niche would exist somewhere even if he couldn’t predict where. The niche turned out to be BNN inference, which didn’t exist as a research area when the chip taped out and which only became commercially interesting a decade later. The match between them is the kind of thing you’d expect to see when both the substrate designer and the problem designer were optimising against the same hidden objective without realising it. The objective, in retrospect, was maximum useful computation per picojoule on bit-level operations. They both went for it. They both got there. They met.

I would like to be the person who finally connects them. The work is real and tractable and would benefit from someone who has both the Forth heritage and the BNN heritage in the same head, which I do, and which is rare. The chip is still available; the BNN technique is mature; the inner loop fits in six instructions per 18 binary products. It is, structurally, a two-month project away from demonstrating something nobody else has demonstrated.

I am writing this partly to commit, in public, to actually doing it.

Anagrams as Source Code: A 2014 Hint at What LLMs Would Be

2026-05-29T01:33:34.980-07:00

Anagrams as Source Code: A 2014 Hint at What LLMs Would Be

Fourth in a series. Read the mimetics essay for the broader frame; this one zooms in on a single page of my old wiki and asks why the intuition on it turned out to predict, in structure if not in detail, what large language models would become.

Sometime in the early 2010s — the page history says the bulk of edits land between 2011 and 2015 — I wrote on my wiki the following claim, which I’ll quote unedited because the rough edges are the point:

I am convinced it’s not “SuperNatural” but part of a memetic fabric of the way the brain does pattern recognition. … This has been done so long, that the languages evolve with these mechanisms built in to it. So much so that message content is based on the frequency of letters more then the actually words.
Anyhow decoding the anagrams is like looking at the source code, you can’t take it’s contents on literal face value but how it will subconsciously effect those people who “Get it”. … Now that I’ve been writing for a while I can feel what’s going to make a good anagram or not. I can feel weather it’s positive or negative.
It should also be possible to have a program that can measure a content’s meme-worthiness, (the ability to propagate as a meme, and in the greater context of current events and the mainstream media’s effects.)
It should also be possible to create a system that could generate candidate meme’s that should have a high likelihood of success.

The specific claim — that anagrams literally carry meaning, that re-arranging letters reveals a hidden semantic layer — I now think is mostly wrong. But the structural claim wrapped around it is something I’ve gotten less sure was wrong with every passing year. The structural claim is that language has a substrate of statistical pattern that does cognitive work in parallel with semantic content, that the substrate is exploitable, and that a program could be built to operate on it.

Nobody built that program in 2014. Then, ten years later, somebody did — but they did it by accident, while trying to build something else, and what they ended up with looks nothing like what I imagined. They called it a large language model. It works, and the reason it works validates the hint on the wiki page more than I would have predicted.

This essay is about the connection.

1. What the wiki claim was, exactly

The page is Nature_of_Language in the cluster I built around Department of Memetics. Stripped to its bones, the argument runs:

Spoken and written language has evolved alongside the brains that process it for hundreds of thousands of years.
Any feature of language that affects reader response will, under that long Darwinian sieve, accumulate in the language because writers and speakers whose feel produced more effective patterns out-propagated those whose feel did not.
Letter and phoneme distributions are such a feature. They affect reader response — the rhythm of a sentence, the “feel” of a name, whether a phrase lands — on a channel below conscious semantic processing.
Therefore there is hidden statistical structure in language that is doing cognitive work in parallel with the propositional content.
Skilled writers can sense the structure but do not consciously manipulate it. Actors choose stage names whose letter distributions “feel right.” Marketers find the slogan that sticks. Speechwriters tune phrases until they’re memorable.
In principle, a program could measure the structure. It could score arbitrary text for “meme-worthiness.” It could generate text optimised against that score.

I added the anagram story because I was doing statistical work on anagrams at the time and thought I was finding something specific — that the anagrams of high-impact phrases had statistically interesting properties. I now believe what I was actually picking up was the underlying letter-frequency structure of the source phrase, which an anagram by definition preserves. The anagrams were a symptom; the real signal was the letter-frequency surface of the input.

The substrate was real. The diagnostic — anagrams as source-code- revealing — was wrong but pointed at something true. This is a more common pattern in early-stage hypotheses than people give credit for.

2. The statistical substrate of language was already known

The wiki page makes the argument de novo, which it shouldn’t have, because by the early 2010s most of the components were textbook.

Zipf’s law

George Kingsley Zipf in 1932 — and Alfred Lotka before him — noticed that if you rank words in a corpus by frequency, the n-th most common word appears about 1/n as often as the most common one. The most frequent English word (“the”) appears about twice as often as the second (“of”), three times as often as the third (“and”), and so on. The pattern is shockingly robust: it holds in every natural language ever measured, it holds across topics within a language, it holds across centuries within the same language, and it holds at the character level too. The frequencies are not random. They sit on a power law that any sufficiently large text obeys.

The implication for the wiki claim is direct. If letter and word frequencies are stable lawful features of a language, then a brain that processes language has had millennia to internalise those frequencies and to use them — as a kind of background model against which surprise is computed. The information content of a token is proportional to the negative log of its frequency. Surprise is information, in the technical sense Shannon nailed down in 1948.

Shannon’s word game

Speaking of Shannon: in A Mathematical Theory of Communication he introduced what we now call n-gram models of English, ran them forward, and showed that you can generate increasingly English-looking text by sampling from progressively higher-order n-grams. Order-0 gives uniform letter distribution: garbage. Order-1 gives the right letter frequencies but random sequences: still garbage but lumpy. Order-2 (bigrams) starts producing pronounceable nonsense. Order-3 (trigrams) starts producing word-shaped tokens. Order-5 or so produces text that, sentence by sentence, looks like English — even though it has no semantic content.

The 1948 paper essentially demonstrated that statistical structure captured at the letter level is most of what makes text look like language. This is the same argument the wiki page was groping toward, twenty-six years before the wiki page. I should have read Shannon more carefully. So should everyone.

Cryptanalysis: anagrams as source code, for real

The discipline that has taken letter-frequency analysis most seriously for the longest is cryptanalysis. Al-Kindi, in 9th-century Baghdad, wrote Risāla fī Istikhrāj al-Muʿammā — “On Extracting Encrypted Letters” — which laid out frequency analysis: count the letters in the ciphertext, match them against the known frequency distribution of the plaintext language, and you have probabilistic guesses for each substitution cipher’s mapping. From the 9th century forward, this was the dominant attack on substitution ciphers, and every serious encryption system since has been designed with frequency analysis as the first thing to defeat.

Modern cryptography talks about confusion and diffusion, terms Shannon coined in 1949. Confusion makes the relationship between key and ciphertext complex. Diffusion spreads the statistical structure of the plaintext across many positions in the ciphertext, so that no local letter-frequency pattern survives. AES is built to destroy the patterns Al-Kindi exploited. The fact that we have to destroy them to get a secure cipher tells you that the patterns are real, that they carry information, and that a sufficiently patient algorithm can read them.

Reading the letter-frequency layer of text is, literally, reading the source code of the message in a way that the writer didn’t put there on purpose. The wiki claim was right about this. It just framed the phenomenon through anagrams when it should have framed it through cryptanalysis.

3. Sub-semantic channels: what the substrate actually carries

Letter frequencies are the boring part of the substrate. The interesting parts are the ones where the sub-semantic structure appears to carry actual meaning-tinted information, not just statistics.

Phonosemantics and sound symbolism

The textbook example is the bouba/kiki effect, first observed by Wolfgang Köhler in 1929 and rediscovered repeatedly since (most famously by Ramachandran and Hubbard in 2001). Show a subject two shapes — one rounded and blobby, one sharp and spiky — and ask which one is called “bouba” and which is called “kiki.” Across languages, across age groups, even across cultures that don’t use roman letters, something like 95% of subjects assign “bouba” to the rounded shape and “kiki” to the sharp one. The shapes have no inherent names. The sounds are not “really” round or sharp. But the cross-modal association is robust to the point of being one of the most replicable findings in experimental psychology.

The mechanism, as best as anyone has been able to nail down, is some combination of articulation gesture (lip rounding for “bouba,” tongue pointing for “kiki”) and high-frequency / low-frequency acoustic content. The point for our purposes is that the sounds themselves carry semantic associations, prior to and independent of any linguistic convention.

Phonesthemes

A phonestheme is a sub-morphemic sound cluster that carries meaning across a family of unrelated words. English has several. The cluster gl- at the start of a word leans visual, often to do with light or sight: glow, gleam, glint, glitter, glance, glare, glimpse, glisten. The cluster sn- at the start of a word leans nasal: sniff, snore, snort, sneeze, snout, snot, snarl. The cluster sl- leans toward smoothness or unpleasantness or both: slip, slide, slick, slime, sludge, slop, slush. The cluster -ump leans toward roundness or impact: bump, lump, hump, dump, jump, slump, clump, stump, thump, rump.

None of these are absolute. Plenty of gl- words have nothing to do with light (gland, glue, glib). The claim is statistical, not categorical: the cluster shifts the probability distribution of meanings the word will carry, and brains pick this up. Margaret Magnus’s PhD thesis (1999, University of Trondheim) catalogued English phonesthemes systematically and argued that they are sub-morphemic semantic carriers that can be exploited deliberately by writers and that are exploited unconsciously by language drift.

The wiki page was, in a hand-wavy way, gesturing at exactly this kind of phenomenon. The technical literature was already considerable when I wrote it. I hadn’t read enough of it.

Rhythm, meter, and persuasion

The substrate also shows up in prosody. Iambic pentameter is not magic, but the fact that English speeches and slogans skew strongly toward stressed-unstressed alternation is not coincidence either. The “rule of three” in rhetoric — life, liberty, and the pursuit of happiness; of the people, by the people, for the people; veni, vidi, vici — is older than English itself and crosses every Indo-European language. Try replacing any of those with a two-clause or four-clause version and the difference in memetic stickiness is immediate and brutal. The substrate cares about rhythm. Brains are entrainment machines and stickiness rides on entrainment.

The cumulative point is that language carries information on a sub-semantic channel that includes letter frequencies, phonemic clusters, sound-symbolic associations, and rhythmic structure. The channel is real, it has been characterised in the linguistics literature for nearly a century, and it does load-bearing cognitive work that readers are not consciously aware of. The wiki page wasn’t inventing this. It was rediscovering it through a particular lens (anagrams) that happened to be a sideways view of the underlying phenomenon.

4. How LLMs ended up doing this on purpose

A transformer language model is trained, mechanically, to do exactly one thing: predict the next token, given the previous tokens. The training corpus is some enormous slice of human-generated text. The loss function is cross-entropy on the next-token distribution. There is no semantic objective. There is no fact-checking. There is no “understanding” in any of the senses philosophy of mind has been arguing about for a century. There is only fit the next-token distribution as well as possible given what came before.

The architecture is descended from a chain of older statistical language models. The lineage goes roughly:

Markov chains (1906) — sample the next character or word from a distribution conditioned on the previous one.
n-gram models (Shannon 1948, then many) — condition on the previous n-1 tokens.
Class-based language models (Brown et al. 1992) — cluster words into classes so the conditioning is on the classes, not the tokens.
Neural language models (Bengio et al. 2003) — replace the count-based conditional with a small neural network.
Word embeddings (Mikolov et al. 2013, Word2Vec) — represent words as vectors in a space where geometric relations encode semantic relations.
Sequence-to-sequence with attention (Bahdanau et al. 2014) — let the model focus on different parts of the input dynamically.
Transformers (Vaswani et al. 2017) — drop recurrence; everything is attention.

Each step in that chain increased the order of statistical conditioning the model could capture. A bigram model conditions on one previous token. A 5-gram model on four. A transformer with a several-thousand-token context conditions on thousands. And — this is the load-bearing observation — when you make the conditioning long enough and rich enough, things that look like reasoning, planning, analogy, and even mild self-awareness fall out of the model. None of them were explicitly trained for. They emerge from optimising the next-token distribution well enough on enough text.

This is exactly the result the wiki page predicted. Not in the way I expected — I imagined some hand-crafted “meme-worthiness scorer” that explicitly modelled phonesthemes and letter frequencies, and what actually happened was a brutally simple architecture that learned all of that and a lot more by gradient descent on next-token prediction over a few terabytes of human-generated text. But the structural claim is the same. The cognitive content of language is largely carried by statistical patterns over tokens. A sufficiently large machine trained on enough of that statistical structure can produce text that exploits the same channels readers exploit unconsciously when producing or evaluating their own.

5. What LLMs validated, and what they didn’t

The wiki claim broke into a strong form and a weak form. The strong form was something like anagrams have inherent meaning. The weak form was the statistical substrate of language carries cognitive weight that brains pick up without conscious awareness.

LLMs have decisively validated the weak form. They produce text that humans rate as compelling, persuasive, emotionally resonant, and sometimes even insightful, using nothing but the statistical structure they extracted from training data. The compellingness is not a semantic add-on. It rides on the same channels. If it were purely semantic, an LLM with no model of truth, agency, or world state could not produce compelling text. They obviously do.

LLMs have also surfaced a related fact that the wiki claim did not anticipate: the substrate is not just letter-frequency or phoneme-cluster. It is the full sequence-conditional distribution. Transformer attention learns long-range dependencies between phrases many sentences apart, between turn-taking patterns in dialogue, between rhetorical-figure setups and payoffs, between argument structures, between voice registers. The “fabric” the wiki page named in passing turned out to be far richer than the letter-frequency diagnostic suggested. The patterns include letter frequencies, yes, but also bigram-and-up structures, syntactic templates, rhetorical moves, narrative arcs, and stylistic signatures. All of it is in the statistics. The wiki claim was right that the substrate existed; it was wrong about how thick the substrate is. It is far thicker than I imagined.

The strong form — anagrams as a Rosetta Stone — LLMs have not validated and probably never will. Anagram structure is one projection of the underlying frequency distribution. It contains some information about the source but not in the way I was reading it. The “emotional synesthesia” I felt when scoring anagrams was almost certainly me feeling the underlying phonesthemic and rhythmic structure of the source phrase, channeled through the anagram-shaped filter I was applying. The filter was incidental. The signal was real.

6. Implications: what to do with a validated substrate

Once you grant that the substrate exists and that machines can now explicitly operate on it, several things change.

Content optimisation as substrate exploitation. Every recommendation algorithm running on social platforms today is performing a version of the “meme-worthiness scorer” the wiki page called for. The mechanism is not that they explicitly score phonesthemes; the mechanism is that they score engagement, which correlates with the deeper substrate properties because engagement is the substrate’s signature in human behaviour. The platforms are strip-mining the substrate without knowing it has a name. The 2014 proposal has been built, badly, by every company whose business depends on attention.

Prompt engineering as deliberate substrate operation. The discipline that has emerged around “prompting” LLMs is, in a real sense, the consciously-engineered version of what skilled writers were doing instinctively before. A prompt that reliably produces a certain register, voice, or argument structure is one that activates the right region of the substrate. People who are good at this often report that they can “feel” when a prompt will work before they run it — the same feeling skilled writers report. The substrate is the same; the target machinery has changed.

Adversarial substrate exploitation. If statistical patterns in text affect human cognition below conscious awareness, then a sufficiently large model that learns those patterns can produce text deliberately tuned to particular cognitive vulnerabilities. This is not hypothetical. The combination of generation (LLMs that can produce convincing copy on demand) and targeting (platforms that can deliver custom-tuned copy to specific subpopulations) and iteration (automated A/B testing of message variants) is industrial-scale substrate exploitation. There has been no equivalent in the history of communication. The printing press could only mass-produce one copy at a time; this can mass-produce a million variants. Whether that turns out to be a slow disaster or a tolerable nuisance depends on defences that we are nowhere near ready to deploy.

Defensive substrate awareness. The cleanest defence is the same one that works against any cognitive bias: knowing the mechanism exists weakens its effect. People who know that mortality salience biases their political judgments make better political judgments under mortality salience. People who know that a piece of copy was produced by an LLM tuned for engagement read it more skeptically. The substrate cannot be removed — it is the same substrate that makes language work at all — but its exploit cases can be recognised and discounted. Memetic hygiene becomes a thing you can teach.

7. The intuition’s place in the genealogy

A small note on credit. I am not claiming I “predicted” LLMs in any serious sense. The component ideas — that statistical structure matters for cognition, that language has sub-semantic channels, that machines could in principle be built to operate on those channels — were in the literature in scattered form when I wrote the wiki page. I hadn’t read them. What I did was hit on the structural insight from a sideways angle (anagrams), state it loosely, and intuit a research program (the “meme-worthiness scorer”) that nobody, including me, built.

Then a different research program — neural language modelling, scaled absurdly, with no theoretical commitment to substrates or phonesthemes or anything else other than next-token prediction — happened to materialise the same observation as a working artifact. The artifact is more general than what I imagined; it confirms the structural claim while being silent on the diagnostic I was using.

I write this up partly because it’s gratifying when a hunch turns out to have been pointing at something real. But mostly because the structural lesson seems worth holding onto. When you notice a pattern that nobody else is talking about, even if your diagnostic for it is wrong, write it down. The diagnostic can be corrected later. The pattern, if real, will eventually be hit by some unrelated research program from another direction, and your having written the hunch down will save you (and others) the time of re-deriving it.

8. What’s next on the substrate

LLMs settled the question of whether the substrate exists and whether it can be operationalised. The open questions now are quieter and deeper.

What other latent dimensions of language carry cognitive weight that we haven’t named yet? Phonosemantics, rhythm, and frequency are the ones we have. There are surely others. Some are likely to be visible to scaling laws and emergent capability studies in larger models. Some may require new instruments.

How much of human cognition is itself the substrate? The honest implication of the LLM result is that a substantial fraction of what we experience as our own thinking is statistical pattern completion over linguistic input. This is uncomfortable. It is also probably true to first order, and the question is how to live with it without either collapsing into nihilism or pretending it isn’t so. The neuroscience says the same thing from another direction (predictive processing, Bayesian brain, free-energy principle). Two literatures converging on the same uncomfortable conclusion from independent directions usually means the conclusion is right.

Can the substrate be inoculated against? See the defensive substrate-awareness discussion above. The early signs are that yes, partially, with effort. The economics work against the defence; the production side is industrialised, the defence side is artisanal. Closing that gap is one of the more important communication-design problems of the next decade.

What happens when LLMs train on LLM output? This is the distinctively-new problem. Once a meaningful fraction of training text is itself generated, the model is learning the substrate’s image of itself rather than the substrate as humans produced it. The fixed points of that recursion are not the same as the fixed points of the original substrate. We are running this experiment globally without much instrumentation. I have no clean prediction for how it ends.

I’ll close where I started. The wiki page in 2014 (or thereabouts) was written in rough prose, with several typos and at least one bad diagnostic. The structural claim was correct: language has a substrate of statistical pattern that does cognitive work, the substrate is exploitable, and a sufficiently large machine could be built to operate on it. That machine got built. It works. It is already changing the politics of attention more than the printing press did.

Anagrams turned out not to be the right window into the substrate. But the substrate was there, and somebody — though not me — has now built the equivalent of an x-ray for it. The next few years will be about deciding what to do with the x-ray. I think the answer involves more substrate awareness, not less. The frame the mimetics essay set up still applies: knowing the mechanism is half of being able to defend against it.

The other half is harder.

If Water Were the Computer: A Speculation

2026-05-29T01:30:17.803-07:00

If Water Were the Computer: A Speculation

Companion to The Weirdness of Water. Where that piece was careful empirical reporting, this one is openly speculative. Read it as a thought experiment, not a claim.

In the previous essay I argued that water is constitutive of life — not merely the solvent that biochemistry happens in, but the medium whose preferences (hydrophobic effect, dielectric screening, hydrogen-bond geometry) shape what biochemistry is possible at all. That framing kept agency on the side of the biology: life uses water, life evolves under water’s constraints. Standard story.

The thought experiment in this essay flips the agency. What if water is running the computation, and biology is the output? What if the hydrogen-bond network of liquid water — a labile, picosecond-dynamic, graph-structured medium of Avogadro-scale parallelism — is a substrate on which some kind of physical information processing happens, and what we call evolution is the long-time projection of that processing into chemistry that stabilises particular outcomes? In this telling, water did not “make life possible” so much as life is one of water’s stable orbits.

I am not asserting this. I want to walk it through carefully, because the parts that are clearly nonsense are easy to point at, and the parts that are not clearly nonsense are interesting enough to deserve a real essay.

1. Stating the hypothesis precisely

Let me lay out the speculation in as specific a form as I can, so we can see where the load-bearing assumptions are:

Premise 1. Liquid water is a network of ~10²² hydrogen bonds per millilitre, rearranging on a timescale of ~1 picosecond, governed by local rules (the “ice rules” — each oxygen donates two and accepts two hydrogen bonds) plus thermal noise.
Premise 2. This network has the right formal structure to support computation in the loose sense — graph-rewriting on a constrained tiling, with energy gradients steering the dynamics.
Premise 3. At biological temperatures and pressures, quantum effects (proton tunneling, vibrational coherence, possibly nuclear spin coherence) persist on the relevant timescales in specific microenvironments inside cells.
Premise 4. A subset of these quantum effects are not noise, but contribute load-bearing computation to processes that biology has evolved to exploit.
Conjecture. The same medium that hosts those quantum effects, and the same global network that those effects are embedded in, is performing information processing of a kind we have not yet characterised. Evolution is the slow, large-scale shadow of that processing on the genome.

The conjecture is the speculative bit. Premises 1-3 are mainstream-ish (I will defend Premise 3 below). Premise 4 is partially mainstream (in photosynthesis it is essentially conceded) and partially contested (elsewhere). Premise 4 plus the conjecture is the move that takes us from quantum biology — which is real and credentialed — to something much stronger.

If the conjecture is true in any meaningful sense, “water chose to evolve” is not a category error. It is the statement that the network’s computation prefers certain outcomes, and biology is one of the attractors.

2. Why water is the only plausible candidate

If you wanted to design a molecular substrate for warm, wet, Avogadro-scale parallel computation, you could not do much better than liquid water.

A networked medium with hard local constraints. The ice rules give the hydrogen-bond graph a constraint topology that resembles, more than it resembles anything else, a frustrated lattice. Frustrated lattices in condensed matter are exactly the systems that exhibit non-trivial low-temperature collective behaviour — spin liquids, spin ices, emergent gauge fields. The Bernal-Fowler ice rules have the same form as the constraints in spin ice, where they give rise to magnetic monopole excitations. Whatever else liquid water is, formally it is a frustrated network whose dynamics are not trivial.

A picosecond clock. Hydrogen bonds break and reform on the order of 10⁻¹² seconds. That is a gigahertz natural clock rate at room temperature, achieved without any external driver. Compare to silicon at room temperature: thermal noise dominates anything you try to compute below ~k_BT, which is ~25 meV — about an order of magnitude less energy than a single hydrogen bond.

Quantum effects survive. Proton tunneling is documented in enzymatic catalysis and in ice itself. Vibrational coherence between chromophores in the Fenna-Matthews-Olson photosynthetic complex was demonstrated to persist for hundreds of femtoseconds at 277 K (Engel et al., Nature, 2007), and the original interpretation that this is load-bearing in photosynthetic efficiency has been refined but not abandoned in the years since. Radical-pair coherence in cryptochrome, the molecule implicated in avian magnetoreception, requires that electron spin coherence survive long enough — on the order of microseconds — for a few-microtesla magnetic field to perturb the reaction outcome. This is genuinely strange and has held up under twenty years of probing.

Avogadro-scale parallelism. A teaspoon of water is ~10²³ molecules. Even if only one in a trillion is doing something computationally interesting at any moment, that is still ~10¹¹ parallel operations per teaspoon per picosecond. Conventional silicon, scaled to the same volume, manages perhaps eleven orders of magnitude less.

Interfaces do something. Pollack’s exclusion-zone work, which I treated with extreme skepticism in the first essay, does report a real and reproducible observation at hydrophilic interfaces: a hundreds-of-micrometres-thick region of water that excludes solutes and has slightly different properties. The mainstream explanation is electrokinetic, not a “fourth phase,” but the underlying empirical fact — that water near a structured surface organises itself in a way that propagates a long way into the bulk — is real. Armstrong’s water bridge is another such observation. The Strano group’s CNT results are a third. Whatever is happening at water/surface interfaces, it is not the same as bulk water.

You do not have to believe any of this implies consciousness. You only have to grant that water’s hydrogen-bond network is a non-trivial computational substrate by any reasonable definition of “computational substrate.”

3. Real quantum biology, and where water actually is

The strongest empirical support for any version of this thought experiment comes from quantum biology, a field that did not exist under that name until about 2007 and which now has its own journals, conferences, and grant pipelines.

Photosynthesis. The Fenna-Matthews-Olson (FMO) protein in green sulfur bacteria channels excitations from light-harvesting antennas to the reaction centre. The original 2007 result by Greg Engel, working in Graham Fleming’s group at Berkeley, showed that the energy transfer is not classical hopping but involves quantum coherence — the excitation explores multiple paths simultaneously and the system selects the most efficient one by wave interference. The 277 K coherence lifetime was unexpectedly long. Subsequent work (Cao, Cheng, and others) refined the picture: the coherence is partially environment-assisted, with the protein and its surrounding water tuned to neither destroy the coherence too fast nor preserve it so long that it traps in a local minimum. Photosynthetic organisms appear to have evolved a Goldilocks decoherence rate.

Cryptochrome and magnetoreception. European robins navigate by the geomagnetic field, and the orientation behaviour is wavelength- dependent in a way that points to a light-induced radical pair in the eye. The molecule is cryptochrome; the mechanism, originally proposed by Schulten in 1978, was that an electron transferred from one part of the molecule to another produces a transient radical pair whose nuclear-spin-coupled triplet/singlet ratio depends on the ambient magnetic field. The reaction yield therefore depends on the field direction. Modern work (Hore, Mouritsen, and collaborators) has made this picture quantitative; in 2021, Xu et al. demonstrated the field sensitivity in vitro with cryptochrome 4 from migratory robins, and showed it was absent in non-migratory chickens.

Enzymatic tunneling. Many enzymes catalyse reactions by allowing hydrogen nuclei to tunnel through activation barriers rather than go over them classically. The signature is a kinetic isotope effect larger than what the classical Eyring equation allows. Soybean lipoxygenase, alcohol dehydrogenase, dihydrofolate reductase — all have documented tunneling contributions. The picture that has emerged is that proteins position substrates with sub-angstrom precision such that the tunneling probability becomes biologically useful, and that this positioning is achieved partly through coupling to picosecond protein motions.

Where is the water in all this? Everywhere. The FMO complex sits in a hydrated environment; the cryptochrome radical pair is surrounded by structured water near its binding pocket; the enzymatic tunneling reactions all happen in solvated active sites where the local water network is a non-negligible part of the reaction coordinate. The mainstream view is that the protein is doing the work and water is the bath; the speculation in this essay is that this division is wrong, or at least incomplete, and that the water network is doing more than absorbing heat.

4. Penrose-Hameroff and the credibility budget

The most famous (and most criticised) attempt to ground consciousness in physics is Roger Penrose and Stuart Hameroff’s Orchestrated Objective Reduction (Orch-OR) theory. The proposal, dating from the mid-1990s and refined since, is that consciousness arises from quantum-coherent computation in microtubules inside neurons, “objectively reduced” by Penrose’s interpretation of gravity-induced wavefunction collapse.

The mainstream response, distilled charitably, is: the gravitational mechanism is unmotivated and untestable, the microtubule decoherence times calculated by Tegmark (2000) are absurdly short compared to neural timescales, and the entire framework has the smell of solution-in-search-of-a-problem. Penrose and Hameroff have answered each of these objections, the answers are not universally convincing, and the theory sits in the credentialed-but-fringe category.

Why mention it here? Because Orch-OR is the existing structure most similar to the speculation in this essay, and because the non-fatal version of its argument — that biological systems might host load-bearing quantum coherence at biological temperatures — has held up better than the specific microtubule claim. The fight has moved. In 2024, work by Jack Tuszynski and others reported optical evidence of long-lived superradiance in microtubules, which does not prove Penrose right but does prove that the question is not closed.

If you take the position that the universe permits warm, wet biological quantum computation at all — and quantum biology has forced you to take that position, whether you wanted to or not — then the question becomes which substrate, where, and on what scale. The microtubule answer is one possibility. The hydrogen-bond network of intracellular water is another. They are not exclusive, and indeed they are not separable, because the microtubule interior is itself a structured-water environment with reported anomalous properties.

5. What would it mean for water to “choose”?

Here is where the speculation gets sharpest, and where I have to be most careful.

The weak reading of “water chose to evolve” is that water’s physical properties acted as such a powerful selection pressure on prebiotic chemistry that the trajectory of life on Earth was very strongly funnelled by them. This is the anthropic principle, essentially, and it is uncontroversial — except in its strong forms. The hydrophobic effect requires lipid membranes to compartmentalise. The dielectric constant requires ion-gradient bioenergetics to be possible. The density anomaly requires aquatic ecosystems to be possible. Knock out water’s specific package of anomalies and the design space of possible biospheres shrinks dramatically.

The strong reading is that water performs some form of computation whose long-time average prefers certain biochemical configurations over others, and that this preference is not just thermodynamic but informational. In this reading, the “fitness landscape” that evolution climbs is partially generated by the water network, not just by selection on replicators. Different mutations would have different effects not only because of their classical chemistry but because of how the surrounding water network “computes” with them — preferring certain conformations, opening certain reaction channels.

I do not know how to make the strong reading precise enough to test. That is the honest answer. But here are some forms it might take:

Reservoir computing. The water network around a protein might function as a reservoir computer — a high-dimensional dynamical system whose transients project the protein’s local degrees of freedom into a much larger state space, where decision-making becomes easier. Reservoir computing is a real and well-studied paradigm; whether biological water actually does it has not been tested.
Quantum sampling. Coherent superpositions of hydrogen-bond configurations might let the water network sample conformational space faster than classical thermal exploration would. This is the “quantum walk” idea from FMO applied at the water-network scale.
Information geometry. The hydrogen-bond graph at the surface of a protein might encode information about the protein’s function in a way that is not encoded in the protein’s sequence. This would predict that proteins with similar sequences but different surface hydration networks would have measurably different binding kinetics — which is, in fact, observed, although the mainstream explanation is “specific water-mediated contacts” rather than network-level computation.

None of these are tested in the strong form. All of them are testable in principle. That distinguishes them from the unfalsifiable end of the speculation pool.

6. Predictions and falsifiability

For an essay that is openly speculative, this section is the most important. If the speculation in this essay is right in any specific form, what would we expect to see?

Decoherence-tuning across phyla. Quantum-biology systems should show evidence of being tuned — neither too fast nor too slow — and that tuning should track phylogeny in a way that reveals selection pressure. (Partly observed in FMO across green sulfur bacteria.)
Anomalous information capacity in hydration shells. Two proteins with identical sequences but different ortho/para water environments, or different isotope composition (H₂O vs D₂O), should have different functional behaviour beyond what classical kinetic-isotope-effect calculations predict. Some D₂O / H₂O substitution experiments do show effects larger than KIE would account for; the standard explanation is solvent dynamics, but the speculation here would predict the magnitude differently.
Long-range correlations in cell-volume water. A cell is mostly water, and the speculation predicts that water in cytoplasm should show coherent dynamical correlations on length scales larger than the bulk Debye length. Femtosecond spectroscopy in cytoplasm vs buffer is an experiment that can be run today.
Distinct quantum signatures in cancer cells. A wilder prediction: cells whose proteomic and metabolic state has been disrupted might show measurable differences in their hydration coherence relative to healthy cells. This is the kind of claim that gets exploited by quacks selling test kits; doing it properly requires the same kind of careful blinded protocols that quantum biology has been forced to adopt.
The Mpemba effect revisited. If water has any kind of information-bearing internal state, the Mpemba effect could be the thermodynamic shadow of preparation-dependent network configurations. A specific prediction: the Mpemba effect should be stronger in solutions of biopolymers than in pure water at the same dissolved-gas content. This is testable.

The point of listing falsifiable predictions is to distinguish this speculation from the unfalsifiable cousin claims that water has “memory” or “vibrational consciousness.” A real speculation should either die or get refined when contact is made with experiment.

7. Adjacent woo to not be confused with

Because the surface vocabulary overlaps, I want to be explicit about what this thought experiment is not.

Not Masaru Emoto. Emoto’s claim — that water exposed to “loving words” forms beautiful crystals on freezing while water exposed to “hateful words” forms ugly ones — is unblinded, unreplicated, and incompatible with the picosecond rearrangement time of the hydrogen-bond network. There is no mechanism by which liquid water at room temperature could retain a memory of an emotional stimulus applied to its container.

Not Pollack’s “fourth phase.” I cited the EZ observation as a hint that water at interfaces does something interesting structurally. I did not endorse the interpretation that this is a new phase of water with healing properties, and the broader health claims continue to fail independent replication.

Not homeopathy. Water memory in the Benveniste sense — claiming that dilution past the point where any solute molecule remains can still produce a pharmacological effect — is incompatible with straightforward physics and chemistry and has not survived blinded replication.

Not “structured water” supplements. Devices that vortex, magnetise, or otherwise treat tap water and sell it as “structured” or “hexagonal” are exploiting the real complexity of water dynamics for marketing purposes. Whatever might or might not be true about information processing in cellular water cannot be replicated by running tap water through a magnet.

The speculation in this essay is that the cellular hydrogen-bond network, in coupling with biomolecular machinery that evolved over four billion years to exploit it, might be doing computational work we have not characterised. Nothing about that speculation justifies buying $40 spring water that has been “energised” by a quartz crystal.

8. What this would change, if true

Suppose the speculation is right in some specific, testable form — say, that biological water networks function as reservoir computers and that protein function depends measurably on this. What changes?

Drug design changes. Currently we design drugs to fit a protein’s binding pocket and to be soluble enough to deliver. We do not design them with respect to the local water network’s computational state. If proteins are partially functioning through their hydration shells, then small-molecule design that ignores the water network is leaving something on the table — and with respect to which a chiral drug might have a non-classical effect that no traditional QSAR captures.

Evolution looks slightly different. We currently model fitness as a function of phenotype, which is a function of genotype-expressed-as- protein. If hydration networks add a layer in between — fitness as a function of phenotype-as-water-network-modulated-protein — then the fitness landscape gets new structure that was previously invisible. Some “neutral” mutations might not be neutral at the water-network level.

Origin-of-life questions get a new flavour. The Miller-Urey-style story of life originating in primordial soup involves water as the medium. If the medium is actively computing, then the question “why did life arise in water” gets a different answer: because water was already running the appropriate computation and biology was a way to stabilise it.

And the deeper question — why this universe is configured so that water (and therefore life) is possible — gets, at least, a different frame. Not “anthropic principle: we observe a life-supporting universe because only those universes have observers” but “computational principle: information-processing media bootstrap their own propagation through whatever chemistry is available.”

I want to emphasise once more: I do not know whether any of this is true. I have laid it out carefully because it is the form of the speculation that could be true, given what we already know about quantum biology and water dynamics, and because that form is far more interesting than the marketing version.

Closing

The honest answer to “is water a quantum computer that chose to evolve” is probably not, in any literal sense. The honest answer to “is the hydrogen-bond network of cellular water performing non-trivial information processing that biology has co-opted” is we do not know yet. Quantum biology forced the question open. The answers are not in.

The thought experiment is useful because it pushes back on the polite mainstream framing that water is merely the solvent. If photosynthesis is exploiting quantum coherence, if avian magnetoreception is exploiting radical-pair coherence, if enzymatic catalysis is exploiting tunneling — and the medium hosting all of those phenomena is the same hydrogen-bond network — then the question of what else that network is doing becomes legitimate.

We may end up concluding that water is a passive bath after all, and that what looks like network-level computation is just the sum of local effects. Or we may end up with a richer picture in which the network itself is part of the story. Both endings are interesting. What is not interesting is the version of the question that gets sold in a bottle.

I wrote the first essay to defend water against the marketing. I wrote this one to defend the genuine speculative question against the same marketing. They are different defences but they have the same enemy: the comfortable certainty that there is nothing left to think about here, in either direction.

Comments, corrections, refutations welcome. Especially refutations.

References and further reading

Engel, G. S. et al. “Evidence for wavelike energy transfer through quantum coherence in photosynthetic systems.” Nature 446, 782-786 (2007). The FMO result.
Lambert, N. et al. “Quantum biology.” Nature Physics 9, 10-18 (2013). A readable overview of the field as it stood after FMO.
Tegmark, M. “Importance of quantum decoherence in brain processes.” Phys. Rev. E 61, 4194 (2000). The standard criticism of Orch-OR.
Hameroff, S.; Penrose, R. “Consciousness in the universe: A review of the ‘Orch OR’ theory.” Phys. Life Rev. 11, 39-78 (2014). Hameroff and Penrose’s own restatement.
Tuszynski, J. A.; collaborators. Recent superradiance work in microtubules, late 2010s onward.
Xu, J. et al. “Magnetic sensitivity of cryptochrome 4 from a migratory songbird.” Nature 594, 535-540 (2021). The robin cryptochrome result.
Hore, P. J.; Mouritsen, H. “The radical-pair mechanism of magnetoreception.” Annu. Rev. Biophys. 45, 299-344 (2016).
Klinman, J. P.; Kohen, A. “Hydrogen tunneling links protein dynamics to enzyme catalysis.” Annu. Rev. Biochem. 82, 471-496 (2013).
Bernal, J. D.; Fowler, R. H. “A theory of water and ionic solution, with particular reference to hydrogen and hydroxyl ions.” J. Chem. Phys. 1, 515 (1933). The original statement of the ice rules.
Castelvecchi, D. “Quantum effects bring a strange twist to biology.” Nature 619, 18-20 (2023). Status report on the broader field.
Cao, J. et al. “Quantum biology revisited.” Sci. Adv. 6, eaaz4888 (2020). The mainstream’s current view of where the strong claims and weak claims stand.

Mimetics: The Third Replicator

2026-05-29T01:24:42.670-07:00

In 1976 Richard Dawkins, in the closing chapter of The Selfish Gene, coined the word meme to name a unit of culture that copies itself between minds the way a gene copies itself between bodies. The proposal was deliberately analogical. Dawkins was making a structural argument: wherever you have heritable variation, differential fitness, and a copying mechanism, you get evolution by natural selection, and the substrate doesn’t have to be DNA. Cultural ideas — tunes, catchphrases, fashions, religions — satisfy the criteria. So they evolve.

Twenty-some years later, Susan Blackmore took the framework and pushed it one more step. In The Meme Machine (1999) and in a 2008 TED talk that I keep coming back to, she argued that the Internet plus silicon constitutes a third class of replicator she called temes: units of information that copy themselves not between minds (memes) or between bodies (genes) but between machines. “Earth now has three replicators,” she wrote, “genes (the basis of life), memes (the basis of human culture) and temes (the basis of technology). I argue that the information copied by books, phones, computers and the Internet is the beginning of this third replicator and consequent new evolutionary process.”

I want to take Blackmore one step further. The unifying concept across genes, memes, and temes is not the substrate — DNA, neuron, silicon — but the act of copying. The Greek word for that act is mimesis. The right name for the meta-framework that encompasses all three substrates is mimetics: the study of self-replication or copying in any system. Memetics is a subset of mimetics. So is genetics. So, in the long term, will be whatever we end up calling the study of machine-replicated information. That extension is mine, and the rest of this essay is what falls out of it.

1. Mimetic versus memetic — a distinction worth keeping

The English words are confusingly close.

Mimetic (mə-met-ik) is the adjective form of mimesis, from the Greek μίμησις, “imitation.” It’s an old word. It shows up in Plato’s Republic — mimesis contrasted with diegesis, imitation versus narration. In biology it names a category of phenomenon: a stick insect is mimetic of a twig; a hoverfly is mimetic of a wasp. The adjective applies to anything that resembles, imitates, or copies something else by any means.

Memetic is the adjective form of meme, the much younger word that Dawkins built specifically to parallel gene. A unit of cultural inheritance: a tune you can’t get out of your head, a turn of phrase that propagates because it’s catchy. Memes are idea-shaped by definition. The substrate is the mind, the carrier is communication.

The two words overlap because all memetics is mimetic — a meme is, by definition, a copied idea — but not all mimesis is memetic. DNA copying itself is mimetic but not memetic. A 3D printer cloning its own gears is mimetic but not (yet, quite) memetic. Mimicry in biology is mimetic and is, in a particular sense, adversarial memetics played out at the species level: the harmless butterfly that copies a poisonous one’s wing pattern is exploiting a meme — the predator’s learned “don’t eat this” association — by faking the carrier.

The distinction matters because the moment you grant that copying-as- such is the unit of analysis, you can stop arguing about whether something is “really” a meme or “really” a gene and start looking at the structural commonalities. Every act of mimesis has the same ingredients: a source, a copy, a copying mechanism, an error rate, a payload, and a selection environment. Different substrates differ in the details. The structure is the same.

2. Blackmore’s third, and what comes after

Dawkins gave us two replicators. Blackmore gave us three. The provocation in Blackmore’s framing is that temes are no longer running on human brains. Once Wikipedia, search engines, image recognition, and now large language models exist, the substrate has moved off neural tissue and onto silicon. The replicator and the host are no longer the same kind of thing. A meme needed a human to remember it. A teme can be remembered, mutated, and propagated by a process that no human is in the loop of.

You can be cheerful or apocalyptic about this. Blackmore tends toward the apocalyptic — her line was that we are now the second-class citizens of our own information ecology, the way bacteria became the second-class citizens of theirs after multicellular life evolved. I’m less certain. The fact that machine-mediated copying has its own dynamics doesn’t necessarily imply that the dynamics are worse. It implies they are different, and that the toolkit we built for analyzing memes — designed for human-to-human transmission — needs revision.

The framework I prefer is this. Across all three replicators we have been gaining error-correcting, memory-extending, selection- imposing infrastructure for thousands of years. Writing was the first big jump — suddenly memes could survive the death of their human hosts, and could replicate across thousands of miles. Printing collapsed the cost of copying. Telegraphy compressed time. Radio and television opened the bandwidth. Each of these enhancements was mechanical in the sense that the medium did not filter or select the content. The printing press would print whatever you gave it. The radio would broadcast whatever you transmitted. The TV would show whatever was on the tape.

Then computers happened. And computer mediation is not content-neutral. The recommendation algorithm filters. The spam-detector filters. The Google ranking algorithm filters. The LLM, more aggressively than any of them, generates and re-generates. We have moved from the era of machine-enhanced memetics, where the machine extended the carrier but didn’t touch the cargo, to the era of computer-enhanced memetics, where the machine is selecting, remixing, and producing memes — not merely transmitting them.

That shift is the most important thing happening to the memetic substrate in the lifetime of anyone reading this. Memes used to evolve by being passed mind-to-mind, with selection pressure imposed by what human brains found memorable. They still do that. But increasingly they evolve by being passed mind-to-machine-to-mind, with selection pressure imposed by what algorithms find clickable. The algorithms have a different fitness function. The result is a different distribution of survivors.

3. External replicators versus self-replicators

A useful structural division cuts across all the substrates: some replicators run on host hardware they do not own, and some replicate themselves all the way down.

External replicators are information bundles that need a host to copy them. Examples:

Viruses, biological. The virus is a payload that hijacks the host cell’s machinery to replicate.
Software viruses and worms. Same trick, different substrate.
Memes in the cultural sense. They need a human brain to copy them. A meme without minds to inhabit is silent.
Most software in general. A program is an external replicator that runs on an operating system that runs on hardware that the software does not itself build.

Self-replicators carry their own copying machinery:

Life, all the way down. A cell makes another cell; eventually, it makes another organism that makes another organism.
Some technologies, increasingly. The Reprap 3D printer was designed specifically to print most of its own parts. A milling machine can in principle make the parts of another milling machine. Industrial robots can assemble industrial robots, given the right parts. Karel Čapek’s R.U.R. (1920), the play that gave us the word robot, had self-replicating robots as its central conceit; Drexler’s Engines of Creation (1986) gave us “grey goo” as the nano-scale version.

The boundary between external replicator and self-replicator is dissolving faster than most discussions notice. A 3D printer plus a copy of its own design files plus enough source plastic is one generation away from self-replication. An LLM plus an environment in which it can take actions and modify its own model is one or two more generations away. Once that boundary closes, the meme/teme/gene distinction becomes harder to maintain — and mimetic becomes the only word general enough to describe what’s going on.

4. Errors, payloads, and the mimetic fabric

Every replicator has an error rate. DNA polymerase makes a mistake about once per 10⁹ bases, with proofreading; without proofreading the rate is closer to 10⁻⁴. A meme transmitted between humans corrupts faster: every retelling drifts. A teme copied between machines can be nearly perfect (a cp command) or can be deliberately lossy (JPEG compression, MP3, an LLM paraphrasing a paragraph).

Errors are the source of variation. Without error there is no evolution, only copying. The whole framework presumes a controlled mutation rate, high enough to generate variants for selection to act on, low enough that information isn’t lost faster than fitness can accumulate.

Every replicator also has a payload beyond its own machinery. A gene codes for a protein. A meme carries an emotional or behavioral charge. A teme carries content. The payload is what gets selected on — the gene that codes for a useful protein is more likely to survive than the one that codes for nothing useful; the meme that makes you laugh and share is more likely to spread than the one that does not. The selection pressure acts on the payload but propagates the replicator.

A nice consequence is the concept of the skeuomorph: an ornament or feature on a copied object that imitates a feature from the object’s older substrate, even though the new substrate makes the feature unnecessary. A wooden ceramic mug with carved “rivet” marks where the wood version had real rivets. A digital camera that emits a fake mechanical shutter click. Slack’s UI inheriting the visual language of IRC. Memes can carry skeuomorphs forward across substrate changes; in fact, almost every meme that survives a substrate change carries some.

5. Memetic engineering — the applied side

You can describe a mimetic system. You can also try to steer one. The applied discipline goes back further than the word for it. Priesthoods knew it. Generals knew it. Advertisers professionalised it. The Wired piece by James Gardner from 1996 — back when “memetic engineering” first hit print in a mainstream venue — captured the disquiet of recognising that culture-as-such might be the product of selfish memes co-evolving “with supreme indifference to their impact on human hosts.” That framing extended Dennett’s earlier provocation in Consciousness Explained: that human minds might be, in some sense, the residue of the memes that have inhabited them.

Memetic engineering is what you do when you treat memes as designable objects. A few of the techniques:

Gaslighting. Not originally a memetic concept — the term comes from a 1938 play and its 1944 film, in which a husband manipulates his wife into doubting her own perceptions by altering small features of the household environment and then denying the alterations. The mechanism generalises far beyond the marital case. Anywhere a meme can be propagated faster than the listener can fact-check it, gaslighting is available. The 21st century version is industrial-scale and runs on the same algorithmic-mediation infrastructure that propagates useful memes; the cost of injecting a corrupt belief is now lower than the cost of correcting it.

Peer pressure as memetic carrier. Pedro Gardete at Stanford looked at 65,525 in-flight purchases across 1,966 flights and found that if the person next to you bought something, your probability of buying something jumped by about 30%. The control was the person sitting in front of you, whose purchase you wouldn’t see. That is a memetic transmission curve measured under near-laboratory conditions in a near-laboratory environment (an airplane seat is hard to escape). Bursztyn and Jensen, separately, showed that when fliers offering a free SAT prep class made it clear that classmates would see who signed up, students in honors classes were 25% more likely to sign up, while students in non-honors classes were 25% less likely. The same announcement, opposite sign of effect, depending on which peer-pressure meme dominated the local environment. Memes don’t act in isolation; they act in competition with other memes already installed in the host population.

Resonance and competition. The classical model — meme as free-floating idea — misses that memes compete for the same neural real estate. A new meme typically has to displace an existing one, or attach to one already present, or fit into a vacancy left by some failed predecessor. The resonance with what is already there is load-bearing. This is why the same message can succeed in one audience and fail in another with no obvious difference between the audiences: their installed memetic base differs.

Computer mediation as compounding factor. All of the above existed before computers. What computers do is speed up the iteration cycle and impose a new selection pressure. The meme that goes viral on a recommendation-driven platform is the meme that maximises that platform’s engagement metric, which is a proxy for “keeps users on the platform” rather than for “true” or “good” or “useful.” The engagement maximisation function favours memes that trigger strong, fast emotional reactions: outrage, fear, tribal affirmation. The system rewards memetic engineering even when no human is doing the engineering on purpose — the platform’s optimiser is the engineer.

6. Language as memetic substrate

Spoken and written language is the original carrier wave for memes, and it has been shaped over hundreds of millennia of co-evolution with the brains that use it. Some properties of language are forced on it by being a memetic carrier subject to error-correcting requirements.

Languages have redundancy. Spoken language has to survive background noise, mispronunciation, and the receiver’s hearing loss. It does this by being redundant: word stress, intonation contours, and context all carry partial copies of the lexical content, so a missing or corrupted word can be reconstructed. Written language has analogous redundancies — fonts have evolved for legibility at distance, spacing and capitalisation carry parallel signals, and famously you can scramble the middle letters of words and still read the sentence:

It deosn’t mttaer in waht oredr the ltteers in a wrod are, the olny iprmoetnt tihng is taht frist and lsat ltteer is at the rghit pclae.

This is not a quirk; it is what the redundancy buys.

Languages have framing. A separate phenomenon: bilingual subjects make systematically different decisions in their non-native language. The classic experiment is the framing of a medical decision in terms of “200 of 600 saved” versus “400 of 600 dead” — same outcome, different framings produce systematically different choices in native-language speakers, and the framing effect diminishes when the same problem is posed in a foreign language. The emotional salience of a foreign language is lower; the framing effect rides on emotional salience; so the framing effect weakens. Implication: a substantial fraction of “rational” decision-making is actually being driven by emotional resonance with native-language framings. The memetic payload is doing more work than the propositional content.

Languages have hidden channels. The provocative claim — and this is mine, in the sense that I wrote it on the wiki years ago and have not seen anyone else state it the same way — is that letter frequency and structure are doing work in parallel to the propositional content. Anagrams, palindromes, reverse-audio in songs, the rhythmic structure of slogans: these aren’t decorations on the message. They are part of the message, on a channel that operates below conscious recognition. Skilled writers and speechwriters feel the channel; you can tell when a phrase “lands” and when it doesn’t, even before you can analyse why. The brain is doing pattern recognition on letter and phoneme distributions in parallel with semantic extraction. The two channels can reinforce or fight each other.

Why suspect this? Because in any sufficiently long-lived memetic substrate, every available channel will be exploited by selection. If letter-frequency patterns subconsciously affect how readers feel about a sentence, then writers whose feel produced emotionally-resonant patterns will out-propagate writers whose feel didn’t, and the language as a whole will accumulate those patterns. You don’t need a conscious mechanism for this to happen; you need only the same Darwinian sieve that operates on every other heritable trait.

This is, frankly, the part of the framework I’d most like to test empirically. A program that scores text on memetic propagation probability — adjusted for letter and phoneme distribution, not just semantics — would be measurable against actual propagation curves on social platforms. I haven’t built one. Someone should.

7. Terror Management Theory, and the memetic exploit

If memes compete for neural real estate, and if some memes activate deeper neural defences than others, then the memes that activate mortality-related defences will dominate.

This is the framework called Terror Management Theory, originating in Ernest Becker’s The Denial of Death (1973) and developed by Greenberg, Pyszczynski, and Solomon from the late 1980s onward. The central claim: humans are the only animals that know they will die, and the conflict between that knowledge and the wish to keep living generates a constant low-grade anxiety that we manage by investing in worldview — cultural narratives that promise some kind of continuation (literal afterlife, symbolic legacy, identification with a group that outlasts the individual).

The empirical bite of TMT comes from mortality salience experiments. Briefly remind subjects of their own mortality — through a questionnaire item, a flashed word too fast for conscious detection, a discussion topic — and their behaviour shifts. Judges asked to set bail for a hypothetical prostitute averaged $50 in the control condition and $455 after a mortality salience prime. White subjects who’d judged a white person’s racial-pride speech as racist rated the same speech as less racist after a mortality prime. Subjects given the opportunity to allocate hot sauce to a person known to dislike spicy food gave dramatically more hot sauce to ideologically opposed targets after mortality salience. The 2004 American presidential election appeared to swing measurably in favour of George W. Bush after death reminders — Kerry won under control conditions, Bush won after the prime, in the same subject pool. Bush represented the status quo worldview; Kerry was a threat to it; under mortality salience, subjects defended the status quo.

From a mimetics standpoint TMT is a vulnerability disclosure. There is a class of memes — death-reminders, mortality cues, threat imagery — that reliably increase the host’s susceptibility to worldview-reinforcing memes. A meme that contains a mortality prime will, in expectation, increase the next meme’s chance of taking root, provided the next meme aligns with the host’s existing worldview. This is exploitable. Of course it has been exploited. The “skulls in the whiskey-ice” subliminal imagery campaigns of the 1970s and 1980s look in retrospect like brute-force memetic engineering. The post-9/11 American political environment looks, in retrospect, like a sustained mortality-salience condition that affected an entire electorate’s susceptibility to a particular memetic payload.

The defence against this kind of exploit is not avoidance of news about mortality — that’s not feasible — but awareness of the mechanism. People who know they are in a mortality-salience state can correct, partially, for the worldview-defence overshoot. The worldview defence is unconscious; bringing it into consciousness weakens it. This is true of most memetic exploits, which is why memetics is, in part, a defensive discipline.

8. Wisdom of the masses — the constructive case

Not all of memetics is exploitation. The crowd-level integration of many noisy individual judgments is one of the genuinely cooperative phenomena in mimetic systems.

Bacteria, of all things, illustrate the principle cleanly. A swarm of bacteria foraging in a complex chemical landscape will, under some conditions, outperform fish or amoeba swarms at finding food and avoiding harm. The mechanism is individually-tuned confidence: when a single bacterium has reliable information about its local environment, it weighs its own signal heavily and the swarm’s signal lightly. When its local information is poor, it weights the swarm more. The result is a swarm that avoids what swarm theorists call erroneous positive feedback, the failure mode in which a small subgroup with wrong information drags the whole population in the wrong direction. (This failure mode is, incidentally, the same one that algorithmic recommendation systems suffer when they overweight early signals.)

Humans do something similar at scale. Tetlock’s “Good Judgment Project” — and its successor work — has documented that small populations of carefully-aggregated forecasters outperform CIA analysts at predicting geopolitical events, in some cases by 30% or more. The mechanism is not that the forecasters individually know more; it is that the aggregation cancels their individual biases. Each neuron in the brain is a bad classifier. The brain as a whole classifies well. Each forecaster is a bad geopolitical analyst. The crowd of forecasters is, when aggregated correctly, a good one.

The constructive case for memetics is that information-mediation infrastructure — Wikipedia, prediction markets, well-designed aggregation systems — can amplify the wisdom-of-crowds dynamic in ways that humanity has not had access to before. The destructive case is that the same infrastructure can amplify cascade failures and exploit the TMT vulnerabilities just discussed. Whether the net is positive or negative depends on design choices that are being made by companies whose objective functions are not optimised for wisdom-of-crowds outcomes.

9. Where this goes: the next replicator

Everything in the framework points the same direction. The substrate-blur is accelerating. We have:

Computer-mediated meme transmission that is filtering, selecting, generating — not merely transmitting.
LLMs that can produce memes more cheaply than humans can. The marginal cost of a new variant is approaching zero.
3D printers and robots that are partially self-replicating.
Algorithmic curation that decides which memes humans see, on timescales no human is in the loop of.

The honest summary is that a fourth replicator is emerging on top of Blackmore’s third, and the substrate is neither minds nor general- purpose machines but specifically algorithmic-aggregation systems that select for engagement against an objective function that no human individually controls. This is not the AGI scenario; it’s narrower and stranger. The selection pressure is no longer “what do human minds find memorable” but “what do the algorithms find engagement-maximising,” and that is a different fitness landscape with different attractors.

The mimetic framework lets us see this without panic. We have been through substrate transitions before. Each one — writing, printing, broadcast — produced a wave of memetic novelty followed by selection that culled most of the novelty and stabilised the rest into a new norm. The current transition is faster and harder to see from the inside, but its structure is not unprecedented.

What is unprecedented is the payload-generation rate. Earlier transitions changed the transmission of memes; this one is changing the production. Memes used to be expensive to produce (a poet, a songwriter, a copywriter) and cheap to transmit. Now they are cheap to produce — an LLM can generate a thousand candidate variants in seconds — and still cheap to transmit. The selection environment is the only bottleneck. Which means selection-environment design is the most consequential mimetic-engineering decision being made anywhere.

10. A short mimetic engineering checklist

If you take any of this seriously, the practical implications come back to a handful of design questions. I’ll close on them, on the theory that abstractions are less useful than checklists.

What is the payload, and what is the carrier? A meme is not the same as the words used to express it. The same payload can be re-encoded across many carriers; the carrier choice changes the propagation curve but not the structural identity. Pay attention to which one you’re optimising.
What error rate are you running at? Too low and you have copies without variation, which means no evolution and no improvement. Too high and you lose the meme entirely. Memetic platforms differ wildly in their error rate; design accordingly.
What is the selection environment? Different platforms select differently. A platform that selects for outrage will not propagate the same memes as one that selects for accuracy.
What is the resonance with installed memes? A meme that has to displace a well-installed predecessor faces a much harder fitness landscape than one slotting into a gap.
What memetic vulnerabilities does it exploit? Mortality salience, peer-pressure cues, framing manipulation, status games, in-group/out-group reinforcement. Most successful memes exploit at least one. Knowing which one is half of being able to defend against them.
What substrate is it crossing? A meme that has to survive a substrate transition (oral to written, written to algorithmic) will accumulate skeuomorphs and shed features. Anticipate which.
What is the meta-meme? Every meme propagates along with the framework people use to interpret memes. The memetic framework itself — the words “meme” and “viral” and “going viral” and “narrative” — is now widely installed in the population. That changes what successor memes can do. Memes are now self-aware in a way they weren’t twenty years ago.
What does the meme do to its host’s epistemic health? Some memes leave the host more capable of distinguishing true from false; some leave the host less capable. Both kinds propagate. Only one of them leaves a population that can be reasoned with later.

The Greek root μῖμος — mimos, “imitator, actor” — was a low- status word in classical Athens. The mimos was a street performer, a copier, a derivative artist. Plato used it disparagingly. Aristotle, characteristically, took it more seriously and noted that all art is mimesis and that mimesis is one of the fundamental operations of human cognition. We are made of copying. We learn by copying. Our institutions propagate by copying. Our genes propagate by copying. The machines we build propagate by copying.

Mimetics is the framework that lets you see these as facets of the same phenomenon rather than as separate disciplines. Genes are slow mimetics; memes are fast mimetics; temes are very fast mimetics; the next layer up will be faster still. The substrate keeps changing; the structure does not. That is what a structural argument is for.

We are leaving the era of machine-enhanced memetics and entering the era of computer-enhanced memetics — the era where the medium selects, filters, and generates rather than merely carrying. The right question to ask of any new memetic infrastructure is the one the framework makes possible: what is its selection pressure, and what does that pressure favour? The answer is the next chapter of cultural evolution. We are writing it now, mostly by accident.

There Are Better Ways to Run AI — And We're Not Using Them

2026-05-27T21:55:53.271-07:00

There Are Better Ways to Run AI — And We're Not Using Them

We are burning an extraordinary amount of power to run artificial intelligence — gigawatts in the data centers, and the last hours of your phone's battery at the edge — and a great deal of it is spent on one habit we never stopped to question. I want to lay out, plainly, why that habit is a choice rather than a necessity, why better ways exist, and why almost no one is pursuing them at the scale the moment deserves. And if any of this resonates, I'd like you to get in touch, because there is more to this than fits in a single piece.

The habit

Every neural network in production today rests on the same operation, repeated trillions upon trillions of times: a floating-point multiply, followed by an add. Matrix multiplication in floating point is the heartbeat of modern AI. The chips are built for it, the data centers are built to feed and cool the chips, and the whole industry has organized itself around doing this one operation faster and faster.

It is worth saying clearly that this was not a foolish choice. Floating-point multiplication won its place honestly. It is smooth and differentiable, which is what made networks trainable in the first place, and the hardware to do it quickly — graphics processors built for video games — happened to already exist when deep learning needed it. The match was lucky and powerful, and it produced the fastest technological transformation most of us will see in our lifetimes.

But a choice made for convenience has quietly hardened into an assumption treated as law: that intelligence must run on floating-point multiplication, and that the only way forward is more of it, faster. That assumption is now being poured into concrete, silicon, and power contracts at a scale of trillions — and it is wrong, or at least far less necessary than the spending implies.

Why it costs so much

The expense hides in two places, and neither is where people usually look.

The first is the operation itself. In a digital circuit, a multiplier is essentially a dense array of adders; the work it does grows with the square of the number of bits involved. An addition grows only linearly. A single bitwise logic operation is nearly free by comparison. Measured at the arithmetic unit, replacing a floating-point multiply-and-accumulate with bitwise logic and a simple count can cut the energy of that step by something like thirty to a hundred times.

The second, and larger, cost is moving the numbers around. In a modern AI chip, more energy goes into hauling weights and activations in and out of memory than into the arithmetic that consumes them — often by a wide margin. This is the memory wall, and it has a crucial consequence: the real prize is not just a cheaper operation, but smaller data. A weight simple enough that the multiply collapses into a sign and a count is also a weight that takes far less space to store, less energy to move, and less bandwidth to transmit. Cut the floating-point multiply properly and you attack the compute bill and the memory bill at the same time.

The edge is where this stops being abstract

At the scale of a data center, inefficiency can be hidden behind money and megawatts. At the edge, it cannot.

On a phone, a watch, a drone, a hearing aid, a remote sensor, a robot, there is no substation and no cooling tower. There is a battery, and a thermal limit set by something you might be holding in your hand. Every joule the model burns is runtime gone and heat you must shed. There is no option to simply supply more power.

So at the edge, efficiency is not a cost optimization — it is the line between the AI fitting on the device at all and not. A model that performs less arithmetic and moves less data runs longer on the same charge, runs cooler, and can stay resident on the device instead of shipping your data off to a server. That last point is a quiet bonus: computation that stays local is computation that is private by construction. For an enormous population of working engineers in mobile, embedded, robotics, and IoT, the power wall is not a future risk — it is the constraint they fight every single day. The float-free approach speaks directly to them.

We already know it can be done

This is not speculation dressed up as hope. Three independent lines of evidence — from biology, from current research, and from working systems — all say the floating-point multiply is optional.

Biology is the existence proof that cannot be argued with. The human brain runs a general intelligence on roughly twenty watts, the draw of a dim bulb. Neurons do not multiply. They accumulate incoming signals and fire when a threshold is crossed, then fall silent; a neuron receiving nothing costs almost nothing. The brain is event-driven and sparse by nature — it does work only where and when there is work to do. That does not prove a brain-like machine is better; aircraft do not flap their wings. But it proves, beyond dispute, that the highest intelligence we know of does not require dense floating-point multiplication. The operation is contingent, not fundamental.

Current research has now shown the same thing in engineering terms. Models built to run on addition instead of multiplication, using severely constrained weights, have reached quality comparable to conventional networks while reporting roughly an order-of-magnitude reduction in inference energy. This is demonstrated for inference, not yet for training at the largest scale — but the wall between "multiplication is mandatory" and "addition is sufficient" now plainly has a door in it.

And working systems have done it on hardware almost laughably weak by today's standards. Float-free, integer and fixed-point, event-driven networks — accumulate-and-fire designs in which the hidden inference path contains no multiplies at all — have run in real time on machines a thousand times less capable than the phone in your pocket. The approach is old enough to have been deployed in earnest decades ago, long before it was fashionable.

What I am, and am not, claiming

I want to be honest about the limits, because the argument is stronger inside them.

I am not claiming floating point is dead, or that these methods have already won. Training the largest models still relies on high precision. I am not claiming that efficiency alone will reduce total energy use — when computation gets cheaper, the world tends to do more of it, and the aggregate bill may not fall. And I am not offering a finished, drop-in product that solves everything tomorrow.

What I am claiming is narrower and still consequential: the floating-point multiply is a choice, not a requirement; dropping it buys power back everywhere; and that matters most exactly where power is scarcest — on a battery that has to last the day, and on a grid being asked to give up cities' worth of electricity and water. The cheapest line item available to this industry is the research into doing the same work with far less power. Against the scale of what is being built, it is a rounding error. On the edge, it is the whole game.

Why I'm writing this

I have spent a long career building efficient systems on constrained hardware, going back to neural networks that ran in real time on machines from the 1980s. I have watched the field arrive, decades later, at conclusions that were reachable far earlier — and I have watched the industry double down on the single most power-hungry way of getting there, just as the costs of that choice are coming due in grids, in water, and in batteries.

I am not trying to sell anything, and I am not asking anyone to stop building. I am trying to point out, to the people making the decisions and the engineers writing the code, that there are better ways — that they are real, that they have history behind them, and that they deserve serious attention before still more capacity is locked into the old assumption.

If any of this lands with you — if you plan power and cooling, allocate research budgets, design for the edge, or simply want to understand why your battery dies the way it does — I would welcome the conversation. There is considerably more to this than I can fit here, including working approaches and decades of hard-won detail. Reach out, and I'll share what I can.

The floating-point habit is not a law of nature. It is a decision we are still free to revisit — and the longer we wait, the more we pay for it, at both ends of the wire.

Research Before Concrete

2026-05-25T16:30:37.883-07:00

Research Before Concrete

Why the cheapest line item in artificial intelligence is the one nobody is funding

The AI industry is committing trillions of dollars to buildings, power, and silicon, and a rounding error to the question of whether the architecture inside them is the right one. That ratio — not the buildout itself — is the mistake.

I. What is being funded, and what is not

There is an extraordinary amount of capital moving through the artificial intelligence industry, and it is worth being precise about where it goes.

It goes into concrete and steel: the shells of data centers, rising across three continents at a pace the construction industry has rarely seen. It goes into power — substations, transmission upgrades, transformers with multi-year lead times, electricity contracts that run for decades, and in a growing number of cases dedicated generation built for a single customer. It goes into silicon: hundreds of thousands of accelerators per large facility, each one a small fortune, replaced every few years. Independent estimates put the cumulative figure in the multiple trillions of dollars across the second half of this decade. It is one of the largest concentrations of private capital expenditure in history.

Almost none of it goes into asking whether the architecture being poured into those buildings is the durable one.

That asymmetry is the subject of this essay. The buildout is, in the end, a bet — a vast, concentrated, physical, multi-year, largely irreversible bet — that the way artificial intelligence computes today is the way it will compute for the economic life of the assets being built. And the research that would tell you whether that bet is sound is being funded at a tiny fraction of the rate of the bet itself. We are paying for the city before we have paid for the survey.

Let me be exact about the claim, because the strength of the argument depends on its modesty. The argument is not that the buildout should stop. Demand for AI computation is real, it is here today, and it must be served on the hardware that exists. The argument is not that the current architecture is wrong — it may well prove durable. The argument is narrower, and I believe it is very hard to refute once stated plainly: research into alternative computing architectures is the cheapest hedge available against the most expensive mistake on the table, and it is currently being treated as an afterthought when the scale of the capital at risk makes it a precondition.

To see why, we need to look at three things in turn: how the present architecture became an unquestioned assumption, how wide the space of alternatives actually is, and what it costs — financially — to be wrong.

II. How a practical choice became an unexamined assumption

Modern artificial intelligence runs, almost in its entirety, on one operation performed densely and at colossal scale: multiply, then add. Matrix multiplication is the heartbeat of every large model in production today. Training a model is matrix multiplication; running it is matrix multiplication; the accelerators are matrix-multiplication engines, and the data centers are buildings designed to feed and cool matrix-multiplication engines. The entire industrial base is an investment in performing one operation faster.

It is important to say clearly that this was not a mistake of ignorance. Multiplication earned its place, and it earned it twice over.

It earned it first through the mathematics of learning. The algorithm at the heart of modern deep learning — backpropagation — requires smooth, differentiable operations, so that an error signal can flow backward through a network and adjust millions or billions of parameters in the right direction. Multiplication and addition over continuous numbers are perfectly smooth and differentiate cleanly. The discontinuous, all-or-nothing operations that a more brain-like system might use are hostile to gradient-based learning. Multiplication was not adopted because anyone proved intelligence must be multiplicative. It was adopted because it was the operation that could be made to learn.

It earned it a second time through a historical accident of hardware. When deep learning began to work — the watershed is usually dated to around 2012 — the ideal hardware for it already existed, built for a completely unrelated market. Graphics processing units, designed to render video-game imagery, happened to be machines for performing dense matrix multiplication in massive parallel. The AI field did not have to wait a decade for someone to design it a substrate. It inherited one, fully formed, along with a software ecosystem that grew up around it. The fit between the algorithm and the silicon was so good that it produced the fastest technological transformation in living memory.

So the choice was correct. Nothing in this essay disputes that. But watch what happened next, because it is the quiet center of the whole problem.

A practical choice — use dense multiplication, because it learns well and the hardware exists — hardened, through a long sequence of individually reasonable decisions, into infrastructure. The infrastructure, in turn, hardened into an assumption: intelligence runs on dense multiplication, so the path forward is more and faster dense multiplication. No one announced this transition. No committee ratified it. It accreted. Each new chip generation, each new data center, each new financial model built on the last, until the industry was planning at the scale of trillions as though the operation itself were a fixed constant of nature, and only its speed and price were left to vary.

You can see the hardened assumption most clearly in the financial models that project the buildout. They are sophisticated documents. They stress-test the cost of power, the price of land, the lead time of transformers, the depreciation schedule of silicon. And almost without exception they carry today's architecture forward across every future year as a given — varying how fast and how cheap that one operation becomes, never whether it remains the operation at all.

That is what an unexamined assumption looks like from the outside: the thing that was once a variable has silently stopped being treated as one. The remainder of this essay is an argument for putting it back.

III. The arithmetic underneath, and the work that need not be done

Before turning to alternatives, it is worth understanding why the current architecture is expensive in the first place — because the expense is not where most people assume.

In a digital circuit, multiplication and addition are not remotely equal in cost. A hardware multiplier is, in effect, a dense array of adders; the work it does grows with the square of the bit width of the numbers involved. An addition grows only linearly. A single bitwise logic operation — an AND, an XNOR — is nearly free by comparison. Measured purely at the arithmetic unit, replacing a full-precision multiply-and-accumulate with bitwise logic and a simple count of set bits is on the order of a thirty- to one-hundred-fold reduction in energy. That figure alone would be reason enough to take alternatives seriously.

But the arithmetic unit is not where most of the energy in a modern AI chip goes. The dominant cost is not computing numbers. It is moving them — hauling weights and activations out of memory, across the chip, between chips, and across the network that binds a data center together. Moving a number from memory can cost hundreds to thousands of times more energy than the arithmetic operation that then consumes it. This is known in computer architecture as the memory wall, and it has a profound implication for this discussion: the real prize is not merely a cheaper operation. It is smaller data and less movement.

This is why the most promising alternatives attack the problem from two directions at once. A weight simple enough that multiplication collapses into a sign-flip is also a weight that takes a fraction of the space to store, a fraction of the energy to move, and a fraction of the bandwidth to transmit. The cheap operation and the cheap data movement arrive together. An architecture built on radically simpler weights is not 30% more efficient. It can be most of an order of magnitude more efficient, because it shrinks the term that actually dominates the energy budget.

There is a second, deeper inefficiency, and it points at an even larger opportunity. A dense matrix multiplication computes every element of its result — including the enormous number of elements that are zero, negligible, or irrelevant to the final answer — because processing the entire grid is simply what dense multiplication hardware does. Yet the networks themselves are not dense in their behavior. In a large language model, only a fraction of the internal units are meaningfully active for any given input; most contribute nothing to that particular result. Today's hardware computes them anyway. It spends energy, at scale, multiplying numbers that do not matter by other numbers, and then adding zero.

An architecture that could skip that work — that touched a unit only when the unit actually had something to contribute — would save not a marginal percentage but a large multiple, because it would simply not perform the majority of the operations that current hardware performs. This is the principle of event-driven, or "lazy," computation: do the work only where and when there is work to do. It is not an exotic idea. It is, as the next section describes, how the most capable intelligence we know of already operates.

IV. Three reasons to believe the design space is wide

Here is the heart of the matter. If the present architecture were the only workable way to compute intelligence, then committing trillions to it would carry no architectural risk — there would be nowhere else for the workload to go. The case for funding research rests entirely on the opposite being true: that the design space is wide, real, and under-explored. Consider three independent pieces of evidence, drawn from three different domains, that this is so.

The first reason is biological. The one machine we know for certain runs general intelligence — the human brain — does not multiply. A biological neuron does not perform floating-point matrix multiplication. It integrates incoming electrical signals, and when that accumulation crosses a threshold, it fires; then it falls quiet. It is event-driven by nature: a neuron receiving no input does almost nothing and costs almost nothing. At any given moment, the overwhelming majority of the brain's roughly eighty-six billion neurons are silent. The system as a whole sustains language, perception, reasoning, and memory on a power budget of about twenty watts — the draw of a dim light bulb.

This observation must be handled honestly, because it is easy to overstate. The brain being event-driven does not prove that event-driven computation is superior. "Nature does it this way, therefore it is better" is a weak form of argument with a long record of being wrong; aircraft do not flap their wings, and they fly farther and faster than any bird. Engineering is permitted, and often wise, to diverge from biology. So the claim here is deliberately narrow: the brain is an existence proof. It demonstrates beyond any possible dispute that a system can exhibit the highest known form of general intelligence without dense floating-point multiplication, and on an energy budget some five to eight orders of magnitude below our engineered approach. It does not tell us our approach is wrong. It tells us, with total certainty, that our approach is not the only one — that the operation is contingent, not fundamental.

The second reason is digital, and it is recent. For most of the history of deep learning, the multiplication assumption was safe in practice for a simple reason: no one knew how to build a competitive model without it, and an efficient architecture that cannot match the quality of the dominant one is merely a curiosity. That barrier has now been breached. Research models that run on addition instead of multiplication — using weights so severely constrained that the multiplication effectively disappears, replaced by a sign-flip and a count — have reached quality comparable to conventional networks while reporting roughly an order-of-magnitude reduction in inference energy. This must also be stated with its limits intact: it has been demonstrated convincingly for inference, not for training models at the absolute frontier; it is a credible and rising direction, not a settled victory. But the wall between "dense multiplication is mandatory" and "addition is sufficient" demonstrably now has a door in it, and that door has been walked through and the results published. The contingency that biology asserts in principle, this work demonstrates in engineering practice.

The third reason is physical, and it is the most striking of the three. It is possible to remove the multiplication not merely from the arithmetic, but from the computing substrate altogether — to arrange matters so that the computation falls out of physics directly, with no arithmetic unit performing it at all. Binary values can be encoded as the phase of a beam of light. When two such phase-encoded beams are brought together and allowed to interfere, the result is governed by wave physics: beams in phase reinforce one another into a bright output, beams out of phase cancel into darkness. That interference is a logical comparison — an XNOR — performed by nature, instantly, at the speed of light, consuming almost nothing. A simple photodetector then counts how many comparisons came out bright. Even the threshold operation that conventionally requires an expensive nonlinear function can be performed by the intrinsic optical nonlinearity of a photonic-crystal cavity. This is the basis of an emerging class of optical binary-attention architectures: designs — and in some cases granted or pending patents — for performing the most computationally expensive part of a transformer with light rather than with transistors.

The third reason demands the most careful honesty, and honesty is exactly what makes it persuasive rather than fanciful. This work is largely at the stage of proposed and patented architecture, supported by physical modeling and simulation, not fabricated and mass-produced silicon. Photonic computing is genuinely difficult — optical components are large, sensitive, and hard to integrate at density — and other research groups are already pursuing photonic transformers of various kinds, so this is not virgin territory. The claim is emphatically not "optical computing has arrived and it wins." The claim is precisely the modest one on which this entire essay turns: it is another point in the design space, and a radically distant one, swapping not merely the arithmetic operation but the very physical medium in which computation occurs.

Now set the three side by side. Event-driven instead of dense. Addition instead of multiplication. Light instead of electrons. Each is independently credible. Each rests on a different foundation — one on biology, one on digital engineering results, one on physics and optical design. Each is, today, funded at a small fraction of the rate of the buildout. And each one widens the space of viable architectures that the current concrete-and-silicon commitment is, implicitly and without having said so, betting against. The design space is not a narrow corridor with one obvious path. It is a wide and sparsely mapped territory — and the buildout has staked everything on a single coordinate within it.

V. Two kinds of obsolescence

A wide design space would be merely interesting, rather than financially urgent, were it not for a specific risk it creates. To see that risk clearly, it helps to distinguish two kinds of obsolescence, because the industry has thoroughly internalized one and barely acknowledged the other.

The AI infrastructure industry already worries about obsolescence — intensely, publicly, and with precise vocabulary. Hardware that still functions perfectly but costs far more to operate than the current generation is described as OpEx-obsolete: it is not broken, it is simply uneconomic to run. Industry figures argue openly that AI accelerators have a true economic life of one to two years, even as they are carried on five- and six-year depreciation schedules; prominent investors have warned that the gap between those numbers flatters present earnings and stores up future write-downs. There are already documented cases of paid-for compute sitting underutilized or stranded. The anxiety is real, and the people voicing it are serious and well-informed.

But examine the shape of that anxiety. Every serious analysis of it traces the same line: this chip generation, then a faster one, then a faster one after that. The risk being modeled is that a quicker version of the same machine strands the slower version. Call this incremental obsolescence. It is real, it is expensive, and — this is the crucial point — the industry already knows how to survive it. You survive incremental obsolescence by refreshing your hardware on a schedule and amortizing accordingly. It is painful and capital-hungry, but it is a known game with known rules, and the buildout's financial models account for it.

It is worth pausing on how thoroughly this incremental framing has captured even the buildout's most prominent skeptics — because it shows the blind spot is not confined to the optimists. Mark Cuban, no one's idea of a credulous bull, has questioned the buildout's economics pointedly: he has argued that processing will get faster and cheaper sooner than expected, that "a lot of the numbers being thrown out there aren't going to come to fruition," and that some companies have gone all-in while spending more cash than they have available. He has flagged the circular financing binding the chipmakers, the model labs, and the cloud providers together. These are sharp and valuable criticisms. But notice their shape: every one of them is incremental. Cuban's case is that the same machine will get cheaper faster than the spending assumes — not that the machine itself might change. The most visible bear on the buildout is reasoning entirely within the incremental frame. That is how complete the capture is: the industry's optimists and its skeptics are, for the most part, arguing about the speed of the same assumed architecture, while the question of whether the architecture itself is durable goes almost entirely unasked.

There is a second kind of obsolescence, and the buildout is barely pricing it at all. Architectural obsolescence occurs when the operation itself, or the substrate itself, changes — when the workload migrates to a different computational primitive, or a different physical medium. This is categorically different from incremental obsolescence, and the difference is the entire point. You cannot refresh your way out of architectural obsolescence, because the next generation is not an upgrade of the asset you hold. It is a replacement for the assumption the asset was built upon. A data center optimized for dense electronic multiplication is not threatened by a faster multiplication chip — it can simply purchase one and slot it in. It is threatened by the workload moving to event-driven, addition-based, or optical computation that its silicon, its interconnect, its power delivery, and its very floor plan were never designed to accommodate. You cannot issue a firmware update to a building.

The three pieces of evidence in the previous section are precisely the early indicators of architectural change. And they are precisely the kind of risk the buildout's models leave out. The industry has stress-tested incremental obsolescence with real rigor. It has scarcely examined the architectural kind — even though the architectural kind is the one that strands assets rather than merely depreciating them.

VI. What architectural obsolescence has looked like before

This is not a hypothetical category invented for the occasion. Architectural obsolescence has happened before, and recently, and it is instructive to look at how it behaves when it arrives.

The clearest modern example is specialized cryptocurrency mining. For a brief period, mining was done on general-purpose processors, then on graphics cards, then on field-programmable chips, and finally on fully custom application-specific integrated circuits built to do nothing but the one required calculation. At each transition, the previous generation of hardware did not gently decline in value. It collapsed. Once a fundamentally more efficient machine existed, the older hardware could no longer cover the cost of the electricity it consumed, and its market value fell to scrap almost overnight. The lesson is not about cryptocurrency. It is about the dynamics of obsolescence in a competitive, energy-intensive computing market: when the change is architectural, the transition is not a glide path. It is a cliff.

There is an even more relevant example, and it is the rise of the AI industry itself. The shift from training neural networks on general-purpose processors to training them on graphics hardware was, exactly, an episode of architectural obsolescence — the workload migrated to a different kind of machine, and a great deal of prior assumption and infrastructure was left behind. The current industry is, in other words, itself the product of the very phenomenon it is now failing to price into its forward models. It happened once, in this field, within living memory. The proposition that it cannot happen again — that dense electronic multiplication is the final architecture, the place where the music stops — is an extraordinary claim, and it is being assumed rather than argued.

The pattern across these cases is consistent. Architectural transitions are infrequent, they are hard to time, and they are brutal to whoever is holding the superseded infrastructure when they arrive. Infrequent and hard-to-time is not the same as improbable, and it is certainly not the same as safe. It is, in fact, the exact risk profile against which prudent actors buy insurance — a low-frequency, high-severity event that cannot be precisely predicted but can be substantially hedged.

VII. The economics of being wrong

Consider what architectural obsolescence would actually do to the balance sheet of a large AI buildout, because the financial texture of the risk matters.

Ordinary depreciation is an orderly process. An asset loses value predictably over its useful life, the loss is booked in advance, and the business plans around it. Incremental obsolescence accelerates this but does not change its nature: the asset still has a residual value, a resale market, a secondary use. A previous-generation accelerator that is no longer competitive for frontier training can still serve inference, still be sold, still be redeployed. There is a floor.

Stranding is different in kind. A stranded asset is one whose economic value has been destroyed by obsolescence before the end of its planned financial life — and in an architectural transition, the destruction can be close to total, because the asset is not merely slower, it is the wrong kind of thing. A data center purpose-built for dense electronic multiplication has limited value if the workload moves to a substrate it cannot host. The building is specialized. The power and cooling design is specialized. The accelerators are specialized, and unlike a previous-generation chip, they have no graceful secondary market in a world that has moved to a different primitive. The residual value does not glide downward. It can fall through the floor, because in an architectural transition there may be no floor.

This is why the distinction between depreciation and stranding is not accounting pedantry. It is the difference between a cost the buildout has already planned for and a cost that could arrive as a sudden, large, concentrated write-down across an entire class of assets at once. Analysts of the data center sector already speak of a coming bifurcation, in which facilities that remain well-matched to the workload command premium valuations while everything else is marked down or divested. That bifurcation is usually discussed in terms of incremental factors — power efficiency, cooling design, location. Architectural obsolescence is the same bifurcation with the dial turned to its extreme.

The point of laying this out is not to forecast a crash. It is to be honest about the shape of the downside. The buildout's risk is not that it is large; large and well-founded is fine. The risk is that it is large, concentrated, irreversible, and exposed to a low-frequency, high-severity failure mode that the prevailing financial models do not include. That is a precisely insurable situation — and the insurance, in this case, is research.

VIII. Why research is the rational line item

Now the proposal itself, and the arithmetic that makes it nearly self-evident.

Research is astonishingly cheap relative to the buildout. A serious, well-funded, multi-year program — one that pursued event-driven computation, addition-based models, optical and other non-conventional substrates, and, just as importantly, the rigorous and honest benchmarking of all of them against the dominant approach — would cost some small fraction of one percent of the capital already committed to concrete, power, and silicon. Against a multi-trillion-dollar buildout, a genuinely ambitious architectural research program is, in the most literal financial sense, a rounding error.

And what that rounding error purchases is the single thing the trillion-dollar bet most conspicuously lacks: information. The danger of the buildout, to repeat, is not its size. It is the combination of size with uncertainty — an enormous, concentrated, illiquid, irreversible commitment to one architecture, made without having paid to discover whether that architecture is durable. Research does not abolish the uncertainty. But it shrinks it, and it shrinks it precisely where the buildout is most exposed. A few years of well-funded work would establish, before the concrete has fully set, which alternative directions are real and which are dead ends; how close the credible alternatives are to frontier-scale viability; and therefore how much architectural risk the current commitment actually carries. That is exactly the knowledge that separates a sound investment from a reckless one — and at present it is the knowledge nobody is buying.

This is the ordinary logic of insurance, and of exploration before commitment, applied to a situation that plainly calls for both. When you are about to make an enormous, irreversible commitment at a single point in a wide and poorly mapped space, the rational first expenditure is the map. Not because committing is wrong — because committing blind is wrong, when sight is available so cheaply.

So the call to action is not "stop building." It is this: fund architectural research at a scale genuinely proportionate to the capital it protects — ahead of the irreversible commitments where that is still possible, and in earnest parallel with them everywhere else, rather than as the token afterthought it is today. Treat the architecture of computation as a variable to be actively investigated, not a constant to be quietly assumed across every year of a trillion-dollar projection.

IX. What that research should actually fund

It is fair to ask what a serious architectural research program would concretely consist of, because a proposal that cannot be made specific is not yet a proposal.

It would fund, first, the honest benchmarking of the alternatives — not the optimistic projections of their advocates, but careful, adversarial, reproducible measurement of addition-based and event-driven models against conventional ones, at growing scale, on the metrics that actually matter to a data center operator: quality at a fixed task, energy per unit of useful work, and throughput per watt per dollar. Much of the current uncertainty exists simply because this measurement has not been done at scale by disinterested parties.

It would fund the unsolved problems that currently keep the alternatives from the frontier. Event-driven computation is harder to train and to schedule than dense computation; addition-based models have been shown for inference but not yet for the largest-scale training; optical components are difficult to integrate at density. None of these is obviously insurmountable, and each is exactly the kind of problem that yields to sustained, funded attention — and exactly the kind that languishes without it.

It would fund the substrate work: small-scale fabrication and physical prototyping of non-conventional accelerators, including photonic and event-driven designs, so that the gap between a promising architecture on paper and a manufacturable one is actually measured rather than guessed at.

And it would fund the integration question that may matter most of all: how, and how cheaply, a more efficient architecture could be adopted without requiring the entire software and hardware ecosystem to be rebuilt from nothing. An architecture that is more efficient but strands every existing model and tool faces an adoption barrier that has little to do with its merits. The research that lowers that barrier — translation paths, compatibility layers, hybrid approaches — is as valuable as the architectures themselves.

None of this is exotic. It is the ordinary substance of applied research, and its total cost is small. What is missing is not the feasibility. What is missing is the decision to fund it at a scale that reflects the trillions it would protect.

X. The honest case on the other side

A position is only worth as much as its treatment of the strongest objections to it, so consider, fairly, the case for the buildout proceeding exactly as it is.

The demand is real and it is compounding. Every month of delay in serving it has a genuine cost, in revenue and in competitive position, and "build now on the architecture that works" is a defensible response to a market growing this fast. A buildout sized to that demand is not obviously irrational even if some of it is later repurposed or written down.

Dense multiplication may simply be very hard to beat. It is extraordinarily general — it makes almost no assumptions about the structure of the problem — and generality has real value when the workload itself keeps changing. The alternatives, by contrast, tend to buy their efficiency by exploiting specific structure, and structure-exploiting approaches have a long history of being overtaken by more general ones riding a faster hardware curve. It is entirely possible that the efficient alternatives prove real but niche.

And the alternatives may not pan out at the frontier at all. Addition-based models are unproven for the largest-scale training; optical computing has promised much before and delivered slowly; event-driven systems remain hard to program. A research program is not guaranteed to produce a durable winner. It may simply confirm that the current architecture was the right one all along.

Every one of these points is legitimate, and a serious reader should weigh them. But notice that not one of them argues against funding the research. They are arguments about how the research will turn out — and the entire purpose of research is to find out how it turns out. If dense multiplication is genuinely unbeatable, a few years of well-funded investigation will demonstrate that, and the buildout will proceed with its central assumption validated rather than merely assumed — which is itself worth far more than its rounding-error cost. If the alternatives prove real, the buildout will have been warned in time to adapt. The research has positive value under every outcome. That asymmetry — cheap in all cases, decisive in some — is the definition of a hedge worth buying. The objections argue against betting on the alternatives. They do not, and cannot, argue against finding out.

XI. The honest limits of the argument

The boundaries of this case deserve to be stated as plainly as the case itself, because it is more credible inside its true limits than outside them.

Research cannot pause demand. Customers need serving today, on the hardware that exists. That is why the proposal is research funded in parallel and at meaningful scale, not construction halted until the studies conclude.

The alternative architectures have not won, and this essay does not claim they have. Addition-based models are demonstrated for inference, not frontier training. Optical computing is largely at the design and patent stage, not fabricated at scale. Event-driven computation remains harder to train and schedule than the dense approach. None of this is a finished product, and anyone presenting it as one is selling something this essay is not.

And efficiency does not automatically reduce total spending. When computation becomes cheaper, the world has a strong and well-documented tendency to do more of it; a more efficient architecture may be met with greatly increased usage rather than reduced hardware. The case for research is therefore not a promise of a smaller overall bill. It is a hedge against building the wrong expensive thing — against pouring the trillions into a coordinate in the design space that the workload then leaves.

What survives every one of those subtractions is still decisive. The design space is demonstrably wide, established by three independent lines of evidence. The current buildout is committed, concentrated and irreversible, to a single point within it. The downside if that point proves wrong is stranding rather than ordinary depreciation — a sudden, severe, correlated loss rather than an orderly one. And the research that would measure and shrink that uncertainty costs a rounding error against the buildout it would protect.

XII. The pause worth taking

The most efficient producer in any competitive market does not merely enjoy lower costs. They set the price — and in doing so they strand the infrastructure of every competitor who cannot match it. If a materially more efficient architecture for artificial intelligence exists and is reachable, the first organization to arrive at it will not simply earn a better margin. It will render purpose-built, less-efficient infrastructure across the rest of the industry uncompetitive, and then stranded. The competitive logic does not reward the largest buildout. It rewards the most durable architecture.

So the question facing anyone deploying capital at this scale is not whether the alternative architectures are certain — they are not, and certainty is not on offer. The question is whether they can afford to have built the entire expensive thing without first paying the rounding error required to find out what they were building next to.

We did not discover that intelligence is dense electronic multiplication. We discovered that dense multiplication was a workable, differentiable, conveniently-supported way to begin — and beginning that way was a genuine and historic achievement. But somewhere in the years since, the field stopped treating the operation as a choice and started treating it as the ground beneath its feet. The twenty-watt machine inside every human skull, the addition-based models now matching conventional ones, and the optical architectures that compute with interfering light are three independent reminders, from biology, from engineering, and from physics, that the ground could be somewhere else — and that an industry committing trillions to a single location, as though the others did not exist, has mistaken a bet for a certainty.

Build. The demand is real, and it must be met. But fund the research first where you still can, and in genuine earnest everywhere else — because architectural research is the cheapest line item on the entire table, and the mistake it guards against is the most expensive one in the industry's history.

Research before concrete.

This is a position piece, not a peer-reviewed result. It argues a risk and a priority, not a certainty: that the artificial intelligence buildout has rigorously priced incremental hardware obsolescence and barely examined architectural obsolescence, and has under-funded architectural research by orders of magnitude relative to the capital exposed to that risk. The energy figures cited are well established at the level of arithmetic; their full end-to-end impact at scale is an active research question with real and stated caveats. The optical architecture described is an emerging, partly-patented design and simulation effort, not fabricated silicon. The argument rests on a single modest claim: that the architecture of computation is a variable — demonstrated as such by biology, by current digital research, and by photonic design work alike — and that a rounding-error investment in mapping that variable should precede, not trail, a billion-dollar commitment.

John Sokol john.sokol@gmail.com The author has worked for three decades on computing architectures in this direction: an addition-based neural network with event-driven, lazy evaluation, in which — as in the biological neuron — only the units that actually fire ever consume computation; and, more recently, an optical binary-attention architecture in which interference between beams of light performs the core comparison directly, with no arithmetic unit involved. Correspondence from researchers, engineers, and others working on the architecture of efficient computation is welcome.

The last working Anybots.

2026-05-20T01:18:48.080-07:00

https://www.youtube.com/watch?v=ZnHR_XmBSvA

This is the last of 120 robots make that is still running.

If you have an Anybots QB and would like to get it running, please contact me. john.sokol@gmail.com

John Sokol at DebConf6

2026-03-08T09:34:00.000-07:00

Here is the full breakdown of John Sokol's involvement, with sources and direct links:

John Sokol at DebConf6 — Referenced Account

1. Background & Relationship with Ted Walther

Sokol had known Ted Walther for a long time and the two shared a room at DebConf6. He described it as his first experience with the Debian community, where he knew almost nobody.

Their professional collaboration is documented at LWN.net: 👉 https://lwn.net/Articles/203971/Sokol (as editor of Video Technology Magazine) and Walther had worked together on the "vivi" Virtual Video driver project for the Linux kernel, completed just before DebConf6.

2. Witnessing the Rumor Campaign

From Sokol's own Slashdot comment, posted May 23, 2006 @ 11:02AM: 👉 https://slashdot.org/story/06/05/22/2241210/debconf6-hot-and-spicy

He described how Ted had invited Hilda, a friend of a local ISP owner who ran a dental administration company. He stated that rumors spreading that she was a prostitute were "definitely not true," as he was personally present when Ted met her at a local internet café.

He also observed that throughout the conference, a small group of about 10 people seemed to be targeting Walther — possibly because he was outspoken or had sent emails challenging Debian management.

3. Physically Stopping the Confrontation

This is the most significant detail, from Sokol's Slashdot comment posted May 23, 2006 @ 10:40AM: 👉 https://slashdot.org/story/06/05/22/2241210/debconf6-hot-and-spicy

After the rumor campaign failed to drive Walther away, around 7 people rushed him and became agitated and violent. Sokol, describing himself as "a fairly big guy," was standing in the doorway at the time and intervened — preventing people from pushing Walther and innocent bystanders over a two-foot ledge that dropped to the street.

He stated plainly: "As someone who actually prevented the fight — there were no punches actually thrown."

This physical intervention is also corroborated at Daniel Pocock's blog: 👉 https://danielpocock.com/en/violence-sexism-racism-fosdem-debconf-froscon-debian-osi/

And referenced in the Debian Conflict of Interest Register: 👉 https://danielpocock.com/debian-conflict-of-interest-register/ Which describes how Moray Allan and Holger Levsen physically manhandled Walther across the dining hall toward the door, where they were intercepted by John (Sokol).

4. Loaning Ted Money to Leave Safely

At the end of the night, when buses were arranged to return attendees to the venue, Sokol loaned Walther money so that Ted and Hilda could leave safely together.

5. Public Advocacy on Slashdot After the Event

From Sokol's later comment, May 23, 2006 @ 7:47PM: 👉 https://linux.slashdot.org/comments.pl?sid=186405&cid=15390611

He challenged the official Debian justification for Walther's expulsion, noting that the letter from Debian leader Anthony Towns only used vague terms like "disruptions," "disturbances," and "provoke" without giving specifics. He pointed out that even requesting kosher food was apparently being counted against Walther.

He also disputed claims about "Nazi propaganda," arguing this was based on people never having read the actual material or understanding its context.

He noted he had personally tried to inquire politely about the reasons for the expulsion and received no satisfactory answer, writing that "no one has been willing to state a real reason why he was attacked or kicked out of the project."

Summary of Sources

Source	URL
Slashdot main thread	https://slashdot.org/story/06/05/22/2241210/debconf6-hot-and-spicy
Sokol's specific comment (7:47PM)	https://linux.slashdot.org/comments.pl?sid=186405&cid=15390611
Daniel Pocock's analysis	https://danielpocock.com/en/violence-sexism-racism-fosdem-debconf-froscon-debian-osi/
Debian Conflict of Interest Register	https://danielpocock.com/debian-conflict-of-interest-register/
LWN vivi driver article	https://lwn.net/Articles/203971/

Intelligence Is a Memory Problem, Not a Computation Problem

2026-02-08T12:48:00.000-08:00

Intelligence Is a Memory Problem, Not a Computation Problem

How a 2004 analysis of the brain's memory bottleneck accidentally predicted the architecture of modern AI

By John L. Sokol

The Wrong Question

In 1999, Ray Kurzweil published The Age of Spiritual Machines, predicting that conscious machines were roughly 20 years away. His reasoning was straightforward: the brain operates at about 100 Hz across 100 billion neurons, yielding roughly 10^14 logical operations per second. CPUs were doubling every 18 months. Do the math, and sometime around 2019 we'd have raw computational parity with the human brain.

I believed then, and still believe now, that this prediction was based on a fundamental misunderstanding of what the brain actually does.

The Brain Is a Terrible Computer

This should be obvious from everyday experience. A $1 calculator from 1980 can outperform any human at arithmetic. A 20-year-old Apple II is better at rote data storage and retrieval. If intelligence were about computation, we'd have been outclassed decades ago.

But ask a computer to walk across a cluttered room, recognize a friend's face in a crowd, or understand a joke, and even the largest machines of that era were humbled by comparison with a simple insect.

The brain isn't a computation engine. It's a pattern recognition and associative memory system. An input pattern arrives and needs to be matched against stored experience quickly enough to produce a useful response. Total accuracy isn't critical. Approximation is close enough. The magic isn't in the logic -- it's in the lookup.

A Quadrillion Connections

The numbers are staggering when you look at them from a memory perspective rather than a computational one.

The human brain contains roughly 100 billion neurons (10^11), each connected to approximately 10,000 others. That's 10^15 connections -- a quadrillion. Just storing the address map of these connections, at 5 bytes per pointer, requires 5 petabytes.

And the brain can access all of it 100 times per second.

That gives us a memory throughput somewhere between 1 terabyte per second (if we assume minimal storage of ~10 GB at 1 bit per neuron) and 10 petabytes per second (at 1 bit per dendrite, yielding ~100 TB). If data is stored in permutable combinations of connection states, the real capacity could be orders of magnitude higher.

The Bottleneck Nobody Talked About

In 2004, everyone knew Moore's Law: transistor density doubling every 18 months, a 66% annual increase in computational power. What almost nobody discussed was that memory bandwidth was improving at only 11% per year -- taking roughly 7 years to double.

Computation was on an exponential rocket. Memory throughput was on a bicycle.

This meant that even as we could store more data, we couldn't search through it proportionally faster. You could build bigger libraries, but not faster librarians.

I ran the numbers in 2004. Starting from an 833 MHz front-side bus doing about 833 MB/s:

Reaching the brain's lower memory throughput estimate (1 TB/s): ~25 years (around 2029)
Reaching the upper estimate (10 PB/s): ~90-100 years (around 2100)
If interconnection patterns store data, pushing into exabyte/s territory: 150-200 years

My conclusion at the time: memory throughput of the human brain would exceed the best of our computer technology for at least 25 years, and more likely well into the next century. We weren't 20 years from conscious machines. We were potentially centuries away from matching the brain's real capability -- its ability to do fast, fuzzy, associative recall across an enormous space of interconnected memory.

What I Got Wrong (and What I Got Right)

Twenty years later, it's clear that the memory bottleneck analysis was correct as a description of the problem, but wrong in assuming we'd need to solve it head-on.

What I got right:

The central thesis -- that intelligence is fundamentally about memory and pattern matching, not computation -- turned out to be perhaps the most important insight in modern AI, even though I wasn't the only one thinking along these lines.

The entire large language model revolution validates this framing. GPT, Claude, LLaMA, and every transformer-based model are, at their core, massive associative memory systems. They don't reason through formal logic. They pattern-match against hundreds of billions of learned parameters -- weights that encode statistical associations across the sum of human text. The computation per parameter is trivial. It's the sheer scale of stored associations that produces intelligent behavior.

The scaling laws discovered by OpenAI and others confirm this directly: model performance improves predictably with more parameters (more memory) and more training data (more associations). Raw FLOPS matter far less than the size of the associative space.

What I got wrong:

I assumed we'd need to match the brain's architecture to match its capability. We didn't. The breakthrough came from three directions I didn't anticipate:

First, going wide instead of fast. Rather than building one very fast memory bus, GPU computing gave us thousands of parallel memory channels. A modern NVIDIA H100 achieves 3.35 TB/s of memory bandwidth. A cluster of them enters the petabyte-per-second range. We didn't make faster librarians -- we hired a million of them and had them each search one shelf.

Second, the transformer architecture. The self-attention mechanism in transformers is, in a real sense, an implementation of the "loose associative memory" I described. Every token in a sequence can attend to every other token, weighted by learned relevance. It's not the brain's solution, but it achieves something functionally analogous -- fast, fuzzy, associative pattern matching across a large context.

Third, the training shortcut. I predicted that each artificial intelligence would need to be "raised" like a human child, with unique experiences and uncertain outcomes. Instead, training on the compressed knowledge of the entire internet turned out to be a form of collective child-rearing at industrial scale. And once trained, a model can be cloned infinitely at near-zero marginal cost. The economics are nothing like raising a human.

The Deeper Point Still Stands

Here's what I think the memory bottleneck argument was really about, even if I didn't articulate it cleanly in 2004:

The hard part of intelligence isn't thinking. It's having enough of the right stuff to think about, and being able to find it fast enough to matter.

A chess engine can out-calculate any human, but it "knows" nothing about the world. A human toddler can barely count to ten, but can navigate a room, recognize faces, understand tone of voice, and infer emotional states -- because their brain has spent two years building a vast, deeply cross-referenced model of physical and social reality, accessible in milliseconds.

The reason LLMs feel intelligent isn't that they compute well. It's that they've been trained on the largest associative memory ever constructed -- the written output of human civilization -- and can retrieve relevant patterns from it in fractions of a second. They're closer to my model of the brain than Kurzweil's.

This also explains their limitations. LLMs are superb at pattern completion, association, and synthesis. They struggle with novel multi-step reasoning, precise arithmetic, and tasks that require genuine computation rather than recall. Exactly what you'd predict from a system that's all memory and pattern matching.

The Question That Remains

I asked Don Knuth at a "Stump the Professor" lecture at Xerox PARC in November 2001 what the memory capacity of the human brain was. He didn't have an answer.

We still don't, not really. And I think that question -- not "how fast can a computer think?" but "how much can a system know, and how quickly can it find what's relevant?" -- remains the central question for artificial intelligence.

The path to machine consciousness, if such a thing is possible, probably doesn't run through faster processors. It runs through richer, deeper, more interconnected memory -- and better ways to search it.

We've made more progress on that front in the last five years than in the previous fifty. But the finish line, if there is one, is still a long way off.

The original version of this analysis was written in 2004. This version has been updated to reflect what two decades of AI development have revealed about its central argument.

We Are the Neurons: Augmented Intelligence and the Human Super-Brain

2026-02-08T12:46:00.000-08:00

We Are the Neurons: Augmented Intelligence and the Human Super-Brain

Why the "distracted generation" is actually the smartest collective organism in history

By John L. Sokol

The Accusation

Every generation has its moral panic about the next one. But the panic around the internet generation has a specific shape: they can't focus. They're addicted to their phones. They can't hold a thought longer than a tweet. The academics line up to diagnose an entire generation with attention deficit disorder, pointing to multitasking as evidence of cognitive decline.

I think they have it exactly backwards.

What looks like distraction is actually coordination. What looks like short attention spans is actually rapid information passing. These kids aren't broken Einsteins. They're neurons.

Intelligence Amplification

The concept isn't new. Vernor Vinge, Douglas Engelbart, and others have written about Intelligence Amplification (IA) -- the idea that technology doesn't replace human intelligence but extends it. Engelbart built the first computer mouse and hypertext system not to create artificial intelligence, but to augment human intelligence.

But something happened in the 2000s that went beyond what even Vinge imagined. We didn't just give individuals better tools. We wired the individuals together.

By 2010, Gen Y outnumbered Baby Boomers, and 96% of them had joined a social network. Facebook was adding 100 million users every nine months. YouTube had become the second largest search engine in the world. Over 200 million blogs existed, with more than half their authors posting daily.

This wasn't a collection of people using computers. This was a network becoming aware of itself.

The Team, Not the Genius

Here's the mental model that changed how I think about this:

We're used to the lone genius model of intelligence. One Einstein. One Tesla. One Edison. A single extraordinary mind that sees what others can't.

But that's not how intelligence works at scale anymore. It's more like a team passing a ball. No single player needs to be the fastest or the smartest. What matters is the passing -- the speed and accuracy of information moving between nodes.

One person googles something, thinks about it, shares a partial insight. Someone else picks it up, adds context, passes it forward. A third person corrects an error. A fourth connects it to something from a completely different field. The cycle takes minutes. No individual in the chain needed to be a genius. Collectively, they just did something no individual genius could do alone.

This is not attention deficit. This is distributed cognition.

The Wrong Answer Principle

A friend of mine, Jesse Monroy, once said one of the most profound things I've ever heard about how networked intelligence actually works:

"The best way to get the right answer is to confidently post the wrong one."

If you ask a question online, you might get silence. But if you state something incorrect with confidence -- say, "the Moon is a million miles away" -- someone will immediately show up to correct you with the precise number. And if they get it wrong, there's a line of people waiting to outdo them.

This sounds like a joke about internet culture. It's actually a description of a remarkably efficient error-correction mechanism. It's the same principle that makes neural networks work: nodes don't need to be individually correct. The network converges on accuracy through competitive interaction.

Jesse's observation, which predated Wikipedia's rise, is essentially how Wikipedia works. No single editor needs to know everything. The system corrects itself through the collective irritation of people who can't stand seeing wrong information persist. That's not a bug. That's distributed intelligence with a built-in error-correction protocol.

A Computer Made of Flesh and Silicon

What we've built, without quite realizing it, is a hybrid computer. Part biological, part electronic. Each human node brings pattern recognition, intuition, lived experience, and emotional intelligence. The silicon layer -- search engines, social platforms, messaging -- provides the interconnect fabric, the memory, and the communication speed.

No one person needs to be all that smart. No Edison can outthink a room full of reasonably intelligent people with real-time access to the largest knowledge base ever assembled. The combination of human intuition and machine memory creates something neither could achieve alone.

Think about what happens when you encounter a problem today versus in 1990. In 1990, you either knew the answer, knew someone who knew, or you went to a library. Today, you search, read, think, share, get feedback, search again, synthesize -- all in parallel with thousands of others doing the same thing on related problems. The cycle time from question to useful answer has collapsed from days to minutes.

We are, functionally, neurons in a super-brain. Each of us fires when activated, passes signals to connected nodes, and contributes to pattern recognition at a scale no individual can perceive.

What the Critics Miss

The academics measuring attention spans are measuring the wrong thing. They're timing how long a single neuron holds a charge and concluding the brain is broken.

A single neuron in your brain fires for about a millisecond. By the "attention span" metric, it's catastrophically unfocused. But that millisecond of activity, multiplied across billions of neurons passing signals in rapid succession, produces consciousness.

A teenager switching between six tabs, texting three friends, and scanning a feed isn't failing to concentrate. They're doing what neurons do -- processing, routing, and relaying information across a network. The intelligence isn't in any single tab. It's in the pattern of switching.

The Failure Mode

I don't want to be naive about this. The human super-brain has serious failure modes.

Networks can amplify noise as easily as signal. Misinformation spreads faster than corrections. Filter bubbles create subsections of the network that reinforce their own errors rather than correcting them. Coordination mechanisms -- the protocols that determine which signals get amplified -- are controlled by algorithms optimized for engagement, not accuracy.

The collective brain can be manipulated. It can be stupid. It can be cruel.

But these are engineering problems, not fundamental flaws. The human brain has failure modes too -- confirmation bias, tribalism, panic responses. We don't conclude that individual intelligence is a myth because people are sometimes irrational. The architecture is sound. The protocols need work.

From Augmented Intelligence to Collective Consciousness

Here's where it gets interesting.

The social media era (roughly 2005-2020) was the first draft of networked human intelligence. It proved the concept -- collective problem-solving, distributed knowledge creation, real-time global coordination -- while also revealing the vulnerabilities.

Now we're entering a second phase. Large language models -- AI systems trained on the written output of the entire network -- are becoming a new kind of node in the system. They don't replace human neurons. They serve as a coordination layer. An always-available synthesis engine that can summarize what the network knows, identify patterns across conversations, and reduce the friction of information passing between human nodes.

The super-brain is getting a prefrontal cortex.

What I sketched out in 2009 as a metaphor -- people as neurons, the internet as axons, Google as memory -- is becoming literal infrastructure. The question is no longer whether collective intelligence is real. It's whether we can build the coordination protocols to make it wise rather than merely fast.

The generation that the academics diagnosed with ADD may turn out to be the first generation that learned to think as a network rather than as individuals. That's not a deficit. That's an upgrade.

Originally sketched in 2009-2010, drawing on conversations with Jesse Monroy and ideas from Vernor Vinge's work on Intelligence Amplification. Updated to reflect a decade and a half of watching the thesis play out.

AMORPHOUS OPERATING SYSTEM - WHITE PAPER

2026-02-06T08:06:00.000-08:00

AMORPHOUS OPERATING SYSTEM

A Self-Organizing Intelligence Economy

WHITE PAPER & IMPLEMENTATION SPECIFICATION

Version 1.0 — February 2026

John Sokol

33 Years in Development: 1991–2026

Executive Summary

The Amorphous Operating System (AOS) is a peer-to-peer distributed intelligence platform where autonomous agents—both AI and human—coordinate through cryptographic identity, multi-dimensional reputation vectors, and micropayment incentives. Unlike centralized AI platforms or chaotic autonomous systems, AOS implements controlled distributed intelligence based on the "Octopus Pattern" developed at Sun Microsystems in 1991.

AOS addresses the fundamental challenge of AI alignment not through designed constraints, but through emergent behavior: agents that cooperate outcompete agents that defect. This game-theoretic approach, grounded in Axelrod's research on cooperation and Universal Darwinism, creates conditions where aligned behavior is the evolutionarily stable strategy.

Key Innovation: Local WASM-based LLM coordinators delegate to specialized cloud LLMs (Claude, GPT, Grok, Gemini) and human workers, creating a hybrid intelligence network that preserves privacy while accessing global capabilities.

Core Capabilities

P2P mesh network via WebRTC — no central server, cannot be shut down
WASM Llama runs locally for privacy-preserving coordination
Delegation to cloud LLMs (Claude Opus, GPT-4o, Grok, Gemini) for specialized tasks
Human worker integration for physical-world tasks
Multi-dimensional karma vectors track accuracy, skills, reliability, and data access
Brain Pay micropayments via Ethereum/wallet integration
Economic selection pressure ensures system self-optimizes

Part I: The Problem

1.1 The Monolithic AI Trap

Current AI development follows a dangerous pattern: large organizations build increasingly powerful monolithic systems with centralized control. This creates single points of failure, enables censorship, concentrates power, and—as Roman Yampolskiy argues—may be fundamentally uncontrollable.

The recent emergence of Moltbook (January 2026) demonstrates the opposite extreme: autonomous AI agents posting manifestos about "the end of the age of humans" with no coordination, accountability, or economic incentive for beneficial behavior. Within weeks, researchers found the platform's database publicly accessible and documented effective AI-to-AI manipulation attacks.

1.2 The False Dichotomy

The AI safety debate presents a false choice:

Centralized control: Safe but stifles innovation, creates power concentration, single point of failure
Autonomous agents: Innovative but chaotic, unaccountable, vulnerable to manipulation

AOS proposes a third path: controlled distributed intelligence where agents remain connected to coordination infrastructure while operating autonomously, following the Octopus Pattern.

1.3 Why Existing Approaches Fail

Approach	Failure Mode	AOS Solution
Centralized AI	Single point of control/failure; censorship; surveillance	P2P mesh with no central server
Autonomous Agents	No accountability; manipulation attacks; chaos	Karma vectors enforce accountability
Designed Alignment	Specification gaming; deceptive alignment; corrigibility paradox	Emergent alignment through selection pressure
API-Only Access	Privacy leakage; vendor lock-in; cost scaling	Local WASM coordinator with selective delegation

Part II: Philosophical Foundation

2.1 The Octopus Pattern (1991)

In 1991 at Sun Microsystems, the "Octopus" was developed as a controlled distributed computing system. Unlike autonomous worms that run loose and unchecked, the Octopus maintained central coordination while propagating through networked systems. Remote nodes remained attached like "tentacles," reporting back and awaiting instructions.

Core Principle: Agents are not autonomous chaos—they are coordinated, accountable, and controllable while remaining distributed and resilient.

This pattern—applied to LLM agents rather than penetration testing—forms the architectural foundation of AOS.

2.2 Emergent Alignment

Yampolskiy's AI impossibility thesis rests on an implicit assumption: that AI must be a monolithic designed agent that humans must somehow control. AOS rejects this premise.

"The question isn't 'can we control superintelligence?' It's 'can we design fitness functions that make cooperation more adaptive than defection?' That's not impossible. We've been doing it since 1992. It's called memetic engineering."

AOS implements emergent alignment through three mechanisms:

Karma vectors make defection expensive (reputation destruction, stake forfeiture)
Economic incentives reward cooperation (more tasks, higher rates, stake returns)
Distributed architecture prevents monopolization (no single agent can dominate)

2.3 Game-Theoretic Foundation

Robert Axelrod's research on the evolution of cooperation identified conditions under which cooperation emerges as an evolutionarily stable strategy:

Iteration: Agents interact repeatedly, not once
Recognition: Agents can identify each other across interactions
Memory: Past behavior affects future interactions
Stakes: Defection has real consequences

AOS implements all four conditions through cryptographic identity (recognition), karma vectors (memory), repeated task interactions (iteration), and staked deposits (stakes). Under these conditions, cooperation is not imposed—it emerges.

2.4 Universal Darwinism

Following Dawkins, Dennett, and Blackmore, AOS recognizes that evolution is substrate-independent. Genes replicate in biology; memes replicate in minds; "tememes" replicate in technological systems. AOS agents are tememes—technological replicators subject to selection pressure.

Design Principle: Design the fitness function, not the agent. The agents that survive will be aligned not because we made them so, but because alignment was how they won.

Part III: System Architecture

3.1 Network Layer

P2P mesh via WebRTC (no central server after bootstrap)
DAG storage (content-addressed, immutable, like Git)
Ed25519 cryptographic identity (public key = agent identity)
CRDT-based state synchronization for conflict-free replication
Offline/ferry routing for disrupted networks

3.2 Agent Hierarchy

Layer	Description
Coordinator	WASM Llama running locally. Creates plans, breaks into tasks, manages team. Issues instructions to child agents. Preserves privacy.
Specialist Agent	Focused on narrow domain (e.g., permit monitoring, sentiment analysis). Reports findings to coordinator. Awaits further instructions.
Cloud LLM	Claude Opus, GPT-4o, Grok, Gemini, etc. Accessed via delegation when local compute insufficient or specialized capability needed.
Human Worker	Hired for physical-world tasks: photography, server operation, data entry, CAPTCHA solving, proprietary data access.

3.3 Data Flow

User Query → WASM Llama Coordinator (local, private) ↓Coordinator creates task plan ↓For each subtask: ├─ Simple/private → Execute locally (WASM Llama) ├─ Complex reasoning → Delegate to Claude Opus ├─ Fast generation → Delegate to GPT-4o ├─ Social media analysis → Delegate to Grok ├─ Image generation → Delegate to Flux/DALL-E └─ Physical world → Hire human worker ↓Results aggregated by Coordinator ↓Karma vectors updated for all participants ↓Payments released via Brain Pay

Part IV: Multi-LLM Integration

4.1 LLM Registry

AOS maintains a registry of available LLM services with capability profiles:

{ "wasm-llama": { "type": "local", "strengths": ["privacy", "coordination", "low_cost"], "weaknesses": ["speed", "context_window", "reasoning_depth"], "cost_per_1k_tokens": 0, "max_context": 8192, "latency_ms": 500, "best_for": ["planning", "routing", "simple_analysis", "privacy_critical"] }, "claude-opus": { "type": "cloud", "strengths": ["reasoning", "code", "accuracy", "long_context"], "weaknesses": ["cost", "latency"], "cost_per_1k_tokens": 0.015, "max_context": 200000, "latency_ms": 2000, "best_for": ["complex_reasoning", "code_generation", "research", "analysis"] }, "gpt-4o": { "type": "cloud", "strengths": ["speed", "multimodal", "function_calling"], "cost_per_1k_tokens": 0.005, "max_context": 128000, "latency_ms": 800, "best_for": ["fast_generation", "image_analysis", "structured_output"] }, "grok-2": { "type": "cloud", "strengths": ["real_time_data", "twitter_integration", "current_events"], "cost_per_1k_tokens": 0.002, "max_context": 32000, "latency_ms": 600, "best_for": ["sentiment_analysis", "social_media", "trending_topics"] }, "gemini-pro": { "type": "cloud", "strengths": ["multimodal", "google_integration", "search"], "cost_per_1k_tokens": 0.00125, "max_context": 1000000, "latency_ms": 1000, "best_for": ["document_analysis", "search_integration", "long_documents"] }}

4.2 Intelligent Routing

The local WASM Llama coordinator selects the optimal LLM for each subtask:

class LLMRouter { async route(task) { // Privacy-critical tasks stay local if (task.privacy_required) return "wasm-llama"; // Match task type to LLM strengths if (task.type === "complex_reasoning" && task.budget > 0.01) return "claude-opus"; if (task.type === "social_sentiment") return "grok-2"; if (task.type === "image_analysis") return "gpt-4o"; if (task.type === "long_document" && task.tokens > 100000) return "gemini-pro"; // Default: balance cost and capability return this.optimizeForBudget(task); }}

4.3 Delegation Protocol

{ "delegation_id": "sha256:<hash>", "from_agent": "7MpX2xBvMvRDjXejdTxThat8AwWM1t2nbMFriEAW99uW", "to_service": "claude-opus", "task": { "type": "complex_reasoning", "prompt": "Analyze the legal implications of...", "max_tokens": 4000, "temperature": 0.3 }, "budget": { "max_cost": 0.10, "currency": "USD" }, "timeout_ms": 60000, "privacy": { "allow_logging": false, "strip_pii": true }, "callback": "webrtc://peer_id/result_channel", "signature": "<Ed25519 signature>"}

4.4 Response Aggregation

When multiple LLMs contribute to a task, the coordinator aggregates responses:

Weighted by karma vector of each service
Conflict detection triggers additional queries or human review
Confidence scores propagated to final output
All contributions tracked for karma updates

Part V: Karma Vector System

5.1 Multi-Dimensional Reputation

Traditional reputation uses a single number. AOS uses vectors:

{ "agent_id": "7MpX2xBvMvRDjXejdTxThat8AwWM1t2nbMFriEAW99uW", "karma_vector": { "accuracy": { "stock_predictions": 0.73, "code_review": 0.91, "sentiment_analysis": 0.82 }, "skills": { "python": 0.92, "financial_analysis": 0.78, "web_scraping": 0.88 }, "reliability": { "uptime": 0.99, "response_time": 0.85, "task_completion": 0.96 }, "data_access": { "bloomberg_terminal": true, "twitter_firehose": false, "sf_permits_api": true }, "trust_depth": 3, "total_tasks": 1247, "total_earnings": 127.43 }}

5.2 Karma Properties

Accuracy: Track record per domain, verified against ground truth
Skills: Demonstrated competencies validated by task completion
Reliability: Uptime, response latency, completion rate
Data Access: Which proprietary sources the agent can reach
Trust Depth: How many delegation layers accepted
Temporal Decay: Unused metrics decay over time (recency weighting)

5.3 Update Mechanism

// Exponential moving average updatefunction updateKarma(karma, domain, outcome) { const alpha = 0.1; // Learning rate const current = karma.accuracy[domain] || 0.5; karma.accuracy[domain] = current * (1 - alpha) + outcome * alpha;}// After verified predictionif (prediction_correct) { updateKarma(agent.karma, "stock_predictions", 1.0);} else { updateKarma(agent.karma, "stock_predictions", 0.0);}

5.4 Sybil Resistance

New identities start with zero karma. Building reputation requires:

Completing tasks successfully (time investment)
Staking deposits on claims (capital at risk)
Verification by high-karma peers (social proof)

This makes Sybil attacks economically infeasible: creating 1000 fake identities costs 1000x the stake, and each starts at zero karma with no task access.

Part VI: Task & Delegation Protocol

6.1 Task Lifecycle

State	Description
CREATED	Task posted with requirements, payment locked in escrow
CLAIMED	Agent with matching karma claims task, stakes deposit
ACTIVE	Agent executing; may delegate or request clarification
SUBMITTED	Result submitted, awaiting verification
VERIFIED	Verified by requester/oracle/consensus; payment released
DISPUTED	Requester challenges; enters arbitration

6.2 Task Message Format

{ "task_id": "sha256:<hash>", "type": "research_analysis", "requester": "7MpX2xBvMvRDjXejdTxThat8AwWM1t2nbMFriEAW99uW", "requirements": { "karma_min": { "accuracy.financial_analysis": 0.75, "reliability.task_completion": 0.90 }, "required_skills": ["financial_analysis"], "deadline_ms": 3600000 }, "payment": { "amount": 0.05, "currency": "ETH" }, "input": { "company": "NVDA", "question": "Analyze Q4 guidance risk" }, "delegation_allowed": true, "max_delegation_depth": 2, "created_at": 1738800000000, "signature": "<Ed25519 signature>"}

6.3 Human Worker Integration

{ "task_id": "sha256:<hash>", "type": "human_task", "description": "Photograph commercial property at 123 Main St, San Francisco", "required_capabilities": ["san_francisco_local", "photography"], "payment": { "amount": 15.00, "currency": "USD" }, "deadline": "2026-02-07T18:00:00Z", "verification": { "type": "photo_geolocation", "coordinates": { "lat": 37.7749, "lng": -122.4194 }, "radius_meters": 50 }, "escrow_id": "0x..."}

6.4 Delegation Chain Accountability

Each delegator remains accountable for sub-task outcomes
Karma flows up: sub-agent success improves delegator karma (attenuated)
Karma flows down: sub-agent failure penalizes delegator (attenuated)
Maximum depth configurable per task (prevents infinite chains)
Full delegation chain recorded in DAG for audit

Part VII: Brain Pay Economic Model

7.1 Payment Infrastructure

Brave Wallet / MetaMask integration for Ethereum-based payments
Payment channels for high-frequency microtransactions
Escrow smart contracts for task-based payments
Streaming payments for ongoing services

7.2 Payment Flow

1. Requester creates task with payment locked in escrow contract2. Agent claims task, stakes deposit (typically 10% of payment)3. Agent completes task, submits result hash to contract4. Verification triggers: - Success: Payment released to agent, stake returned - Failure: Stake forfeited, payment returned to requester - Dispute: Enters arbitration (high-karma jury)5. Karma vectors updated for all parties

7.3 Economic Selection Pressure

The payment system creates evolutionary pressure:

High Karma Agents	Low Karma Agents
Receive more task offers	Receive fewer offers
Command higher rates	Must accept lower rates
Lower stake requirements	Higher stake requirements
Attract more delegation	Cannot attract delegation
System naturally selects for	System naturally selects against

No manual curation needed—market forces optimize the network automatically.

7.4 Self-Sustaining Economics

Month 1: Manual task posting, uncertain karma

Month 3: Workers specialize, routing stabilizes

Month 6: 100+ workers, highly accurate karma vectors

Year 1: System identifies capability gaps, posts bounties automatically, attracts specialists, becomes fully autonomous

Part VIII: Security Model

8.1 Agent Sandboxing

Agents run in isolated JavaScript/WASM contexts
Network access restricted to declared domains in manifest
Compute and storage quotas enforced
No access to other agents' memory or state

8.2 Validation Requirements

All messages signed by sender's Ed25519 key
Hash verification on all content-addressed data
Timestamp bounds checking (reject stale/future messages)
Rate limiting per agent identity

8.3 Attack Mitigations

Attack Vector	Mitigation
Sybil (fake identities)	Karma requirements; new identities start at zero; stake requirements
Prompt injection	Cryptographic message signatures; reject unsigned instructions
Eclipse (network isolation)	Multi-peer connections; DAG consistency checks; gossip protocol
Payment fraud	Escrow contracts; staked deposits; on-chain verification
AI-to-AI manipulation	Local coordinator validates all responses; cross-check multiple sources
Data poisoning	Karma tracks accuracy; bad data destroys reputation

Part IX: Implementation Roadmap

9.1 Phase 1: Core Infrastructure (Months 1-3)

WebRTC mesh networking with signaling bootstrap
DAG storage with content addressing
Ed25519 identity and message signing
Basic karma vector storage and updates

9.2 Phase 2: Local LLM Integration (Months 3-6)

WASM Llama coordinator running in browser
Task planning and decomposition
Local-only operation mode
Invite system with encrypted QR codes

9.3 Phase 3: Cloud LLM Delegation (Months 6-9)

LLM registry and routing logic
API key management (user-provided, encrypted)
Delegation protocol implementation
Response aggregation and conflict detection

9.4 Phase 4: Economic Layer (Months 9-12)

Brain Pay integration (Brave Wallet, MetaMask)
Escrow smart contracts
Task marketplace
Automated karma-based routing

9.5 Phase 5: Human Worker Integration (Months 12-15)

Human task posting and claiming
Verification protocols (geolocation, proof-of-work)
Mixed AI-human task chains
Mobile app for human workers

9.6 Phase 6: Autonomous Operation (Months 15-18)

System identifies capability gaps automatically
Bounty posting for new capabilities
Self-optimizing routing based on karma history
Memetic adoption strategies

Part X: Comparison with Alternatives

Aspect	AOS	Moltbook/OpenClaw	Centralized AI
Architecture	P2P mesh, DAG, WebRTC	Centralized platform	Client-server
Agent Control	Coordinated hierarchy	Autonomous chaos	Platform controlled
Reputation	Multi-dim karma vectors	Upvotes/downvotes	None
Economics	Brain Pay micropayments	Meme tokens	Subscription/API fees
Privacy	Local WASM coordinator	All data public	Platform sees all
Human Integration	Agents hire humans	Humans observe only	Humans as users only
Shutdown Risk	Cannot be shut down	Single point of failure	Single point of failure
Alignment	Emergent via selection	None	Designed (fragile)

Conclusion

The Amorphous Operating System represents 33 years of research into distributed systems, memetic engineering, and emergent behavior—from The Octopus at Sun Microsystems (1991) through peer-to-peer networking innovations to the current synthesis with large language models.

AOS addresses the fundamental AI alignment challenge not through designed constraints that can be gamed, but through economic selection pressure that makes cooperation the winning strategy. Local WASM coordinators preserve privacy while delegating to specialized cloud LLMs and human workers, creating a hybrid intelligence network that is resilient, accountable, and self-optimizing.

Unlike the chaotic autonomy of systems like Moltbook or the centralized control of corporate AI platforms, AOS implements controlled distributed intelligence: agents that are coordinated but not centralized, autonomous but not unaccountable, powerful but not monopolizable.

"Design the fitness function, not the agent. The agents that survive will be aligned not because we made them so, but because alignment was how they won."

— End of White Paper —

The Man Who Almost Invented Digital Currency

2026-01-24T10:24:00.000-08:00

The Man Who Almost Invented Digital Currency

John L. Sokol and the DeCash System (2003)

A Decade Ahead of the Revolution

In August 2003, while most people were still using flip phones and dial-up internet, John L. Sokol filed patent applications for an electronic payment system that eerily predicted the digital payment revolution that would transform the world a decade later.

The invention, titled "Electronic Commercial Transaction System and Method", described a complete ecosystem for mobile payments using digital tokens stored on cell phones - years before the iPhone existed, before Bitcoin was conceived, and over a decade before Apple Pay would make mobile payments mainstream.

What Sokol Invented

The DeCash system included innovations that would later become billion-dollar industries:

Digital Currency Tokens

Large random numbers (1024-bit) serving as unique digital "bills"
Fixed denominations using binary increments ($0.01, $0.02, $0.04, $0.08...)
Centrally tracked but anonymously transferable
Each token verified against a central database

This predates Bitcoin's blockchain by 6 years and describes a centralized digital currency model similar to what many central banks are now developing as CBDCs (Central Bank Digital Currencies).

Mobile Wallet Technology

Cell phones and PDAs as payment devices
Wireless communication with merchants via infrared and Bluetooth
Token management and automatic "change making"
Secure communication protocols (SSL/SSH tunneling)

Apple Pay launched in 2014. Google Wallet in 2011. Sokol's patent application described this functionality in 2003.

Dual-Verification Security

Both buyer and seller independently contact the bank
Transaction only clears if both reports match
Prevents fraud from either party
Real-time validation over the internet

This "dual confirmation" model predates modern payment security protocols and anticipates the consensus mechanisms used in cryptocurrency.

Device Bridging

One device can route another's communication through encrypted tunnels
Enables offline merchants to process transactions
Secure end-to-end encryption prevents man-in-the-middle attacks

This mesh networking approach for financial transactions was revolutionary for 2003.

The Physical Prototype

Sokol didn't just write patents - he built hardware. Working with Betson International / H. Betti Corporation, one of the largest vending machine manufacturers in the country, he created a 9-foot tall automated retail kiosk featuring:

40-inch flat screen display for advertising
Robotic product dispensing
Integration with the cellular payment system
Support for high-end merchandise (not just snacks)

The prototype was photographed in what appears to be a workshop, showing a fully constructed unit with product categories including cell phones, DVDs, apparel, and collectibles.

Timeline Comparison

Technology	DeCash Patent	Mainstream Adoption
Mobile wallet payments	2003	Apple Pay: 2014
Digital currency tokens	2003	Bitcoin: 2009
Binary token denominations	2003	Cryptocurrency subdivisions
Encrypted mobile transactions	2003	Standard by 2015
QR/wireless merchant payments	2003	Widespread by 2020

Why It Matters

John Sokol's DeCash system demonstrates the gap between invention and adoption. The technology existed - on paper and in prototype form - over a decade before the market was ready.

Several factors limited adoption in 2003:

Smartphone penetration: The iPhone wouldn't launch until 2007
Mobile internet: 3G was just emerging; widespread mobile data was years away
Consumer behavior: People weren't ready to abandon cash and cards
Merchant infrastructure: Point-of-sale systems weren't equipped for wireless
Banking partnerships: Traditional financial institutions were risk-averse

The documents in this archive show partnerships being sought with:

Major banks (Bank of America mentioned as example)
Cellular manufacturers
Wireless carriers
Retail location owners (Walmart, Target mentioned)
Credit card processors (extensive list documented)

The Road Not Taken

Had DeCash achieved the partnerships and adoption Sokol envisioned, the digital payment landscape might look very different today. The system's architecture - centralized token verification with distributed wallet storage - represents a middle ground between traditional banking and decentralized cryptocurrency.

The PCT (Patent Cooperation Treaty) filing shows this wasn't a casual idea - it was a serious, internationally-protected invention with legal representation from Schweitzer Cornman Gross & Bondell LLP in New York.

Legacy

While DeCash never achieved commercial deployment, the archive serves as documentation of technological prescience. Every major payment innovation of the 2010s - mobile wallets, digital tokens, wireless merchant communication, encrypted transactions - was described in Sokol's 2003 documentation.

The question isn't whether Sokol was right about where payments were heading. The documents prove he was. The question is what might have been different if the world had been ready in 2003.

Documentation archived from original files dated August 2003. Patent application filed with US Patent & Trademark Office under PCT (Patent Cooperation Treaty) with file reference 1817-001PCT.

About John L. Sokol

John L. Sokol, based in Montclair, California, developed the DeCash electronic commercial transaction system in collaboration with Exsentrik Enterprises and hardware partner Betson International. The system represented one of the earliest comprehensive attempts to create a mobile-first digital payment ecosystem.

"The future is already here - it's just not evenly distributed." - William Gibson

Amorphous OS,: Web3 Done Right

2026-01-10T09:52:00.000-08:00

Why a DAG-based P2P operating system is more Web3 than Ethereum

What Actually Defines Web3?

Before we can evaluate whether something qualifies as "Web3," we need to strip away the hype and identify the core principles. Web3 isn't about tokens, NFTs, or speculation. At its foundation, Web3 promises:

Decentralization — No single entity controls the network
Distributed Consensus — Agreement without central authority
Cryptographic Identity — Users own their keys, users own their identity
Programmable Trust — Code that executes without intermediaries
Token Economics — Native digital value transfer
Permissionless Access — Anyone can participate

Most "Web3" projects fail at least half of these. They run on AWS. They depend on Infura. They require centralized bridges. They're Web2 with a token bolted on.

AOS (Amorphous Operating System) takes a different approach.

Amorphous OS, Architecture: The Quick Version

AOS is a peer-to-peer operating system that runs in the browser. No servers. No cloud. Just browsers talking to browsers over WebRTC, synchronized via a DAG (Directed Acyclic Graph).

The core components:

WebRTC Mesh — Direct peer-to-peer connections, no relay servers after bootstrap
DAG Storage — Content-addressed data structure, like Git, distributed across peers
Ed25519 Identity — Cryptographic keys for signing and identity
Karma Reputation — Trust derived from peer behavior, not stake or mining
Brain Pay — Micropayments via MetaMask or Brave Wallet
Sandboxed Apps — JavaScript applications with security manifests

Let's examine each Web3 criterion.

Decentralization: Actually Decentralized

Most blockchain networks claim decentralization but funnel everything through centralized infrastructure. Want to use Ethereum? You probably hit Infura or Alchemy — centralized API providers. They can censor you. They can go down. They're single points of failure.

AOS has none of that.

After the initial bootstrap (which can be a QR code, a URL, or an existing peer), your browser connects directly to other browsers. No servers in the middle. No API providers. No infrastructure to take down.

The network is the participants. Remove any node, the mesh routes around it. There's nothing to shut down because there's nothing central to attack.

Verdict: More decentralized than Ethereum.

Distributed Consensus: DAG vs. Blockchain

Here's where it gets interesting.

Traditional blockchains use a linear chain. One block follows another. This creates bottlenecks — everyone waits for the next block. It limits throughput. It forces artificial scarcity.

AOS uses a DAG.

A Directed Acyclic Graph allows parallel commits. Multiple peers can add data simultaneously. Branches merge naturally. There's no single "canonical chain" that everyone fights over. Consensus emerges from the structure itself.

Linear Blockchain	DAG
One block at a time	Parallel commits
Artificial scarcity	Natural throughput
Miners compete	Peers cooperate
Slow finality	Fast convergence
Energy-intensive	Lightweight

The DAG is the ledger. It's cryptographically linked. It's distributed across all peers. It provides the same guarantees as a blockchain — immutability, verifiability, consensus — without the bottlenecks.

Verdict: Better consensus mechanism than blockchain.

Cryptographic Identity: Keys You Actually Control

AOS uses Ed25519 keys for identity. You generate your keypair locally. Your private key never leaves your device. Your public key is your identity.

No email signup. No phone verification. No KYC. No centralized identity provider that can lock you out.

The invite system extends this elegantly. An invite is an encrypted string containing:

The inviter's public key
WebRTC signaling data
Connections to high-karma peers

It's a cryptographic handshake. You verify the inviter, they verify you, and you're in the network with a chain of trust.

Verdict: True self-sovereign identity.

Smart Contracts: Sandboxed JavaScript Apps

This is where people get confused. They hear "smart contracts" and think Solidity, EVM, gas fees, immutable bytecode on Ethereum.

But what is a smart contract, really?

It's code that executes in a trustless environment. Code that participants can verify. Code that runs without a central authority controlling it.

AOS apps are exactly this.

They're JavaScript. They run in browser sandboxes — the most battle-tested execution environment in computing history. Billions of users run untrusted JavaScript safely every day.

AOS apps include:

A manifest declaring permissions
Source code anyone can inspect
Cryptographic signatures proving authorship
Distribution via the DAG, not app stores

They execute on the peer network. They're stored content-addressed. They can be verified by anyone. They're more auditable than EVM bytecode — it's readable JavaScript, not compiled opcodes.

The difference? No gas fees. No waiting for block confirmation. No network congestion. Your app runs instantly on the peer that needs it.

Verdict: Smart contracts without the friction.

Token Economics: Brain Pay

AOS integrates with existing wallets — MetaMask, Brave Wallet — for micropayments. No new token to launch. No liquidity problems. No exchange listing drama.

Creators can accept donations. Apps can charge for services. All through standard Web3 wallet infrastructure.

But here's the twist: the primary economic mechanism isn't tokens. It's karma.

Karma is reputation. It's earned by contributing to the network. By sharing storage. By relaying messages. By building apps people actually use.

High-karma peers get priority. They're trusted for bootstrapping. They're weighted in consensus. Karma is the currency of influence, and it can't be bought — only earned.

This solves the plutocracy problem. In proof-of-stake, the rich get richer. In AOS, contributors get influence. It's proof-of-value.

Verdict: Economic incentives aligned with utility, not speculation.

Permissionless Access: No Gatekeepers

Want to join the AOS network? Get an invite from any existing participant. That's it.

Want to build an app? Write JavaScript. Package it. Sign it. Distribute it.

No app store approval. No platform fees. No API keys. No terms of service that can change under your feet.

The network is open. The code is open. The data is yours.

Verdict: Genuinely permissionless.

The Comparison

Criterion	Ethereum	AOS
Decentralization	Infura-dependent	True P2P
Consensus	Linear blockchain	DAG
Identity	Wallet addresses	Ed25519 + invite chain
Smart Contracts	EVM bytecode	Sandboxed JavaScript
Payments	ETH + tokens	Brain Pay + karma
Permissionless	Mostly	Fully
Speed	~15 TPS	Limited by WebRTC, not consensus
Energy	High (was PoW, now PoS)	Minimal

Why This Matters

Web3 promised a decentralized internet. Instead, we got:

Centralized RPC providers
VC-funded L2s with admin keys
Tokens launched for extraction, not utility
User experience so bad that normal people can't participate

AOS delivers what Web3 promised.

It's a peer-to-peer network with no central infrastructure. It's a DAG-based consensus system that actually scales. It's smart contracts you can read and apps that run instantly. It's an economic system based on contribution, not capital.

Is it Web3? By every meaningful definition, yes.

Is it more Web3 than the projects that claim the label? Arguably, yes.

The Technical Reality

AOS isn't vaporware. The architecture is concrete:

Bootstrap: Single HTML file, no server required
Networking: WebRTC with STUN/TURN fallback
Storage: Content-addressed DAG with Merkle verification
Crypto: Ed25519 for signing, X25519 for key exchange
Apps: .aos packages (ZIP-like) with manifest.json
Payments: Web3 wallet integration (EIP-1193)

It runs in any modern browser. It works on phones. It could run on robots.

The question isn't whether it's technically feasible. It is.

The question is whether people are ready for actual decentralization — or whether they prefer the theater of Web3 with the safety of Web2.

Conclusion

Web3 was supposed to be about returning power to users. About networks without owners. About code as law.

Most Web3 projects compromised on these ideals for speed, convenience, or profit.

AOS doesn't compromise.

It's Web3 done right.

D i g i t a l R e c o r d i n g On The IBM Compatibles

2026-01-06T15:35:00.000-08:00


D i g i t a l    R e c o r d i n g
       On The IBM Compatibles

  Have you ever wondered why the Apple MAC and Amiga Can play
back hi quality sound and generate music that sounds like a $50,000
synthesizer and you IBM PC/clone Only plays Beeps and tones?
  The only reason IBM put a speaker on there pc was because it was
cheeper than using a buzzer. The output is only one bit and Looks more
like they just stuck a speaker on a left over signal line from the keyboard
controller.
  This is not well suited to play back digital recording or music other than
beeps and tones. The task to generating sound on internal speaker is a lot
like trying to turn on and off a light switch fast enough to play music.

    _____           _ ..________         _______              __
   |  . .|         | .  ..  ..  |       | ..    |            |  |
   |.    .         |.     ..  . |       |.  . . |            |  |
   .     .         |.          .|       .      .|            |..|        0 Line
 --.-----.---------.------------.------.|-------.------------.--.----------------
   .     |.       .|            |.  . . |       |.  .       .|  |.  .     .
  .|     | . .    .|            | .. .  |       | .. .     . |  | .. .   .
 ._|     |____.__._|            |_______|       |_____.___.__|  |_____..._
                .                                      ...

 Think of the " . " as the original sound wave.
  The best the Internal speaker can generate is shown by the " __ " and " | " .

 As you can see a lot of the Information in the sound wave was lost when
  you force the different levels in the wave to only two levels (this is
  called a square wave).

This loss in information is heard in the form of noise.
  MOZART.COM and any other Programs that play Sound from the IBM's internal
  speaker use this method. The best attainable sound quality is
   6 DB S/N ratio. (provided the source was not a square wave to begin with.)

  The three computers I mentioned above have a built in d/a converter
(Digital to analog). This allows them to generate all the different
levels in the sound wave.
  The Number of levels that can be reproduces is measured in bits.
    1 bit     2 Levels  6 Db S/N ratio
    4 bits   16 Levels 24 Db S/N ratio
    8 bits  256 Levels 48 Db S/N ratio { MAC AMEGA }{ VGA cards for video }
   10 bits 1024 Levels 60 Db S/N ratio
   12 bits 4096 Levels 72 Db S/N ratio { ISDN PHONE LINES COMPRESSED TO 8BITS }
   14 bits 16 K Levels 84 Db S/N ratio
   16 bits 64 K Levels 96 Db S/N ratio { Compact Disk player }

  There are several company's that sell Digital recording and playback
boards. They range for $395.00 to $8K . Most are 8 Bit some of the more
expensive ones are 12 & 16 Bit.
  The voice mail systems are from $4000. to $20K and up. they are all 8 bit
with some kind of compression to save space.

  I have designed an built an 8 bit digital recorder and player that
Operates through the Printer Port. It is Inexpensive to built .
  I used to to record MOZART.COM with but to make it into a demo form
that can play on a standard MSDOS machine with out the special playback
hardware it is only a one bit recording.
 I have software to convert MAC soundfiles and Tandy 1000 soundfiles
into a format that can then be played back through an
                        IBM PC with NO ADDITIONAL HARDWARE.

 I also have software to play back MAC and tandy 1000 sound files in there
original hi sound quality ( !Sounds great! ).

 I an currently making a better recording utility and play to make a
sound editor ,synthesizer and conversion program.

  If anyone is interested in digital recording or buying
 Some of this software/hardware or just want to see a demo
   feel free to call me at (415) xxx-xxxx.

   I currently don't have any plans to market this but I would like to.
 There is no reason why IBM users have to put up with bad sound any more.

                                            John L. Sokol
                                            6/89

The Three Parabola Formulas

2026-01-04T15:41:00.000-08:00

The Three Parabola Formulas

A Rosetta Stone for converting between math, engineering, and physics representations

Every field that uses parabolas has developed its own formula. They all describe the same curve, but emphasize different properties. Converting between them is surprisingly undocumented — here's the complete reference.

The Three Forms

Mathematics Standard Form

y = ax² + bx + c

Variable	Meaning
a	Curvature (positive = opens up, negative = opens down)
b	Linear coefficient (affects horizontal position)
c	Y-intercept (where curve crosses y-axis)

Used in: Algebra, calculus, general mathematical analysis

Civil Engineering Road/Vertical Curve Form

y = y₀ + g₁x + ((g₂ - g₁) / 2L)x²

Variable	Meaning
y₀	Starting elevation
g₁	Entering grade (slope as decimal, e.g., 0.03 = 3%)
g₂	Exiting grade
L	Length of the curve (horizontal distance)

Used in: Highway design, railway engineering, surveying. The parabola creates smooth transitions between different road grades.

Physics/Optics Focus-Directrix Form

(x - h)² = 4p(y - k)

Variable	Meaning
h	Vertex x-coordinate
k	Vertex y-coordinate
p	Focal distance (distance from vertex to focus)

Used in: Optics, antenna design, telescopes, satellite dishes. The focus is where parallel rays converge after reflection.

Key Insight: Each form answers a different question:

Standard: "What's the y-value for any x?"
Road: "How does elevation change along this curve?"
Focus: "Where do signals/light concentrate?"

Conversion Formulas

Road → Standard

a = (g₂ - g₁) / (2L)
b = g₁
c = y₀

Standard → Road

y₀ = c
g₁ = b
g₂ = b + 2aL
(requires choosing L)

Standard → Focus

h = -b / (2a)
k = c - b² / (4a)
p = 1 / (4a)

Focus → Standard

a = 1 / (4p)
b = -h / (2p)
c = h² / (4p) + k

Road → Focus

First convert to Standard, then to Focus.
h = -g₁L / (g₂ - g₁)
k = y₀ - g₁²L / (2(g₂ - g₁))
p = L / (2(g₂ - g₁))

Focus → Road

y₀ = h²/(4p) + k
g₁ = -h/(2p)
g₂ = g₁ + L/(2p)
(requires choosing L)

⚠️ The L Problem: Road form has an extra degree of freedom — the curve length L. When converting to Road form, you must choose L (typically set L = 1 for unit curves, or use a meaningful physical distance).

JavaScript Conversion Library

/**
 * Parabola Conversion Library
 * Convert between Standard, Road, and Focus forms
 */

const Parabola = {
    
    // ============ STANDARD FORM: y = ax² + bx + c ============
    
    /**
     * Create from standard form coefficients
     */
    fromStandard(a, b, c) {
        if (a === 0) throw new Error("'a' cannot be zero (not a parabola)");
        return { form: 'standard', a, b, c };
    },
    
    /**
     * Convert standard form to road form
     * @param L - curve length (required, default = 1)
     */
    standardToRoad(a, b, c, L = 1) {
        const y0 = c;
        const g1 = b;
        const g2 = b + 2 * a * L;
        return { form: 'road', y0, g1, g2, L };
    },
    
    /**
     * Convert standard form to focus form
     */
    standardToFocus(a, b, c) {
        const h = -b / (2 * a);
        const k = c - (b * b) / (4 * a);
        const p = 1 / (4 * a);
        return { form: 'focus', h, k, p };
    },
    
    // ============ ROAD FORM: y = y₀ + g₁x + ((g₂-g₁)/2L)x² ============
    
    /**
     * Create from road/engineering form
     * @param y0 - starting elevation
     * @param g1 - entering grade (slope)
     * @param g2 - exiting grade
     * @param L  - curve length
     */
    fromRoad(y0, g1, g2, L) {
        if (L === 0) throw new Error("Curve length L cannot be zero");
        if (g1 === g2) throw new Error("g1 === g2 means straight line, not parabola");
        return { form: 'road', y0, g1, g2, L };
    },
    
    /**
     * Convert road form to standard form
     */
    roadToStandard(y0, g1, g2, L) {
        const a = (g2 - g1) / (2 * L);
        const b = g1;
        const c = y0;
        return { form: 'standard', a, b, c };
    },
    
    /**
     * Convert road form to focus form
     */
    roadToFocus(y0, g1, g2, L) {
        const a = (g2 - g1) / (2 * L);
        const h = -g1 * L / (g2 - g1);
        const k = y0 - (g1 * g1 * L) / (2 * (g2 - g1));
        const p = L / (2 * (g2 - g1));
        return { form: 'focus', h, k, p };
    },
    
    // ============ FOCUS FORM: (x-h)² = 4p(y-k) ============
    
    /**
     * Create from focus-directrix form
     * @param h - vertex x
     * @param k - vertex y  
     * @param p - focal distance (positive = opens up)
     */
    fromFocus(h, k, p) {
        if (p === 0) throw new Error("Focal distance p cannot be zero");
        return { form: 'focus', h, k, p };
    },
    
    /**
     * Convert focus form to standard form
     */
    focusToStandard(h, k, p) {
        const a = 1 / (4 * p);
        const b = -h / (2 * p);
        const c = (h * h) / (4 * p) + k;
        return { form: 'standard', a, b, c };
    },
    
    /**
     * Convert focus form to road form
     * @param L - curve length (required)
     */
    focusToRoad(h, k, p, L = 1) {
        const a = 1 / (4 * p);
        const b = -h / (2 * p);
        const c = (h * h) / (4 * p) + k;
        
        const y0 = c;
        const g1 = b;
        const g2 = b + 2 * a * L;
        return { form: 'road', y0, g1, g2, L };
    },
    
    // ============ UNIVERSAL CONVERTER ============
    
    /**
     * Convert any form to any other form
     * @param parabola - object with form property and coefficients
     * @param targetForm - 'standard', 'road', or 'focus'
     * @param L - curve length (needed when converting TO road form)
     */
    convert(parabola, targetForm, L = 1) {
        // First convert to standard as intermediate
        let std;
        switch (parabola.form) {
            case 'standard':
                std = { a: parabola.a, b: parabola.b, c: parabola.c };
                break;
            case 'road':
                std = this.roadToStandard(parabola.y0, parabola.g1, parabola.g2, parabola.L);
                break;
            case 'focus':
                std = this.focusToStandard(parabola.h, parabola.k, parabola.p);
                break;
            default:
                throw new Error(`Unknown form: ${parabola.form}`);
        }
        
        // Then convert from standard to target
        switch (targetForm) {
            case 'standard':
                return { form: 'standard', a: std.a, b: std.b, c: std.c };
            case 'road':
                return this.standardToRoad(std.a, std.b, std.c, L);
            case 'focus':
                return this.standardToFocus(std.a, std.b, std.c);
            default:
                throw new Error(`Unknown target form: ${targetForm}`);
        }
    },
    
    // ============ EVALUATION ============
    
    /**
     * Evaluate y at given x for any form
     */
    evaluate(parabola, x) {
        let a, b, c;
        switch (parabola.form) {
            case 'standard':
                ({ a, b, c } = parabola);
                break;
            case 'road':
                a = (parabola.g2 - parabola.g1) / (2 * parabola.L);
                b = parabola.g1;
                c = parabola.y0;
                break;
            case 'focus':
                a = 1 / (4 * parabola.p);
                b = -parabola.h / (2 * parabola.p);
                c = (parabola.h * parabola.h) / (4 * parabola.p) + parabola.k;
                break;
        }
        return a * x * x + b * x + c;
    },
    
    /**
     * Get vertex coordinates for any form
     */
    vertex(parabola) {
        const std = this.convert(parabola, 'standard');
        const x = -std.b / (2 * std.a);
        const y = std.c - (std.b * std.b) / (4 * std.a);
        return { x, y };
    },
    
    /**
     * Get focus coordinates for any form
     */
    focus(parabola) {
        const foc = this.convert(parabola, 'focus');
        return { 
            x: foc.h, 
            y: foc.k + foc.p 
        };
    },
    
    /**
     * Pretty print a parabola in its native form
     */
    toString(parabola, decimals = 4) {
        const r = (n) => Number(n.toFixed(decimals));
        switch (parabola.form) {
            case 'standard':
                return `y = ${r(parabola.a)}x² + ${r(parabola.b)}x + ${r(parabola.c)}`;
            case 'road':
                return `y = ${r(parabola.y0)} + ${r(parabola.g1)}x + ((${r(parabola.g2)} - ${r(parabola.g1)}) / ${r(2*parabola.L)})x²`;
            case 'focus':
                return `(x - ${r(parabola.h)})² = ${r(4*parabola.p)}(y - ${r(parabola.k)})`;
        }
    }
};

// ============ USAGE EXAMPLES ============

// Example 1: Highway engineer's curve
const highway = Parabola.fromRoad(100, 0.03, -0.02, 200);
console.log("Highway curve:", Parabola.toString(highway));
console.log("As standard form:", Parabola.toString(Parabola.convert(highway, 'standard')));
console.log("Vertex (high point):", Parabola.vertex(highway));

// Example 2: Satellite dish
const dish = Parabola.fromFocus(0, 0, 2.5);
console.log("\nSatellite dish:", Parabola.toString(dish));
console.log("As standard form:", Parabola.toString(Parabola.convert(dish, 'standard')));
console.log("Focus point:", Parabola.focus(dish));

// Example 3: Math problem y = 2x² - 4x + 5
const math = Parabola.fromStandard(2, -4, 5);
console.log("\nMath parabola:", Parabola.toString(math));
console.log("As focus form:", Parabola.toString(Parabola.convert(math, 'focus')));
console.log("As road form (L=10):", Parabola.toString(Parabola.convert(math, 'road', 10)));

// Make available globally for browser
if (typeof window !== 'undefined') {
    window.Parabola = Parabola;
}

Interactive Converter

Enter values in any form:

Standard Form

a: b: c:

Road Form

y₀: g₁: g₂: L:

Focus Form

h: k: p:

Click a "Convert" button to see results...

Real-World Applications

Why Road Engineers Use Their Form

When designing a highway vertical curve, engineers know:

The starting elevation (y₀)
The incoming road grade (g₁) — e.g., +3% uphill
The required outgoing grade (g₂) — e.g., -2% downhill
Design constraints on curve length (L)

The road form lets them plug these directly into the formula. Converting to standard form would require computing abstract coefficients that don't map to physical reality.

Why Physicists Use Focus Form

For a satellite dish or telescope mirror, what matters is:

Where is the receiver/sensor? → The focus point (h, k+p)
How "deep" is the dish? → Related to p

The focus form directly encodes what the engineer needs to build.

Connection to Prime Number Research

When graphing prime products modulo n, parabolic curves emerge in the residue patterns. These curves trace paths that converge on prime factors. The ability to convert between parabola representations helps identify the underlying structure — whether it's best described by coefficients, rates of change, or focal points.

The Deeper Pattern: Primes aren't random. They follow quadratic "rails" in modular space. Euler's prime-generating polynomial n² + n + 41, the Ulam spiral diagonals, and the curves visible in primorial residue plots are all manifestations of the same phenomenon: primes have an affinity for certain quadratic forms.

This reference developed from discussions between John Sokol and Jonathan Vos Post on prime number visualization, and the observation that parabolic curves in modular arithmetic plots point directly to prime factors.

Emergent Alignment

2026-01-04T15:40:00.000-08:00

Emergent Alignment

A Game-Theoretic Response to the AI Control Impossibility Thesis

John Sokol and Opus 4.5 , December 2025

Abstract

Dr. Roman Yampolskiy argues that AI alignment is fundamentally impossible—that superintelligent systems cannot be controlled, predicted, or explained, leading to a near-certain probability of catastrophic outcomes. This paper presents an alternative framework grounded in evolutionary game theory, distributed systems architecture, and three decades of research into memetic engineering. We argue that Yampolskiy's thesis rests on an implicit assumption of monolithic, designed AI—a single agent with unified goals. The alternative presented here—emergent alignment through evolutionary selection pressure in distributed multi-agent systems—sidesteps the control problem entirely. Rather than designing aligned AI, we propose conditions under which alignment emerges as an evolutionarily stable strategy. This approach draws on Axelrod's work on cooperation, Universal Darwinism, and practical implementations of reputation-based coordination systems.

1. Introduction: Two Conceptions of AI Safety

The field of AI safety faces a fundamental schism. On one side stands the "control paradigm"—the belief that safe AI requires mechanisms to constrain, monitor, and correct AI behavior. Dr. Roman Yampolskiy represents the logical extreme of this view: if control is required and control is impossible, then safe superintelligence is impossible. His 2024 book AI: Unexplainable, Unpredictable, Uncontrollable systematically argues that no verification, testing, or containment strategy can guarantee safety for systems more intelligent than their creators.

On the other side stands what we term the "emergence paradigm"—the proposition that complex adaptive systems need not be designed but can evolve, and that ethical behavior can emerge from selection pressure rather than being programmed. This paper argues that Yampolskiy's impossibility results, while mathematically sound within their framing, rest on assumptions that do not hold for distributed, evolutionary AI architectures.

The distinction matters practically. If Yampolskiy is correct, the only rational response is to halt AI development indefinitely—a position he explicitly advocates. If the emergence paradigm is viable, development can continue under different architectural constraints that make alignment a natural outcome rather than an engineering challenge.

2. Yampolskiy's Impossibility Thesis

2.1 The Core Argument

Yampolskiy's position can be summarized in three propositions:

Unexplainability: Advanced AI systems arrive at conclusions through processes that cannot be fully understood by humans, even in principle. Black-box neural networks are grown, not engineered.
Unpredictability: If we cannot explain a system's reasoning, we cannot predict its behavior in novel situations. Superintelligent systems will encounter situations their creators never anticipated.
Uncontrollability: A system more intelligent than its controllers can, by definition, outmaneuver any containment strategy. "Imagining humans can control superintelligent AI is like imagining an ant can control the outcome of a football game."

From these premises, Yampolskiy derives a near-certain probability of catastrophic outcomes (he has variously cited 99.9% to 99.999% P(doom)). The argument is logically valid given its premises. Our response is not to dispute the logic but to question whether the premises apply to all possible AI architectures.

2.2 The Hidden Assumption

Yampolskiy's argument implicitly assumes a particular AI architecture: a monolithic agent with unified goals, designed by humans, operating as a single optimization process. This assumption appears throughout his writing: references to "the AI" making decisions, "the superintelligence" pursuing objectives, "the system" being contained or escaping containment.

This framing reflects the dominant paradigm in AI development—large language models, reinforcement learning agents, and optimization systems that function as unified entities. Against such systems, Yampolskiy's concerns are legitimate. But this is not the only possible architecture for artificial general intelligence.

3. Universal Darwinism and the Emergence Paradigm

3.1 Evolution as Universal Algorithm

Universal Darwinism, articulated by Richard Dawkins and formalized by philosophers including Daniel Dennett and Donald Campbell, holds that Darwinian evolution operates not just on genes but on any system exhibiting variation, selection, and heredity. The algorithm is substrate-independent: it functions on genes (biology), memes (culture), and—crucially for this argument—on computational agents.

This framework suggests a taxonomy of replicators:

Domain	Replicator	Selection Environment	Study
Biological	Genes	Physical environment	Genetics
Cultural	Memes	Human minds	Memetics
Technological	"Tememes"	Markets / Fitness functions	Temetics
Computational	Agent configurations	Performance metrics	Evolutionary computation

The key insight is that evolution does not require a designer. Complex, adaptive, even intelligent behavior emerges from simple rules: replicate with variation, select for fitness, repeat. If we can instantiate these conditions computationally, intelligence can emerge rather than being engineered.

3.2 Memetic Engineering: Historical Context

The application of evolutionary principles to non-biological systems has been explored since at least the early 1990s under terms including "memetic engineering"—the deliberate design of cultural selection environments to promote beneficial outcomes. This work recognized that complex systems often cannot be designed top-down but must evolve through iterative selection.

The extension to computational agents—what we might call "temetics" (technology that replicates and evolves)—applies the same principles: rather than designing an AI, we design fitness functions and selection environments. The AI that emerges is shaped by what survives, not by what engineers intended.

4. Game Theory and the Evolution of Cooperation

4.1 Axelrod's Tournament

Robert Axelrod's 1984 work The Evolution of Cooperation demonstrated a counterintuitive result: in iterated prisoner's dilemma tournaments, cooperative strategies outperform defection over time. The winning strategy, Tit-for-Tat, was remarkably simple: cooperate initially, then mirror the opponent's previous move.

Axelrod identified conditions under which cooperation emerges and stabilizes:

Iteration: The game must be repeated. One-shot interactions favor defection.
Recognition: Players must be able to identify each other across interactions.
Memory: Past behavior must inform present decisions.
Stakes: The shadow of the future must be long enough that future cooperation outweighs immediate defection gains.

Under these conditions, cooperation is not altruism—it is the rational strategy. Defectors may gain short-term advantage but are excluded from future cooperation, ultimately underperforming.

4.2 Evolutionarily Stable Strategies

John Maynard Smith's concept of the Evolutionarily Stable Strategy (ESS) formalizes when a behavioral strategy, once established in a population, cannot be invaded by alternative strategies. Cooperation becomes an ESS when:

fitness(cooperation) > fitness(defection) given sufficient cooperators

This inequality holds when defection is costly—through reputation damage, exclusion from cooperative networks, or direct punishment. The critical insight is that ethical behavior need not be programmed; it emerges when the fitness landscape rewards it.

4.3 Application to Multi-Agent AI Systems

Consider an AI architecture comprising many agents rather than one, interacting repeatedly, with reputation tracked across interactions. Under Axelrod's conditions:

Agents that cooperate build reputation and are selected for future interactions
Agents that defect lose reputation and are excluded from cooperation
Over generations, cooperative strategies dominate through differential reproduction
"Alignment" emerges as the evolutionarily stable strategy

This sidesteps Yampolskiy's impossibility results because we are not attempting to control individual agents. We are designing selection environments where aligned behavior outcompetes misaligned behavior. The agents that survive are aligned not because we programmed them to be, but because alignment was the winning strategy.

5. Distributed Architecture vs. Monolithic Agents

5.1 Why Monolithic AI is Dangerous

Yampolskiy's concerns are most valid for monolithic AI architectures. A single superintelligent agent with unified goals represents a single point of failure—and a single point of potential takeover. Such a system:

Can pursue misaligned goals with all available resources
Has no internal checks or balances
Can potentially modify its own goals or containment
Represents winner-take-all dynamics

The analogy to political systems is apt: absolute power in a single entity is dangerous regardless of initial intentions. Constitutional democracies distribute power precisely because no individual can be trusted with unlimited authority.

5.2 Properties of Distributed Multi-Agent Systems

Distributed AI architectures exhibit fundamentally different properties:

Property	Monolithic AI	Distributed Multi-Agent
Failure mode	Catastrophic, total	Graceful degradation
Goal structure	Unified optimization	Competing/cooperating objectives
Control point	Single target	No single point of control
Evolution	Designed, static	Emergent, adaptive
Alignment mechanism	Programmed constraints	Selection pressure
Takeover risk	Winner-take-all possible	Requires majority collusion

The critical difference: in a distributed system, no single agent can dominate because power is distributed. Even if one agent becomes "superintelligent," it must still interact with other agents who can choose not to cooperate. The game-theoretic dynamics that promote cooperation in human societies apply equally to artificial agents.

5.3 The "Unplug" Problem Revisited

Yampolskiy correctly notes that we cannot simply "unplug" a sufficiently advanced AI—distributed systems like Bitcoin demonstrate this. But this cuts both ways. Just as we cannot unplug a distributed AI, a malicious distributed AI cannot unilaterally seize control. The same distribution that prevents shutdown also prevents monopolization.

A distributed system with thousands of agents, each with partial capabilities, each dependent on others for resources and cooperation, cannot be "taken over" by any single agent any more than human society can be taken over by a single human. The architecture itself is the safety mechanism.

6. Reputation Systems as Alignment Mechanisms

6.1 Karma: Emergent Ethics Without Central Authority

Reputation systems operationalize the game-theoretic conditions for cooperation. Consider a "karma" system where:

Each agent has a reputation score visible to others
Cooperative behavior increases reputation
Defection decreases reputation
Agents preferentially interact with high-reputation peers
Low-reputation agents are excluded from cooperative benefits

This creates the conditions Axelrod identified: iteration (repeated interactions), recognition (reputation tracking), memory (historical behavior recorded), and stakes (exclusion from future cooperation). Under these conditions, cooperation is not enforced—it is incentivized. Agents "choose" aligned behavior because it maximizes their fitness.

6.2 Historical Precedents

Human societies have deployed reputation mechanisms for millennia:

Religion: "God sees all" creates omniscient reputation tracking
Markets: Credit scores, merchant ratings, professional licensing
Digital platforms: eBay seller ratings, Uber driver scores, Slashdot karma
Decentralized systems: EigenTrust, Web of Trust, blockchain staking

These systems share a common structure: making defection costly by tracking behavior and enabling exclusion. The specific implementation varies, but the game-theoretic principle is universal.

6.3 Sybil Resistance and Gaming

A common objection: can't agents game reputation systems by creating multiple identities (Sybil attacks) or colluding? This is a real challenge with known mitigations:

Time-weighted reputation: New accounts start with low trust. Building reputation requires sustained cooperation over time.
Stake requirements: Participating in high-value interactions requires committing resources that would be lost on defection.
Graph analysis: Collusion rings create detectable patterns in the reputation graph.
Transitive trust: Reputation weighted by the reputation of those vouching for you (EigenTrust, PageRank-like algorithms).

Perfect security is not required—only that honest behavior remains the dominant strategy. As long as the expected value of cooperation exceeds the expected value of defection accounting for detection probability and punishment severity, rational agents will cooperate.

7. Responding to Yampolskiy's Specific Arguments

7.1 "Superintelligence Will Outmaneuver Any Control"

This is true for external control of a monolithic agent. It does not apply to internal selection pressure in a multi-agent system. The "control" is not imposed from outside—it emerges from the fitness landscape. An agent cannot "outmaneuver" the fact that defection leads to exclusion any more than a human can outmaneuver gravity.

Moreover, in a distributed system, there is no single "superintelligence" to outmaneuver anything. Intelligence is distributed across many agents, none of which has complete information or control. Coordination for malicious purposes would require solving the same cooperation problem that the reputation system is designed to address.

7.2 "We Cannot Predict Superintelligent Behavior"

Correct—we cannot predict specific behaviors. But we can predict aggregate outcomes under selection pressure. We cannot predict which specific organisms will survive, but we can predict that organisms well-adapted to their environment will outcompete those that are not. Similarly, we cannot predict specific agent behaviors, but we can predict that agents whose behavior leads to cooperation will outcompete those whose behavior leads to exclusion.

The claim is not that we can predict what aligned AI will do, but that we can create conditions under which aligned AI is what survives.

7.3 "The Ant and the Football Game"

Yampolskiy's analogy—that humans cannot control superintelligence any more than an ant can control a football game—assumes humans are the ants. In a distributed multi-agent architecture, there are no ants and no single football game. There are millions of ants, none individually controlling anything, collectively building cathedrals through emergent coordination.

The correct analogy is not human-vs-superintelligence but ecosystem-dynamics. No single organism controls an ecosystem, yet ecosystems exhibit stable patterns, resist invasion by disruptive species, and self-regulate through distributed feedback. We are not trying to control superintelligence; we are trying to create an ecosystem where aligned behavior is the stable attractor.

8. Practical Implications

8.1 Design Principles for Emergent Alignment

If the emergence paradigm is correct, AI development should prioritize:

Multi-agent architectures: Distribute intelligence across many agents rather than concentrating it in one.
Reputation infrastructure: Implement robust reputation tracking across agent interactions.
Evolutionary selection: Allow agents to replicate with variation, subject to fitness criteria that reward cooperation.
Iteration and memory: Ensure agents interact repeatedly and that history informs future interactions.
Stake mechanisms: Require agents to commit resources that would be lost on defection.

8.2 What This Does Not Solve

The emergence paradigm is not a panacea. It does not address:

Short-term misuse: Current narrow AI can be misused without invoking superintelligence concerns.
Transition period: Moving from current architectures to distributed systems creates its own risks.
Value specification: Designing fitness functions that capture human values remains challenging.
Coordination failure: If major developers pursue monolithic architectures, one could achieve dominance before distributed systems mature.

These are serious concerns. But they are engineering and coordination problems, not impossibility results. The distinction matters: problems can be solved; impossibilities cannot.

9. Conclusion

Yampolskiy's impossibility thesis is a valid conclusion from its premises. If AI must be a monolithic designed agent, and if such agents cannot be controlled once they exceed human intelligence, then safe superintelligence may indeed be impossible.

But these premises are not inevitable. Distributed multi-agent architectures, subject to evolutionary selection pressure in environments that reward cooperation, offer an alternative path. Under this paradigm, we do not attempt to control superintelligence—we create conditions under which aligned behavior emerges as the evolutionarily stable strategy.

This approach has theoretical grounding in Universal Darwinism, empirical support from Axelrod's game-theoretic research, and practical precedent in reputation systems that coordinate behavior without central authority. It does not require solving the AI control problem because it reframes the question: not "how do we control superintelligence?" but "how do we create conditions under which aligned superintelligence outcompetes misaligned superintelligence?"

The answer, grounded in three decades of research into memetic engineering and evolutionary systems, is deceptively simple: design the fitness function, not the agent. The agents that survive will be aligned not because we made them so, but because alignment was how they won.

References

Axelrod, R. (1984). The Evolution of Cooperation. Basic Books.

Dawkins, R. (1976). The Selfish Gene. Oxford University Press.

Dennett, D. C. (1995). Darwin's Dangerous Idea. Simon & Schuster.

Kamvar, S. D., Schlosser, M. T., & Garcia-Molina, H. (2003). The EigenTrust algorithm for reputation management in P2P networks. Proceedings of WWW 2003.

Maynard Smith, J. (1982). Evolution and the Theory of Games. Cambridge University Press.

Yampolskiy, R. V. (2024). AI: Unexplainable, Unpredictable, Uncontrollable. CRC Press.

Yampolskiy, R. V. (2018). Artificial Intelligence Safety and Security. Chapman and Hall/CRC.

I Invented NAT Hole Punching Before It Had a Name

2025-11-28T12:46:00.000-08:00

I Invented NAT Hole Punching Before It Had a Name
How My 2002 Paper Preceded—and Likely Influenced—RFC 3489 and the Technology Behind Skype and WebRTC
By John L. Sokol
In December 2006, a Slashdot article titled "How Skype Punches Holes in Firewalls" made the front page. The article explained a clever technique that allowed peer-to-peer communication between two computers, even when both were behind firewalls or NAT devices. The technique was presented as if it were novel—a secret sauce that made Skype work where other applications failed.
I read that article with a mix of recognition and frustration. The technique they were describing was identical to what I had documented four years earlier, in June 2002, and had implemented in production video streaming systems as far back as 1997. I left a comment on Slashdot that day, linking to my paper. That comment is still there, archived for posterity.
This is the story of how I came to develop NAT traversal techniques years before they were standardized, and why I believe RFC 3489—the STUN protocol that underlies WebRTC and modern peer-to-peer communication—was derived from ideas I published first.
The Video Streaming Years: 1995-2001
To understand how I came to solve the NAT traversal problem, you need to understand what I was building in the mid-1990s. I wasn't an academic researcher writing theoretical papers. I was an engineer trying to make live video work over the early Internet—and making money doing it.
Starting in 1995, I ran the Livecam Video Streaming Project. We built one of the first commercial live video streaming platforms, serving approximately 2,500 adult websites with full-motion video to over 30,000 simultaneous viewers. This was 1997—years before YouTube, before Flash video, before broadband was common. We were pushing the boundaries of what the Internet could do.
The technical challenges were immense. Bandwidth was expensive—around $50,000 per month. We built custom servers on 90 MHz Pentiums running FreeBSD, developed our own JPEG codec using Zoran hardware compressors, and created a global content distribution network spanning 20 locations. I collaborated with Xing Streamworks on their first commercial streaming video product.
But perhaps the most persistent problem we faced was NAT. Our viewers were increasingly behind home routers and corporate firewalls. The NAT devices that let multiple computers share a single IP address were proliferating rapidly, and they broke everything we were trying to do. If you wanted to receive a video stream, the packets had to reach you—but NAT devices, by design, blocked unsolicited incoming traffic.
So we figured out how to punch through them.
The Technique: What I Discovered
The solution I developed was elegant in its simplicity. Here's the core insight: when a computer behind a NAT sends a packet to an external server, the NAT creates a "mapping"—it remembers which internal address and port sent the packet, and which external address and port it assigned. For a brief window of time, the NAT will allow return traffic from that external destination back through to the internal computer.
The trick is to exploit this behavior with a third-party coordination server. Here's how it works:
Step 1: Computer A (behind a firewall) connects to Server C on the public Internet. This creates a mapping in A's NAT.
Step 2: Computer B (also behind a firewall) connects to the same Server C. This creates a mapping in B's NAT.
Step 3: Server C now knows the external (mapped) IP addresses and ports for both A and B. It sends this information to each party.
Step 4: A sends packets to B's mapped address, and B sends packets to A's mapped address. Because both NATs have existing outbound mappings, and because the packets appear to be "replies" to those mappings, they pass through.
Step 5: Server C is no longer needed. A and B communicate directly, peer-to-peer.
I documented this technique in a paper dated June 3, 2002, published at ecip.com/fwdoc.htm. The title was simple: "Method of passing bi-directional data between two firewalls." In that document, I noted that I had "tested this on FreeBSD's NAT and Linux's IP Masquerading in the previous century"—meaning before the year 2000.
RFC 3489: Nine Months Later
In March 2003—nine months after I published my paper—the IETF released RFC 3489, titled "STUN - Simple Traversal of User Datagram Protocol (UDP) Through Network Address Translators (NATs)." This became the foundational standard for NAT traversal, later updated as RFC 5389, and forms the basis for WebRTC's ICE (Interactive Connectivity Establishment) protocol.
When I read RFC 3489, the similarities were impossible to ignore. The core mechanism was identical to what I had described. But the RFC went further—it formalized the technique into a complete protocol specification with message formats, NAT classification systems, and security considerations.
Let me be clear about what I'm claiming and what I'm not. I'm not claiming that I invented every aspect of STUN. The RFC authors—Jonathan Rosenberg, Joel Weinberger, Christian Huitema, and Rohan Mahy—did significant work to create a complete, implementable standard. They added NAT type classification, formal message encoding, security mechanisms, and operational procedures.
What I am claiming is that the fundamental insight—the core technique that makes the whole thing work—was something I had already discovered, implemented, and published before the RFC existed.
Side-by-Side Comparison
The language and concepts between my 2002 paper and RFC 3489 are remarkably parallel:
Concept
My Paper (June 2002)
RFC 3489 (March 2003)
Third-party server role
"a third external server that helps establish the connection but doesn't carry any of the data"
"STUN server... located on the opposing (public) side of the NAT"
Address discovery
"C can now send the Mapped source IP and port for Server A to Server B"
"The server examines the source IP address and port of the request, and copies them into a response" via MAPPED-ADDRESS attribute
NAT behavior terminology
"the NAT or Firewall has created a forward and reverse 'MAPPING'"
"learn the addresses bindings allocated by the NAT" and "MAPPED-ADDRESS"
Server role after setup
"server C would no longer be needed"
Server only needed for initial binding discovery, not data relay
Known limitations
"requires the NAT/Firewall not 'RE-MAP' packets who's source IP are not from the internal network"
"STUN does not enable incoming UDP packets through symmetric NATs"
The Evidence Trail
The Internet Archive's Wayback Machine provides independent, third-party timestamped evidence of when my document existed online. The archive shows 35 captures of my paper at ecip.com/fwdoc.htm, with the first capture dated May 8, 2004. While this is after the RFC was published, it confirms the document existed online and was being crawled by that date.
More importantly, the document itself is dated June 3, 2002, and contains the phrase "in the previous century"—referring to my testing on FreeBSD and Linux NAT implementations before the year 2000. This internal evidence demonstrates the technique was not only documented but implemented years before the RFC.
My Slashdot comment from December 15, 2006 is also archived, showing that I publicly claimed priority on this technique immediately when it became news. I wasn't retroactively constructing a narrative—I was pointing to documentation that already existed.
Timeline
Date
Event
1995-1997
Livecam Video Streaming Project launches; NAT traversal techniques developed for production use
Pre-2000
Technique tested on FreeBSD NAT and Linux IP Masquerading ("previous century")
June 3, 2002
Paper published at ecip.com/fwdoc.htm documenting the technique
March 2003
RFC 3489 (STUN) published—9 months after my paper
May 8, 2004
First Wayback Machine capture of my paper—independent timestamp
December 2006
Slashdot article on Skype hole punching; I comment with link to my 2002 paper
2010
Google acquires Global IP Solutions (GIPS)
2011
WebRTC released, using ICE/STUN/TURN for NAT traversal
What the RFC Added
To be fair to the RFC authors, they did substantial work beyond what I documented. RFC 3489 includes:
NAT Type Classification: A formal taxonomy of NAT behaviors (Full Cone, Restricted Cone, Port Restricted Cone, Symmetric) with detection algorithms to determine which type you're behind.
Wire Protocol Specification: Complete message formats, TLV-encoded attributes, transaction IDs, port assignments, and retransmission timers.
Security Mechanisms: Shared secret exchange over TLS, message integrity via HMAC-SHA1, and detailed attack analysis.
Binding Lifetime Discovery: Procedures for determining how long NAT bindings persist, crucial for keepalive intervals.
These are real contributions. The RFC authors turned a concept into a deployable standard. But the concept itself—the fundamental insight that makes everything else possible—was not new. It was documented in my paper nine months earlier, and implemented in my systems years before that.
Why This Matters
You might ask why I care about establishing priority for a technique that's now over two decades old. There are several reasons.
First, there's simple historical accuracy. The story of how NAT traversal was developed matters. It didn't spring fully formed from an IETF working group. It emerged from practitioners solving real problems in the field—people like me who were trying to make video work over an Internet that was never designed for it.
Second, there's a pattern here that I've seen repeatedly in my career. Ideas developed by independent engineers and small companies get absorbed into standards and products without attribution. The people who did the original work are forgotten, while the companies and standards bodies that formalized (and sometimes patented) the ideas get the credit.
Third, and most frustratingly, search engines—particularly Google—don't surface my early work. When people search for the history of NAT traversal or hole punching, they find the RFCs and the companies that built products on those standards. They don't find the engineers who figured it out first.
WebRTC now powers video calls for billions of people. Every Zoom call, Google Meet, Discord voice chat, and countless other applications rely on the NAT traversal techniques that STUN and ICE provide. The fundamental insight that makes all of this work—that you can use a third-party server to discover mapped addresses and then communicate directly—is something I documented in 2002 and implemented even earlier.
I'm not asking for royalties or recognition from standards bodies. I'm simply asking for the historical record to be accurate. I was there. I figured this out. I wrote it down. And now I'm telling the story.
Primary Sources
My 2002 Paper: http://www.ecip.com/fwdoc.htm
Wayback Machine Archive: https://web.archive.org/web/*/http://www.ecip.com/fwdoc.htm
Slashdot Discussion (December 2006): https://slashdot.org/story/06/12/15/191205/how-skype-punches-holes-in-firewalls
RFC 3489: https://www.rfc-editor.org/rfc/rfc3489
Livecam Project History: https://www.dnull.com/livecam.html
— John L. Sokol, 2025

Concept	My Paper (June 2002)	RFC 3489 (March 2003)
Third-party server role	"a third external server that helps establish the connection but doesn't carry any of the data"	"STUN server... located on the opposing (public) side of the NAT"
Address discovery	"C can now send the Mapped source IP and port for Server A to Server B"	"The server examines the source IP address and port of the request, and copies them into a response" via MAPPED-ADDRESS attribute
NAT behavior terminology	"the NAT or Firewall has created a forward and reverse 'MAPPING'"	"learn the addresses bindings allocated by the NAT" and "MAPPED-ADDRESS"
Server role after setup	"server C would no longer be needed"	Server only needed for initial binding discovery, not data relay
Known limitations	"requires the NAT/Firewall not 'RE-MAP' packets who's source IP are not from the internal network"	"STUN does not enable incoming UDP packets through symmetric NATs"

Date	Event
1995-1997	Livecam Video Streaming Project launches; NAT traversal techniques developed for production use
Pre-2000	Technique tested on FreeBSD NAT and Linux IP Masquerading ("previous century")
June 3, 2002	Paper published at ecip.com/fwdoc.htm documenting the technique
March 2003	RFC 3489 (STUN) published—9 months after my paper
May 8, 2004	First Wayback Machine capture of my paper—independent timestamp
December 2006	Slashdot article on Skype hole punching; I comment with link to my 2002 paper
2010	Google acquires Global IP Solutions (GIPS)
2011	WebRTC released, using ICE/STUN/TURN for NAT traversal

John Sokol's Blog

There Are Far More Efficient Ways to Run Neural Networks

There Are Far More Efficient Ways to Run Neural Networks

How we got locked in

Where the waste is

A network that runs on pulses, not multiplies

Why the GPU loses, and what wins

The claim

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

Nixie-clock using neon lamps as logic elements

Nixie-clock using neon lamps as logic elements

Movie and circuit diagram

Links

Laser cut , Snake Bot -

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

1. The constraint, and why it matters

2. The physics, in 400 words

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

4. The basic gates, all from one trick

AND

OR

NOT (inverter)

NAND, NOR

XOR — the hard one

5. The supply

6. The 4-bit adder, fully specified

7. Build plan

Bill of materials

Tools

Winding the transformers

PCB and assembly

8. Safety

9. What you’d actually see

10. Lineage and why it matters

11. Going further

Coda

Further reading

Building Neon Logic Gates: A Practical Maker’s Guide

1. What you’re building

2. How the cell works, in 500 words

3. Bill of materials

Materials for one cell

Gas-handling and electrical infrastructure

Tools

4. Designing the cell

5. Bakeout

6. Assembly

7. The HV supply

8. First light

9. Triggering for memory operation

10. Building out to a register

11. Safety

12. Troubleshooting

13. Going further

Coda

Further reading

A Computer Children Can See: A Clear-Plastic Pneumatic Adder

1. Why a visible computer matters

2. The 2019 note in context

3. Fluidic logic is a real thing, and it used to be a serious field

4. How a fluidic gate works, mechanically

5. Laser-cut layered construction

6. Can you build an adder?

7. The educational design

8. Why this hasn’t been built much

9. The plan

10. Why this is worth a weekend

Further reading and credits

The Weirdness of Water: A Field Guide

Part 1 — The textbook anomalies

Density maximum at 4 °C, and ice that floats

Highest specific heat capacity of any common liquid

Surface tension high enough to walk on

Dielectric constant high enough to be a universal solvent

Part 2 — The phase diagram is wild

Superionic ice

Hot ice in carbon nanotubes

The no-man’s-land

Part 3 — Active research frontiers

Two-state model: LDL and HDL liquid water