The world's first stored computer program took 52 minutes to run
On June 21, 1948, the Manchester Small-Scale Experimental Machine, nicknamed "Baby," executed the world's first program stored in electronic memory. Written by Tom Kilburn, the 17-instruction program calculated the highest proper factor of 262,144 through brute-force division. The primitive computer processed roughly 3.5 million operations, successfully displaying the correct answer of 131,072 on its cathode-ray tube display after running for 52 minutes.
The Memory Bottleneck of Early Computing
In the mid-1940s, the primary obstacle to building practical electronic computers was memory. Early computing devices such as ENIAC could calculate at electronic speeds using vacuum tubes, but their programs were set manually by configuring switches, turning dials, and routing cables across patch panels. Changing a program on such machines could take days of manual labor. While the theoretical concept of a stored-program computer—where both instructions and data reside together in high-speed, electronically alterable memory—had been formulated by pioneers like Alan Turing and John von Neumann, the physical hardware to store bits reliably at high speeds did not yet exist.
Early attempts at electronic storage faced severe physical constraints. Mercury delay lines, which circulated data as acoustic pulses through tubes of liquid metal, were bulky, temperature-sensitive, and inherently sequential, meaning the processor had to wait for circulating pulses to reach the end of the line. Electrostatic storage tubes like the Selectron were complicated and expensive to fabricate. Without a fast, rewritable random-access storage device, the immense speed of electronic vacuum-tube arithmetic units was largely bottlenecked by the inability to feed instructions to the processor at equivalent speeds.
The Williams-Kilburn Tube and Baby's Architecture
At the University of Manchester, Frederic C. Williams and Tom Kilburn approached the memory problem from a different angle. They discovered that standard, commercially available cathode-ray tubes (CRTs) could be used to store electrical charges on their phosphorescent phosphor screens. By directing an electron beam at the screen, secondary electron emissions created tiny localized pockets of positive charge. These charges could be read back electronically using an external metal pickup plate and periodically refreshed before the charge dissipated, creating the first practical random-access electronic memory: the Williams-Kilburn tube.
To test whether this electrostatic memory could function reliably inside an actual working computer, Williams, Kilburn, and Geoff Tootill constructed the Small-Scale Experimental Machine (SSEM), affectionately known as "Baby." Baby was not designed to perform practical mathematical work or scientific research; it was built solely as a proof-of-concept testbed for the Williams tube. Its central memory consisted of a single cathode-ray tube capable of storing 32 words of 32 bits each, offering a total storage capacity of exactly 1,024 bits.
The machine was deliberately minimal in physical construction. In addition to the memory tube, it used two other CRT displays as internal registers: one for the Accumulator (which held the results of arithmetic operations) and one for the Control register (which held the current instruction and program counter). A fourth cathode-ray tube was wired as a display monitor, allowing the engineers to look directly at the screen and visually observe the grid of 32-by-32 glowing dots representing the binary contents of the machine's memory in real time.
A Minimalist Instruction Set Driven by Subtraction
Because Baby was an engineering testbed rather than a full-scale calculating engine, its architecture was stripped down to the bare essentials. It operated with a simple single-address instruction format, and its arithmetic-logic hardware was radically simplified to conserve vacuum tubes and reduce points of failure. The machine contained only seven basic instructions: absolute jump, relative jump, load negative, store to memory, subtract from accumulator, test (skip the next instruction if the accumulator is negative), and stop.
Remarkably, the arithmetic unit did not include hardware for addition or multiplication, nor did it feature native division logic. Instead, the central processing hardware was built entirely around subtraction. To load a number into the accumulator, the machine used the "load negative" instruction to flip the number's sign, and any subsequent arithmetic had to be carried out through repeated subtractions. If an algorithm required division, the programmer had to orchestrate a loop of repeated subtractions until the value crossed into negative territory, requiring creative programming to compensate for the austere hardware.
The Historic Run of June 21, 1948
On June 21, 1948, Tom Kilburn entered a 17-instruction program into Baby's memory using a panel of manual push-buttons to set the individual bits on the CRT screen. The goal was to subject the memory tube to a rigorous trial that would stress its ability to maintain stored bits across millions of rapid read-refresh cycles without leaking charge or corrupting data. Kilburn designed a program to determine the highest proper factor of a large integer by brute-force trial division.
The target number chosen for the test was 262,144 (which is 2 to the 18th power). Because Baby lacked a division operator, the program tested potential divisors starting downward from 262,143, executing a sequence of repeated subtractions for each candidate integer to see if it divided the target evenly without a remainder. If a remainder occurred, the program decremented the trial divisor and repeated the subtraction loop.
For 52 minutes, the machine chattered as it executed approximately 3.5 million individual instructions, methodically working its way down through potential factors. Finally, the program halted. When the team inspected the monitor tube, the correct answer—131,072 (2 to the 17th power)—was displayed on the screen. It was the first time in history that a computer had executed a program stored entirely in electronic read-write memory from start to finish without human intervention.
From Laboratory Prototype to the Manchester Mark 1
The success of the June 21 run validated the Williams-Kilburn tube and proved that electronic stored-program computing was entirely viable. Almost immediately after the test, the Manchester team began expanding the prototype into a practical general-purpose machine. They added additional Williams tubes to expand RAM, integrated a rotating magnetic drum for non-volatile secondary storage, and expanded the instruction set to include native addition and hardware-level multiplication.
The expanded machine, known as the Manchester Mark 1, also introduced index registers (originally called B-lines), a foundational innovation in computer architecture that allowed programs to modify memory addresses dynamically during execution. The project drew national attention and attracted mathematician Alan Turing to Manchester in late 1948 to help develop the software environment. The Manchester Mark 1 design was subsequently handed over to the industrial firm Ferranti, resulting in the Ferranti Mark 1 in 1951—the world's first commercially available general-purpose electronic computer.
Baby's Place in Early Computing Milestones
Baby holds a distinct and specific place in the chronology of early computers. It was not the first electronic digital computer—machines like the British Colossus (used for wartime cryptanalysis) and the American ENIAC preceded it. However, those earlier machines relied on fixed internal wiring, patch cords, or external paper tapes to direct their sequence of operations. Baby was the first operational machine to implement the true stored-program paradigm on purely electronic random-access hardware.
While other projects were designing stored-program architectures concurrently—most notably Cambridge's EDSAC and the American EDVAC project—Baby reached operational status first because its creators prioritized building a tiny, focused testbed over a feature-complete computing system. By keeping the design constrained to just 32 words of memory and a handful of instructions, the Manchester team proved the foundational concepts of modern computing architecture before any other laboratory in the world.
Key takeaways
•The Manchester Small-Scale Experimental Machine ('Baby') became the first operational stored-program computer on June 21, 1948.
•Baby was built not as a full computer, but as a minimalist testbed for the Williams-Kilburn tube, the first practical random-access electronic memory.
•Lacking hardware for addition or division, Tom Kilburn's 17-instruction program found the highest proper factor of 262,144 through 3.5 million operations of brute-force subtraction over 52 minutes.
•Baby's success led directly to the Manchester Mark 1 and the Ferranti Mark 1, the world's first commercially available general-purpose computer.