Computation Explainer: How Many Transistors Make a Computer?

Text written by Claude Fable 5.

Computation Explainer: How Many Transistors Make a Computer?

This is the companion to Project 6b, written for a question that reliably comes up when adults watch the siren run: our chip has 25 transistors, a laptop has tens of billions, so how many transistors would you actually need to build a real computer, one that runs any program? It’s a wonderful question because it has a sharp, satisfying answer, and because the circuit on the breadboard is closer to that answer than it looks. No computer science background is assumed; the NE555 explainer is useful but not required.

The punchline up front: about two thousand. A genuine universal processor, the Intel 4004, shipped in 1971 with 2,300 transistors. Our 555 has 25. The distance from “buzzer chip” to “computer” is a factor of about a hundred, not a factor of a billion. Everything beyond that threshold buys speed and memory, never new capability. That last claim sounds like marketing but is a theorem, and the theorem came before the hardware.

1. Turing’s answer arrived before the question

In 1936, a decade before any electronic computer existed, Alan Turing published “On Computable Numbers”. To pin down what “computation” even means, he invented an idealized machine: an endless paper tape, a read/write head, and a small fixed table of rules (“if you see a 1 in state A, write 0, move left, switch to state B”). Nothing more. The claim, since borne out by ninety years of trying and failing to exceed it, is that anything any algorithm can compute, a machine of this kind can compute. (That’s the Church–Turing thesis.)

The paper’s deepest result is the one the parents at the workshop were circling: the universal machine. Turing showed there is a single, fixed, not very complicated machine U which, if you write a description of any other machine onto its tape, will faithfully simulate that machine. The rule table of U never changes; only the tape contents do. In modern words: U is hardware, the description is software, and U is a programmable computer. Every laptop, phone, and supercomputer is, mathematically, this one machine with a bigger tape and a stopwatch.

Two consequences matter for the transistor question:

2. What the threshold demands, and what the 555 already has

Strip any programmable computer to its skeleton and three abilities remain:

  1. Decide: compare values and act differently on the outcome (“if this is zero, jump there”).
  2. Remember: read and write bits that persist.
  3. Fetch: run in a loop that reads its next instruction from that same memory.

Here is why the workshop circuit is a good launchpad for this conversation: the 555 already contains hardware for the first two. Its comparators are one-bit deciders (“is the capacitor voltage above ⅔ of the supply?”), and its SR latch is exactly one bit of memory, holding its state until told otherwise. The NE555 explainer unpacks both. Decision and memory: the two digital ingredients, present in a 1972 buzzer chip.

What the 555 lacks is ingredient three. Nothing in it consults memory to find out what to do next; its behaviour is soldered into its wiring, permanently. Project 6b’s siren takes one genuine step further: the slow chip commands the fast one, so we have a circuit whose behaviour is steered by another circuit’s state. But the “program” (nee-naw forever) is still frozen in copper. The whole trick of a computer, the thing the Manchester Baby demonstrated first (section 3), is to move that wiring into memory, where the machine itself can read it and, crucially, overwrite it. Once stored bits steer the switches, and the switches can rewrite the stored bits, the loop closes and you are above Turing’s threshold.

3. The ladder: counting switches through history

“Transistor” is the wrong unit for the early rungs; the honest unit is the switch, whatever the technology. Relays (electromagnets closing contacts), vacuum tubes, and transistors all do the same logical job at wildly different speeds.

Zuse Z3 (Berlin, 1941): about 2,600 relays. The first working programmable, fully automatic computer, built by Konrad Zuse from telephone-exchange parts. It read its program from punched 35 mm film and did floating-point arithmetic, but it had no conditional branch: it could not decide. A footnote for the most pedantic parent: in 1998 Raúl Rojas proved the Z3 is Turing complete anyway, via a gloriously impractical trick (loop the program film and compute both branches of every decision, discarding the unwanted result). Universality can hide in machines never designed for it.

ENIAC (1946): about 17,500 vacuum tubes. Included here as the counterexample: enormously more hardware, yet “programming” it meant physically re-plugging cables for days. Switch count alone is not the point; architecture is.

Manchester Baby (1948): 550 valves. This is the machine to name when someone asks for the minimum. The Small-Scale Experimental Machine was the first computer to hold its program and its data in the same memory: 32 words of 32 bits, stored as charge spots on the face of a cathode-ray tube, read and rewritten thousands of times a second. Its 550 tubes (250 pentodes doing logic, 300 diodes) implemented just seven instructions, enough to decide, remember, and fetch. On 21 June 1948 it ran the world’s first stored program (finding the highest factor of a number) for 52 minutes. Every computer since is a descendant of those 550 switches.

Intel 4004 (1971): 2,300 transistors. The first complete CPU on one chip, originally designed for a desktop calculator. This is the cleanest one-line answer to the workshop question: two thousand three hundred transistors make a genuine, universal, programmable processor. It appeared one year before the 555 and its 25 transistors; the two chips are near contemporaries, and the ratio between them is about ninety.

MOS 6502 (1975): 3,510 transistors. The processor of the Apple II, the Commodore 64, and the NES: the chip an entire generation learned to program on, with roughly 140 555s’ worth of transistors. And you don’t have to take the number on faith. The MOnSter 6502 is a working replica built from 3,218 individual, visible transistors on a board the size of a serving tray (the missing few hundred are the die’s resistor-like pull-ups, built as actual resistors). It boots and runs real 6502 code, about 50 times slower than the original.

Today: tens of billions. A phone processor carries on the order of 20 billion transistors; the largest desktop chips exceed 100 billion. And, mathematically, they do nothing the Baby’s 550 valves couldn’t. They do it billions of times faster, on billions of times more data, which is the entire (and entirely worthwhile) point.

4. Logic is cheap; memory is the mountain

Two honest caveats sharpen the story rather than spoil it.

First: Turing’s tape is infinite, and no real machine’s is. Formally, Turing completeness requires unbounded memory, so every physical computer is universal only “up to running out of memory.” This is not pedantry-for-sport; it points at where the transistors actually go.

Second: the counts above exclude most of the memory. The Baby’s 550 valves did not include its storage; the 32 words lived as charge on a CRT face precisely because tubes were too expensive to waste on remembering. The arithmetic makes the imbalance vivid. All logic can be built from NAND gates (a NAND is universal for logic, and in modern CMOS it costs 4 transistors), so a 4004-class control unit needs only a few thousand. But one bit of fast static memory costs 6 transistors, so a single kilobyte is already ≈50,000 transistors: ten 4004s’ worth, for an amount of memory that would embarrass a greeting card. That ratio never improved in logic’s favour. The billions of transistors in a modern chip are overwhelmingly memory (caches) and many parallel copies of the same few ideas. The decide-remember-fetch core, the part that crosses Turing’s threshold, remains a rounding error.

5. How low can the logic go?

For the parent who wants the theoretical floor rather than the historical one:

The moral is the same from both directions: the logic threshold for universal computation is absurdly low. What costs is memory, speed, and getting data in and out. Nature seems to agree; the threshold is low enough that computation keeps being discovered in systems never engineered for it, the Z3 included.

6. The mental model to carry back to the breadboard

A computer is a small cluster of deciders (comparators, in our terms) and a program counter, wrapped in a loop, dipping into a large pool of latches for its next instruction. The siren on the breadboard already demonstrates the first half of the trick: one circuit’s state steering another circuit’s behaviour. What it lacks is the closed loop through memory, letting the stored bits choose what the switches do next, so that changing the contents changes the behaviour with no soldering iron involved. Roughly ninety more 555s’ worth of transistors, arranged in that pattern, and the nee-naw would not be a circuit; it would be a program, one of infinitely many the same hardware could run.

So the answer to give across the table, with the siren still wailing: twenty- five transistors sing one song. Two thousand can sing any song ever written, if you hand them the sheet music and somewhere to keep it.

← Back to Project 6b · Project 6 · Read Me First

Sources