The Manchester Baby: The Moment a Program Ran from Electronic Memory
On 21 June 1948 the Manchester Small-Scale Experimental Machine successfully executed a program stored in its electronic memory, demonstrating the stored-program concept in working hardware.
On 21 June 1948, the Small-Scale Experimental Machine at the University of Manchester successfully ran a program stored in its own electronic memory. Nicknamed the ‘Baby,’ the machine was built principally by Frederic C. Williams, Tom Kilburn and Geoff Tootill as a test bed for a new cathode-ray-tube memory system. Its successful run is widely recognized as the first working demonstration of an electronic stored-program computer.[1]
The machine was deliberately small and experimental. Its significance came from what it proved: instructions could be held electronically in memory alongside data and executed without physically rewiring the machine for each new task. Manchester describes the event as the first implementation of the stored-program concept that underlies modern computing.[2]
The memory problem came first
Fast electronic logic was useful only if a computer also had a practical way to hold information. Williams and Kilburn developed a cathode-ray-tube storage technique in which electrical charges on a screen represented bits. The Baby was built largely to demonstrate that this memory could function reliably enough to support a computer.[3]
Memory was not a passive component
The new architecture depended on memory being fast, addressable and integrated into control. A stored program is only meaningful if the machine can retrieve instructions predictably and update data as execution proceeds. The Baby made memory central to the organization of computation.
The first successful program
Manchester’s historical archive records that Tom Kilburn wrote the first successful program. It searched for the highest factor of a number. Later tests used a larger value and ran for roughly fifty minutes, involving millions of accesses to the store.[4]
A simple task proved a general principle
The mathematics of the test was less important than the execution method. The machine fetched an instruction from memory, performed the specified action, and continued through a sequence held electronically. That made the program changeable without reconstructing the control wiring.
What ‘first stored-program computer’ means
Claims of technological ‘firsts’ require careful definitions. Earlier machines were programmable in other ways, and other projects were pursuing stored-program designs. Manchester’s claim is specifically about the first successful execution of a program held in electronic memory by an electronic digital computer.[2]
The Baby was a prototype, not a service machine
The Small-Scale Experimental Machine had limited capacity and was not designed as a practical general computing service. Its purpose was experimental. That distinction matters because Cambridge’s EDSAC, which followed in 1949, is often described as the first practical stored-program computer to provide a regular service to users.
Experimental success triggered rapid expansion
Once the Baby proved the memory and control concepts, the Manchester team moved quickly toward the more capable Manchester Mark 1. The prototype therefore functioned like a successful architecture experiment: small enough to test a principle, important enough to justify a larger system.[5]
From Baby to Manchester Mark 1
The Mark 1 expanded the architecture with additional storage and programming facilities. Manchester’s history places the Baby at the start of a continuing local lineage that led to the Mark 1 and commercial Ferranti machines. The significance of the 1948 experiment was therefore institutional as well as technical.[3]
Software became electronically replaceable
When a program lives in electronic memory, changing a task can be accomplished by changing stored bits rather than redesigning a panel of cables. This altered the balance between hardware and software. The machine became a platform whose behavior could be repeatedly redefined through encoded instructions.
The cost of change moved
Stored programs did not make programming easy, but they made program replacement dramatically more scalable. That change created room for later layers—assemblers, compilers, libraries and operating systems—to become economically meaningful.
Why the Baby belongs in coding history
The Manchester Baby is a hinge point between the idea of stored programs and their physical demonstration. For programmers, its legacy is simple but profound: code could reside in the machine’s memory as an editable representation. The program no longer had to be embodied mainly in wiring, switches or an external control medium.
The larger historical lesson
Computing history often advances when a theoretical or architectural idea is reduced to a small working proof. The Baby did not need to be the most powerful computer to matter. By executing a stored program successfully, it made a new model of programmable electronic computing materially real.
Works Cited
- 01University of Manchester Digital 60 — Birth of the Baby curation.cs.manchester.ac.uk
- 02
- 03University of Manchester Department of Computer Science — History and heritage cs.manchester.ac.uk
- 04University of Manchester Digital 60 — The Baby curation.cs.manchester.ac.uk
- 05University of Manchester Computer 50 — Manchester Mark 1 Introduction curation.cs.manchester.ac.uk
CodeHistory is a living archive. Citations document the evidence used for this edition; later evidence may refine the account.
Submit a research lead