Computing from anything

Computers are physical systems that manipulate information. A computation encodes information into physical states, executes a controlled sequence of state transformations, and decodes the final state to obtain the result. In an earlier post, I categorized computing as one of the three domains of information technologies and assigned fundamental physical limits to it. Here I want to ask a more basic question. What does a physical system need to provide before it can compute at all? It turns out the requirements form a short checklist, and a surprising range of physical systems can satisfy it. People have built computers, or at least logic gates, out of gears, dominoes, water jets, DNA molecules, slime molds, crabs, and card games. Therefore, the interesting question is not whether a physical system can compute, but what it needs to provide to compute reliably and how much energy and time it spends per operation. At the end, I want to look at what happens when the physical system is quantum, because that is the one case where changing the substrate changes more than the cost.

What counts as a computer

In 1936, a computer was a person employed to do arithmetic by hand. Turing’s model of computation is a model of that person, reduced to reading symbols, writing symbols, and changing internal state according to a fixed table (Turing, 1936). The model never specifies what the machine is made of, which is what makes a general theory of computation possible. A machine is universal if it can simulate any other machine, given enough time and memory. Church and Turing proposed that these machines capture everything that is effectively calculable. The physical version of this thesis, that no realizable physical process computes beyond them, is a stronger claim, and it has held so far.

Two years later, Shannon showed in his master’s thesis that circuits of electromechanical relays implement Boolean algebra (Shannon, 1938), which connected the abstract definition of computation to physical hardware. If a physical system provides a switch, a way to connect switches together, and a way to read out the result, then it can implement Boolean logic, and Boolean logic combined with memory is sufficient for a universal machine.

It also turns out that universality is surprisingly easy to achieve. Conway’s Game of Life is universal, and so is Rule 110, a one-dimensional cellular automaton whose entire update rule fits in one byte (Cook, 2004). Even a tournament-legal game of Magic: The Gathering can be arranged so that determining the winner requires running an arbitrary Turing machine to completion (Churchill et al., 2019). Since so many systems are universal, universality alone does not make a good computer. Therefore, we need to identify what a physical system must provide to compute reliably, and then compare how well different systems provide it.

The checklist

To make a computer out of a physical system, the system must provide four things:

1. State. The system needs distinguishable configurations that persist long enough to complete the computation. In practice, this means two states separated by an energy barrier that is large compared to kT, or states that are refreshed faster than they decay.
2. Switching. One signal must be able to change another signal. This requires an interaction between the two, which means a nonlinearity. In a linear medium, signals superpose and pass through each other unchanged, and no complete set of logic gates is possible. Light in vacuum fails this requirement because photon-photon interactions are negligible, which is why building logic directly with light is difficult.
3. Restoration. The output of one stage must be able to drive the inputs of the next stage, and errors must shrink from stage to stage instead of accumulating. This requires gain, thresholding, and fan-out. Restoration is the requirement that most demonstrations of logic gates made from unconventional materials fail to satisfy.
4. Input, output, and reset. We must be able to prepare the initial state, read out the final state, and return the machine to a known state to run it again. Resetting is erasure of information, and erasure dissipates at least kT ln2 of energy per bit, which is the Landauer limit (Landauer, 1961).

Programmability builds on top of these four requirements. Once they are met, we can construct a universal machine in the new medium and change what it computes by changing its inputs rather than rebuilding its hardware. The checklist is short, and that is why so many physical systems can be turned into computers.

Mechanical and fluid computers

The oldest surviving computer is mechanical. The Antikythera mechanism, built in the second century BC, used at least 30 bronze gears to compute the positions of the sun and moon and to predict eclipses (Freeth et al., 2006). Gear ratios multiply by fixed rational numbers, so the machine is special-purpose. However, it already provides state, switching, and readout. Two millennia later, Babbage designed, but never completed, a general-purpose mechanical computer, and in 1975, Danny Hillis and Brian Silverman built a machine out of roughly ten thousand Tinkertoy parts that plays tic-tac-toe without losing (Dewdney, 1989).

Dominoes are a useful system for seeing the physics of digital logic because every requirement on the checklist is visible by eye. A standing domino is a bit that stores potential energy behind a stability barrier. A falling wavefront is a signal that propagates without decaying, because each topple is powered locally by the potential energy stored in the next piece. This is restoration. Colliding wavefronts implement logic gates, and people have built multi-bit binary adders out of ten thousand dominoes. The costs are also visible. A falling domino dissipates on the order of a millijoule, about 10¹⁷ kT, while the Landauer limit for the bit it carries is kT ln2. A domino computer also runs only once. To run it again, someone has to stand every piece back up, which is the reset step of the checklist. The Landauer limit itself has been verified experimentally in single-bit erasures of a colloidal particle held in optical tweezers, with the dissipated heat approaching kT ln2 in the slow-erasure limit (Bérut et al., 2012).

Fluidic logic was developed in the 1960s around the wall-attachment amplifier, in which a small control jet deflects a larger power jet between two stable outlets. This provides gain, thresholding, and memory with no moving parts. Aircraft and missile control systems used fluidic circuits because they tolerate the radiation, heat, and electromagnetic interference that destroy electronics. Therefore, substrates are chosen by their environment as much as by their performance. The modern descendant is microfluidic bubble logic, where bubbles in etched microchannels are the bits and logic gates work by bubbles obstructing and steering one another (Prakash & Gershenfeld, 2007). Each bubble can also carry a chemical payload, so the same device performs the logic and the chemistry that the logic controls.

Chemical and living computers

In 1994, Adleman computed the solution to a seven-city Hamiltonian path problem in a test tube (Adleman, 1994). City-to-city connections were encoded as DNA strands, roughly 10¹⁴ molecules explored every possible path in parallel by hybridizing at random, and a week of filtering steps isolated the strands that spelled valid answers. There are two lessons in this experiment. One lesson is about energy. Adleman estimated about 2 × 10¹⁹ ligation operations per joule, which is within a factor of twenty of the Landauer limit. The other lesson is about scaling. The number of molecules required grows exponentially with the number of cities, so the parallelism only postpones the exponential cost of the search instead of removing it.

A more complete chemical computer came in 2011, when Qian and Winfree built DNA logic circuits that satisfy the whole checklist (Qian & Winfree, 2011). Their seesaw gates compute with DNA strand displacement, with explicit thresholding to reject noise, catalytic amplification to restore signal levels, and fuel strands playing the role of the supply rail. With 130 strands, they computed square roots of four-bit numbers. A circuit takes hours to settle. However, it cascades, and cascading is what separates a computer from a single-gate demonstration. This work was done at Caltech, where I later did my PhD.

Some living systems perform computations as part of how they grow. The slime mold Physarum polycephalum, a single cell with no neurons, finds the shortest path through a maze between two food sources (Nakagaki et al., 2000). When food was instead arranged in the pattern of the cities around Tokyo, its tube network converged on a design comparable to the actual rail system in cost, efficiency, and fault tolerance (Tero et al., 2010). The mechanism is a local feedback rule, in which tubes that carry more flow thicken and tubes that carry less flow decay. This is analog optimization implemented in chemistry, and it finds good answers rather than provably optimal ones. I will come back to this trade-off in the next section.

The strangest example I know of is the crab gate. Soldier crabs swarm in compact balls that propagate in straight lines and merge when they collide, so a swarm approximates a billiard ball, and logic gates can be built from the collision geometry. With real crabs, the OR gate works reliably and the AND gate works less often (Gunji et al., 2011). This is the restoration requirement again. A gate that usually works does not cascade, and without restoration or error correction, a computer built from such gates fails within a few stages.

The crab gate is an implementation of the billiard-ball computer of Fredkin and Toffoli, an idealized machine in which computation is carried entirely by elastic collisions (Fredkin & Toffoli, 1982). The purpose of the model was thermodynamic. Bennett had shown that any computation can be embedded in a reversible one (Bennett, 1973), and conservative logic exhibited a mechanics that dissipates no energy in principle, deferring the entire Landauer cost to whichever bits are eventually erased. However, there is a catch. Collision errors compound exponentially, so the ideal frictionless computer is chaotically unstable, and even this design cannot run long without restoring its state. Reversible logic looked like a curiosity in 1982. I will come back to it at the end of this post.

The analog route

The machines above are digital, in the sense that they snap their state back to discrete values at every stage. The analog route skips the snapping and lets continuous physics carry continuous quantities. The Phillips machine of 1949 modeled the British economy with water flowing through a network of tanks and valves, and differential analyzers solved ballistics and power-network equations with rotating shafts in the decades before electronic computers existed. Analog machines solve differential equations by evolving under the same differential equations, which makes them fast and energy-efficient for the problems they fit. The approach is currently returning in neural network inference, where a matrix multiplication can be carried out by conductances and currents in a crossbar array.

A soap film computes a minimal surface as soon as the wire frame leaves the solution, and films spanning arrays of pins have been proposed as solvers for NP-hard shortest-network problems. However, the film can settle into a local minimum rather than the global one, and larger problem instances have more local minima, so the method fails on the large instances where it would matter most. Proposals for solving NP-hard problems with physical systems have failed in similar ways across many substrates, and Aaronson suggested treating this consistent failure as a principle about nature (Aaronson, 2005).

Reservoir computing makes the analog trade-off explicit. Fernando and Sojakka demonstrated it by driving motors that rippled the surface of a bucket of water, filming the waves, and training a simple readout on the recorded patterns, which was sufficient for XOR and for distinguishing spoken digits (Fernando & Sojakka, 2003). The bucket is not programmed. The waves provide a rich, fixed nonlinearity, and all of the learning lives in the readout. Almost any sufficiently complex dynamical system can serve as the reservoir, which makes reservoir computing the most direct realization of a computer out of anything in this post.

The most capable analog computer known is the brain, which runs mixed-signal, with analog integration inside neurons and pulse-coded signaling between them. It draws about 20 W, a synaptic event costs a few femtojoules (Attwell & Laughlin, 2001), and individual synapses transmit unreliably, with release probabilities that can sit below one half. No engineered digital system is built from components this unreliable. The brain compensates with redundancy, adaptation, and codes that tolerate failure, which is restoration implemented statistically rather than by thresholding every signal. Von Neumann analyzed the general problem in 1956 and showed that reliable machines can be synthesized from unreliable components at the price of redundancy (von Neumann, 1956).

This trade-off is the weakness of the analog route. Without restoration, every stage adds noise, errors accumulate with depth, and the achievable depth of a computation is set by the signal-to-noise ratio. Digital design pays energy at every stage to reset the accumulated noise to zero. This is also what made the substrate stop mattering, because any medium that can switch, restore, and hold state can implement the same logic and run the same programs.

Why silicon won

The substrates in this post differ enormously in performance. Energy per elementary operation runs from 5 × 10^-20 J for a DNA ligation to about 10^-3 J for a falling domino, a spread of more than sixteen orders of magnitude. Switching times run from picoseconds in a transistor to minutes in a strand-displacement gate, a spread of about fourteen orders. However, every machine in this post computes the same set of functions, and the extended Church-Turing thesis holds that each can simulate any other with only polynomial overhead. The overhead can still be large in practice. Cook’s original universality construction for Rule 110 carried an exponential slowdown, and it took further work to bring the simulation down to polynomial time (Neary & Woods, 2006). Therefore, complexity classes survive a change of substrate, but performance does not.

These performance figures are why silicon won. At the 45 nm node, a 32-bit addition costs about 0.1 pJ (Horowitz, 2014), which is near 10⁷ kT, and newer nodes have pushed it lower. A transistor switches in picoseconds, fails so rarely that most logic ships with no error correction on its datapath, and is printed alongside tens of billions of identical copies in one lithographic process. No other substrate comes within orders of magnitude of this combination of speed, energy efficiency, density, reliability, and manufacturability. However, nothing about electrons is special for computation. Silicon won because the transistor is the best switch we have found so far.

It turns out there is still enormous room above silicon. A 1-kg, 1-L computer is permitted ~10⁵¹ operations per second by the quantum speed limit (Margolus & Levitin, 1998) and ~10³¹ bits by the maximum entropy that a kilogram of matter can actually carry (Lloyd, 2000), while a 2025 state-of-the-art computer of the same mass and volume delivers ~10¹⁴ operations per second and ~10¹¹ bits (Lloyd, 2000; NVIDIA, 2024). Therefore, making a computer out of anything is easy, but making a computer better than silicon requires finding a better switch. For every substrate considered so far, changing the substrate has only changed the performance figures.

When the substrate is quantum

In 1982, Feynman observed that simulating a general quantum system on a classical machine appears to require exponential resources, because the machine must track an amplitude for every configuration, and the number of amplitudes doubles with every added spin (Feynman, 1982). Deutsch reformulated the Church-Turing thesis as a claim about physical law and proposed the universal quantum computer as the machine that satisfies it (Deutsch, 1985). Shor then showed that such a machine factors integers in polynomial time (Shor, 1997). No proof rules out a fast classical factoring algorithm, so this is evidence rather than a theorem. However, the prevailing view is that the extended Church-Turing thesis is false. Every other substrate in this post changed the performance figures of computation. Quantum mechanics appears to change the complexity classes, which is something no improvement in switches can do.

The checklist itself survives the transition. DiVincenzo’s five criteria for building a quantum computer map onto the same four requirements (DiVincenzo, 2000):

1. State becomes the qubit, and the stability requirement becomes stricter. A classical bit needs an energy barrier against kT. A qubit must also be protected from decoherence, because any stray interaction that learns which state the system is in destroys the superposition. Therefore, the coherence time takes the place of the retention time.
2. Switching becomes the entangling gate. The nonlinearity requirement survives, because universal quantum computation needs controlled interactions between qubits. Photons still do not interact with each other, which is why photonic quantum computing implements effective nonlinearities through measurement.
3. Input and output become state preparation and measurement, and both are hard physics problems in their own right. Initializing a register into its ground state is an erasure, and it pays the same Landauer cost as every other reset.
4. Restoration is the requirement that almost stopped quantum computing. The classical restoration method is to copy, compare, and threshold, and the no-cloning theorem forbids copying an unknown quantum state (Wootters & Zurek, 1982). Quantum error correction solved this by measuring the errors without measuring the data, extracting error syndromes while leaving the encoded superposition untouched. This is von Neumann’s program repeated under quantum rules, and it recently passed an important milestone, with logical qubits whose error rate falls as the code grows (Google Quantum AI and Collaborators, 2025).

Reversibility also returns here. Unitary evolution is reversible by definition, so a quantum computer is a reversible computer by construction, and the Fredkin and Toffoli gates, designed in 1982 for frictionless billiard balls, are now ordinary gates in quantum circuits. The reversible logic that looked like a curiosity in 1982 turned out to be a requirement for computers whose dynamics follow quantum mechanics.

Therefore, the search for substrates has started again. Superconducting circuits, trapped ions, neutral atoms, photons, spins in silicon, and defect centers in diamond each satisfy different parts of the DiVincenzo criteria, and no winner is settled. We contributed to the photonic side by demonstrating proof-of-concept entanglement generation for measurement-based quantum computing with an on-chip phased array (Gurses et al., 2024). We are back to making computers out of anything, except that now the physical system must also maintain a superposition while it computes.

From objects to quantum fields

There is one more way to organize everything in this post, and I want to end with it, because it also works as a forecast. We can rank computing substrates by how fundamental the carrier of information is, and the history of computing descends this ladder in order:

1. Ordinary objects. Nearly everything in the tour above, from dominoes to crab swarms, carries a bit in the collective configuration of something like 10²³ atoms. Computers made from objects are easy to build and easy to read out. However, every operation has to move a macroscopic amount of matter, which is why these computers are robust, slow, and inefficient at the same time.
2. Matter. The history of mainstream computing is a history of shrinking the carrier from an object to a small piece of matter, from gear teeth to relay armatures to the few hundred electrons that switch a modern transistor. Feynman pointed out in his 1959 lecture that this path had plenty of room (Feynman, 1960), and the end of the path has been reached in the laboratory, where bits have been stored in single atoms (Natterer et al., 2017) and logic has been run on single trapped ions and single spins. In the Standard Model, the matter particles are the fermions, and the same exclusion principle that makes matter rigid also underlies the energy barriers that hold bits in place.
3. Forces. The gauge bosons of the Standard Model are not matter but carriers of interactions, and the next step down the ladder is to compute with the carriers themselves. Each interaction provides a candidate carrier, and none of them is privileged by the checklist. The photon is massless and stable, and photon-photon interactions are negligible, so photonic logic needs matter to mediate its gates or measurement to induce an effective nonlinearity. Light is the carrier we currently know how to generate, guide, and detect at scale, which is why this level is being explored with photons first. Gluons interact with each other, so the strong interaction supplies on its own the switching nonlinearity that light lacks, at the cost of being confined to femtometer scales inside hadrons. The W and Z bosons decay in about 3 × 10^-25 s, which sets the timescale at which any weak-interaction computer would have to refresh its state. Gravity sits outside the Standard Model and its carrier has not been detected, yet gravitational waves already carry information that we detect routinely.
4. Quantum fields. Underneath the first three levels, quantum field theory removes the distinctions between them, because objects, matter particles, and force carriers are all excitations of quantum fields. The final substrate is the field itself. This is already a research program, since continuous-variable quantum computing encodes information in the quadratures of bosonic field modes, with squeezed states as its resource, and the proof-of-concept entanglement we generated on-chip for measurement-based quantum computing (Gurses et al., 2024) is entanglement between modes of the electromagnetic field. The ultimate computer from the earlier post also lives at this level, because Lloyd’s accounting treats every field degree of freedom in a kilogram of matter as computational (Lloyd, 2000), and the Bekenstein limit on its memory is a statement about how much information a region of quantum fields can hold (Bekenstein, 1981).

Each step down the ladder trades robustness for performance and moves the substrate closer to the fundamental limits. The remaining orders of magnitude between current computers and the ultimate ones live in the lower levels of the ladder, and so do the hardest engineering problems, since the restoration that comes for free in a domino has to be engineered deliberately into a field mode. Beyond the fields, the holographic principle bounds the information in any region by the area of its boundary rather than its volume (Bousso, 2002), and that is as far down as current physics goes.

Outlook

The checklist explains why new computing substrates keep being proposed, and the ladder says where to look for them. On the classical side, analog and in-memory computing are being revisited for neural networks, because neural networks tolerate noise and thereby relax the restoration requirement that ruled analog machines out the first time. Thermodynamic computing, probabilistic bits, and reversible logic all aim to lower the energy per operation toward the Landauer limit by giving up parts of the digital abstraction. These are improvements within the first two levels of the ladder.

On the quantum side, no substrate has won yet, and I expect the winner to be decided by the same figures of merit that decided the classical competition, such as energy per operation, gate time, error rate, and manufacturability. The useful way to compare substrates is against the fundamental physical limits, because the limits are the only reference points that do not move when the substrate changes, whichever level of the ladder a substrate comes from. That comparison is the subject of this series, and the next post applies it to information transfer.