H₂O

H₂O. Two hydrogens, one oxygen. The formula is so clean and complete-looking that it feels like a full description. It is not. Water is among the strangest substances in existence: it expands when it freezes instead of contracting, it dissolves almost everything, it has a surface tension strong enough for insects to walk on, and when you run electricity through it, what actually happens is not what the formula suggests at all.

This is a specific kind of deception worth naming: complexity hiding in plain sight as simplicity. The formula is not a summary. It is a label on a door. What is behind the door is where the real work happens, and the people who know what is behind the door have access to leverage that is invisible to everyone looking only at the label.

The site is called h2.io partly because of this. The name points at hydrogen, at water, at something that looks elementary and turns out to be the substrate of everything. The logo is a plus and a minus sign. Those are not decorative. They point at the same idea as the anode and the cathode in electrochemistry: two poles, opposite in charge, each doing something entirely different, and the interesting work happening in the relationship between them.

Two Reactions, Not One

Most people learn that passing electricity through water splits it into hydrogen and oxygen. That summary is not wrong, but it is the wrong level of description if you want to do anything useful with it. What actually happens is two entirely different reactions, occurring simultaneously at each electrode, producing entirely different chemistry.

At the cathode (negative), electrons are added to water molecules. Hydrogen kicks off as gas. What remains is a hydroxide ion: alkaline, strongly basic, the chemistry found in lye and lime. The solution around the cathode turns basic.

At the anode (positive), electrons are ripped away from water molecules. Oxygen bubbles off as gas. The hydrogen left behind bonds to a nearby water molecule, forming a hydronium ion: strongly acidic. The solution around the anode turns acidic.

Same water. Same electricity. Two completely different chemical environments, one at each pole. Add a pH indicator and you see it immediately: red on one side, blue on the other. The two sides cancel if you mix them, which is why the textbook summary works as an overall balance. But the magic is entirely in the separation.

From that understanding alone, a remarkable set of things become possible:

• The acid produced at the anode can dissolve metal ore. The dissolved metal replates as pure metal at the cathode. The ions released cycle back to regenerate more acid. Add selective membranes and you get a closed loop: water, salt, and electricity in; refined metal and reusable chemistry out.
• The same cell, operated differently, is a flow battery: energy stored in liquid tanks that scale independently of the cell stack.
• The same chemistry produces pressurised hydrogen directly inside the cell, without a separate compressor.

All of it from the same primitive. The video below is the best practical introduction to electrochemistry I have seen.

The Membrane Is the Insight

The key enabling piece is the ion exchange membrane: a barrier that is not simply open or closed but selectively permeable. It lets negatively charged ions through and blocks positively charged ones, or vice versa. This keeps the chemistry at each electrode from cancelling out in the middle.

Without the membrane, the acid and base mix and neutralise. You are left with the textbook result: water in, water out, some gases. With the membrane, each side of the cell accumulates its own chemistry. You can route that chemistry deliberately, connect the output of one reaction to the input of another. The membrane does not add energy. It adds structure. It turns a diffuse mess into a directed flow.

Commercial ion exchange membranes cost hundreds to thousands of dollars per square foot. The standard approach is post-functionalisation: lay down a polymer film, then run it through a multi-step chemical treatment to activate the ion-selective channels. Expensive materials, expensive process, controlled by a handful of manufacturers. This cost has been the bottleneck blocking practical flow batteries, closed-loop metal refining, and membrane-based fuel cells from reaching the scale they deserve.

Robert Karas spent two years working out a different approach. Instead of post-functionalisation, use pre-functionalised material: ion exchange resin from water softeners, which is already activated at the particle level. The recipe:

1. Grind the resin beads to a fine powder (spice grinder: 1-2 minutes; ball mill for larger batches)
2. Mix 50/50 by volume with PVC cement
3. Spread onto fibreglass cloth, let air-dry

The ions jump from particle to particle through the PVC matrix. The film is selectively permeable without any chemical activation step. Cost: under a dollar per square yard. Materials: hardware store and garden centre.

The underlying observation that this should work came from a research paper. Robert spent two years simplifying it into a reproducible process from common items, then released everything under the CC0 public domain dedication so nobody could patent-troll it. The full recipe, SEM analysis, manufacturing flowchart, and patent filing are at github.com/Rowow1/Open-sourced-off-the-shelf-ion-exchange-membrane.

This is the pattern that recurs everywhere in well-designed systems: the interface that is selective rather than open, the boundary that allows the right things through and blocks the wrong ones. And the pattern for how knowledge should move: understand the primitive deeply, simplify the path to using it, release it so the next person does not have to start from the paper.

The Same Membrane, in Computing

Computing has its own version of this. Not breakthroughs that required new hardware or new mathematics, but moments where someone understood an existing process deeply enough to notice that one small thing could be done differently, and that difference unlocked a completely different set of possibilities.

Copy-on-write is one. When a process forks, the child does not actually receive a copy of the parent's memory. The pages are shared and marked read-only; a copy is only made if one side writes. From outside, it looks like a copy happened. From inside the memory system, almost nothing happened. The insight (that most forked processes read far more than they write) means that forking a process with gigabytes of state takes microseconds, not seconds. That single observation is what makes process snapshots, cheap parallelism, and fork-based sandboxing practical rather than theoretical.

Content-addressable storage is another. Git does not store files by name or location. It stores objects by the hash of their content. Every version of every file is a hash; every commit is a hash of its tree and its parents. The insight is that if you address by content rather than by location, you get deduplication, integrity verification, and distributed consistency for free as structural consequences of how the storage works, not as features you had to build. The same insight underlies package registries, container image layers, and content delivery networks. It is not a new idea each time. It is the same membrane, recognised again.

The pattern in all of these is the same as the membrane: a small observation about the underlying process, invisible if you are only looking at the surface description, that changes what becomes possible once you act on it. The insight is only accessible from inside a genuine understanding of how the process actually works. From outside, it looks like the thing it always looked like. From inside, it is a door.

The Same Pattern in Computing

The computing primitives we use every day have the same property as H₂O: the formula looks complete and the reality is several layers deeper.

A process is just running code. Except it is a virtual address space, a file descriptor table, a signal mask, a scheduler context, inherited state from fork, copy-on-write pages shared with siblings, a set of capabilities that determine what system calls are permitted. The description "running code" is not wrong. It is the wrong level to operate at when you need to understand why two processes sharing a resource produce a race condition, or why a forked child inherits an open socket, or why a signal delivered at the wrong moment corrupts state.

A socket is just a file. Except it has a state machine with eleven distinct states, a send and receive buffer that can fill independently, a Nagle algorithm that batches small writes, a TIME_WAIT state that holds the port occupied for two minutes after the connection closes, and behaviour under packet loss that your application code never sees directly but absolutely depends on. Writing to a socket and writing to a file are the same system call. What happens is not the same.

A database transaction either commits or it does not. Except isolation levels exist on a spectrum, phantom reads are possible at some levels, serializable isolation has a cost, and the specific failure modes under concurrent access depend on which isolation level you chose and whether you understood what that choice meant. "It is transactional" is the textbook summary. The anode and cathode are doing different things simultaneously and what matters is which side you are operating on.

The formula is always clean. The reality always has two reactions happening at once.

What Mastery Looks Like

Once you understand what the cell actually does, the same hardware expresses as five different things depending on how you configure it.

Closed-loop metal refining

Acid generated at the anode dissolves ore. The dissolved metal plates out at the cathode as pure metal. The ions released in that plating cycle back through the membrane to regenerate more acid. The only inputs are electricity and fresh ore. Nothing is wasted. A fraction of a watt does work that would otherwise require fossil fuels, high-temperature furnaces, and industrial-scale acid production.

Steel at scale

The traditional blast furnace burns coal to reduce iron ore to pig iron (carbon-laden, brittle), then blows oxygen back through to remove the carbon, then discards iron-rich slag. Two energy-intensive steps, 80-90% yield, industrial CO2 output, product that still needs further processing.

The electrochemical alternative: dissolve ore in hydrochloric acid, plate off pure iron at the cathode, recover the acid automatically as a byproduct of the plating. The acid cycles rather than being consumed. At industrial electricity rates this runs under $160 per ton versus over $500 for blast furnace production, with higher-purity output, in a single step.

One detail that maps directly to computing: production throughput in electrolysis scales with current, not voltage. Voltage only needs to clear the reaction threshold; everything above it is wasted heat. The analogous distinction in systems is between latency and throughput: getting the first byte faster and handling more bytes per second are different problems addressed by different techniques. They look like the same dial and they are not.

Flow batteries

In a conventional battery, energy is stored in the electrode material itself: more energy means more electrode, which means more cell, which means cost and physical scale that grow together.

A flow battery stores energy in the electrolyte, the charged liquid circulating through the cell. The cell stack only converts between chemical and electrical energy; it does not hold the energy. Storage capacity is determined by how much electrolyte you have in the tanks. More energy means bigger tanks. Tanks are cheap.

Power output scales with the cell stack. The two parameters are independent: you can scale energy and power separately. For grid-scale storage (absorbing excess solar and wind during generation peaks, releasing it hours later), this independence is exactly what the application requires. The historically prohibitive cost has been the membrane. A membrane at under a dollar per square yard changes the math on what can be built.

Same hardware, more configurations

Pressurized hydrogen

In conventional hydrogen production, gas comes out near atmospheric pressure and a separate mechanical compressor brings it to the thousands of PSI required for storage tanks or pipeline injection. A compressor is expensive, energy-hungry, and introduces another system to maintain and fail.

If the membrane is strong enough to hold a pressure differential, the hydrogen produced at the cathode can be brought to pressure directly inside the cell, with electrolysis providing both the chemistry and the compression in a single step. Ben's video puts the achievable figure at 3,000 PSI or higher, already tank-ready, without a compressor in the loop.

The membrane here has to do two things that can pull in opposite directions: selective ion transport and mechanical pressure containment. At under a dollar per square yard, experimenting with thickness, fibreglass reinforcement, and substrate layering is a different proposition than it was at hundreds of dollars per square foot. The pressure specification becomes an engineering problem rather than an economics veto.

Self-contained inputs

Buying hydrochloric acid to seed the process is not required. Salt water through the cell produces chlorine at the anode, which dissolves into the water to form hydrochloric acid in situ. The starting reagent is salt, the kind sold in bulk bags for water softeners. Water and salt go in; the anode generates the acid it needs.

The electrode material follows the same logic. Carbon wool or carbon fibre felt, available from craft and composites suppliers, is electrically conductive, chemically stable under process conditions, and has large surface area that multiplies reaction sites per unit of electrode. A working cell can be built from a plastic container, carbon fibre electrodes, the membrane, and a power supply. Once running, the inputs to the whole system are electricity, water, and common salts.

In computing, the equivalent is knowing the primitive well enough to compose it in ways that look surprising from outside. A Unix pipe is just file descriptors connected through a kernel buffer; understanding what that actually means lets you build streaming pipelines, rate-limited workflows, and cooperative concurrency from that one primitive. A socket with the right options handles tens of thousands of concurrent connections on a single thread. A fork at the right moment snapshots gigabytes of state in microseconds.

The tools look plain. The leverage comes from understanding what they actually do at the electrode level, not what the formula says they do.

The Toxic Waste Problem

Electrochemistry without understanding produces toxic waste. Wrong electrode material: lead or chromium dissolved into the solution. Wrong ion routing: chlorine gas. Hydrogen and oxygen mixed before they can safely separate: explosion. These are not hypothetical edge cases; they are the natural result of running the process without knowing what each part is doing.

The computing equivalent is not hypothetical either:

• SQL from string concatenation produces injection vulnerabilities.
• Threads sharing state without understanding the memory model produce corruption that appears randomly and disappears under a debugger.
• Cryptography assembled from primitives without understanding what each one guarantees produces systems that are broken in ways invisible until they are not.
• Permissions granted broadly because the specific requirements were unclear produce blast radii that exceed anything intended.

Some electrochemical hazards are invisible until they are permanent. Platinum group metals dissolved in chloride-rich solution form water-soluble salts that cause sensitisation: an immune response that, once triggered, produces asthma-like symptoms on any subsequent exposure. There is no treatment other than avoidance. There is no cure.

Exposure without immediate symptoms does not mean the sensitisation did not occur. Without proper analytical equipment you may not know what is in your ore at all; the hazard may not come from the metal you were trying to extract but from something else in the feedstock. In computing, you often do not know what is in your dependency tree either. The malicious package may not be the one you installed. It may be three levels deep, arriving through a build script that pulled it in automatically.

In both domains, the mess is hard to clean up after the fact. Toxic chemical waste requires handling, containment, and disposal that costs more than the original experiment. A security vulnerability in a deployed system, a race condition in production code, data corrupted by a misunderstood transaction boundary: the remediation cost is always higher than the cost of understanding the primitive correctly before using it.

The primitives are not dangerous because they are complex. They are dangerous because they look simple. The formula H₂O suggests a thing that cleanly splits in half when you add electricity. The reality is two separate reactions, each producing its own chemistry, each requiring its own membrane, its own routing, its own understanding. Getting one side wrong does not produce a slightly incorrect result. It produces acid where you wanted base, chlorine where you wanted hydrogen, toxic output where you expected a clean closed loop.

The Plus and the Minus

The logo is a plus and a minus. They share the same idea as the anode and cathode: two poles that look like a simple binary (positive, negative, on and off, true and false) but where entirely different things are happening simultaneously on each side. The relationship between them, the membrane between them, the deliberate routing of what each side produces: that is what makes any of it useful.

That is the thing we are interested in here. Not the formula. The flows.