Skip to content
Tech HistoryDeep Dive Published Updated 9 min readViews unavailable

Manchester SSEM ('Baby'): The Williams-Kilburn Tube Put a Program in Memory

How the 1948 Small-Scale Experimental Machine tested a regenerating CRT store, and why its achievement is best described as a specific stored-program milestone.

The Manchester Small-Scale Experimental Machine (SSEM), nicknamed the “Baby,” was not designed as a commercial product or a full-scale scientific workhorse. Its immediate engineering purpose was more focused: prove that a cathode-ray-tube memory could store and retrieve digital information at electronic speed while a computer executed instructions from that same memory. On 21 June 1948, Tom Kilburn’s program ran successfully on the machine. The milestone was not simply that a new computer performed arithmetic; it was that the experimental memory and stored-program design operated together in a real electronic system.

The story is strongest when its scope is precise. The SSEM is widely credited with the first successful execution of a program stored electronically in memory. That is a specific and important milestone, not an unqualified claim that it was “the first computer” under every possible definition. The contemporaneous 1948 letter by F. C. Williams and Kilburn described a deliberately small experimental machine, while the University of Manchester’s historical archive explains why its memory was the central question being tested.

The memory problem that shaped the experiment

An electronic computer needs a place to keep values while calculations proceed. In the 1940s, fast electronic logic did not automatically provide fast, practical memory. Some proposed and early machines used delay lines: information moved through a medium in a recurring sequence, so the time to access a particular value depended on when it returned. Such stores could be useful, but they did not offer the same form of direct, short-string random access that Williams and Kilburn wanted to test.

Williams began work on digital storage using a cathode-ray tube at the Telecommunications Research Establishment. Kilburn joined the Manchester work, and Geoff Tootill later assisted. The Williams-Kilburn approach encoded a bit as an electrical charge pattern on the CRT’s phosphor. A write operation directed the electron beam to a location and created one of two distinguishable charge states. Reading the location altered the charge, so a value could not simply be left untouched forever. The system repeatedly sensed and rewrote the pattern, a process called regeneration, to maintain the stored bits.

The memory tube was not a normal television display with readable pixels. A pickup plate sensed the charge; the tube and its electronics were enclosed to reduce interference. A separate display tube could present a synchronized view of values in a form useful to an operator. The distinction between storage tube and display tube matters: the visible spots used to follow computation were not simply the stored bits glowing directly on an exposed screen.

By late 1947, the Manchester group had stored 2,048 bits on a standard six-inch CRT in a memory experiment. That capacity should not be confused with the Baby’s initial main store. The SSEM used a 32-word store with 32 bits per word, for 1,024 bits of main memory. The broader tube experiments and the prototype computer were related stages, but they did not have identical configurations.

Why build a computer around a memory experiment?

The group could write or reset values into the experimental tube only slowly by hand. That did not prove the store could sustain the rapid read-write cycle needed during computation. The decisive test was to place the store inside a working machine and have its values repeatedly read, modified, and written at electronic speed. The archive’s account describes the SSEM as a way to subject the memory system to a searching test; the stored-program principle was both the mechanism of that test and a major result in its own right.

The crucial design choice was that the main store held both data and instructions. A program could be entered into memory, fetched in sequence, and executed without rewiring the machine for each new procedure. The same physical memory was not divided into immutable “program” and “data” devices in the way a plugboard-configured machine might be. A different program required changing stored values rather than reconfiguring the electronic circuit. This did not make programming easy: the first program was entered laboriously by setting bit patterns through a simple keyboard, and output was read from the display tube.

The Baby’s architecture was modest and unusually constrained by modern standards. The archival specification gives a 32-bit word, serial binary arithmetic using two’s-complement integers, a single address format, a 32-word random-access main store, and about 1.2 milliseconds per instruction. The machine had seven instructions in its original order code. The instruction format used a three-bit function field and a 13-bit store address, with the remaining 16 bits unused in that version. The small word count made every program and intermediate value precious; it also made the memory test concrete rather than theoretical.

The accumulator and control state had dedicated storage tubes. One tube held accumulator A; another represented the current instruction address (CI) and the present instruction (PI). This arrangement made the execution loop visible in hardware: obtain an instruction from a store location, interpret its operation and address, perform the operation, and continue or branch based on state. The system was not a miniature modern CPU, and translating its few operations directly into contemporary assembly metaphors can obscure its design. Its significance lies in the working relationship between memory, instruction sequencing, arithmetic, and control.

The first successful program and what it demonstrated

On 21 June 1948, the first successful program calculated the highest factor of a number. It was a small problem, deliberately tractable enough to test the machine and storage. The institutional archive reports that within days the team tried the program on 2^18; it found the correct answer in 52 minutes, involving roughly 2.1 million instructions and about 3.5 million store accesses. Those figures describe a later run and should not be conflated with the first successful run on June 21. They convey the scale of a machine whose memory was tiny but whose electronic cycle could repeat the same operations millions of times.

The output was not a polished printed result. The CRT display showed values, and operators interpreted the final state. Early test runs could fail without telling the builders exactly which component or timing assumption was wrong. The practical achievement involved engineering iteration: build a memory, instrument its behavior, execute a program, observe the display, and refine the circuit and procedures until the answer was stable.

The 1948 Nature letter is especially useful because it is a contemporaneous account from Williams and Kilburn. They wrote that the machine had been operating successfully for some weeks, emphasized that it was experimental and too small for mathematical utility, and explained that it had been built primarily to test the storage principle before a larger machine. They also described the ability to change the program without mechanical or electromechanical circuit changes. Read that statement alongside the later historical narrative: the designers themselves framed the Baby as an experiment, and the later “stored-program computer” milestone describes what that experiment proved.

The phrase “stored program” is about where instructions reside and how the machine uses them, not about whether data can be entered automatically or whether the computer has a modern operating system. The historical account describes a simple keyboard for entering bit sequences and a display tube for reading output; those interfaces did not make the SSEM a general-purpose interactive system. It still demonstrated a powerful architecture principle: instructions could be represented as bits in electronic memory, fetched and executed by the machine that memory served.

From Baby to Manchester Mark I and beyond

Once the SSEM had shown that the tube store could work inside a computer, the Manchester team moved toward a more useful design. The Mark I developed from the prototype through successive stages, adding facilities and capacity. The university archive describes a progression from Baby through the Manchester Mark I to the Ferranti Mark I, which drew on that work as a commercial system. These machines are related, but they are not interchangeable names for one unchanged design.

The early tube store was valuable but not perfect. The archive notes continued experimentation to improve its reliability, and electromagnetic or charge-based memory was eventually displaced in many systems by magnetic-core storage. The Baby should therefore not be cast as a direct ancestor that single-handedly determined every later computer. Its historical role is that of a rigorous proof of concept whose memory and execution model made subsequent designs more credible.

The machine’s small size is an advantage for historical understanding. A modern reader can follow its architecture without confusing it with a later production computer. The 32-word store forced a clear relationship between program length, data, instruction flow, and hardware state. The display made the machine’s electrical computation observable. The result showed how a memory experiment could become an architectural demonstration when the program and data were placed in the same electronic store.

A careful way to tell the “first” story

Claims about “the first computer” depend on the definition being used: electronic or electromechanical, programmable or stored-program, digital or analog, experimental or general-purpose, and successfully operated or merely designed. Colossus, ENIAC, EDSAC, and other machines answer different historical questions. The SSEM’s well-supported distinction is narrower and more informative: it successfully executed a program held in electronic memory on 21 June 1948. That wording leaves room to discuss other milestones without erasing them or turning a complex history into a contest over one label.

Source status also matters. Williams and Kilburn’s Nature letter is contemporary primary evidence. The University of Manchester article is an institutional retrospective. The Computer50 pages are a university-hosted archival reconstruction of anniversary materials, with a stated 1998-1999 copyright and page maintenance history; they are valuable for technical detail and transcribed context, but they are not a newly written current manual. The Computer History Museum offers a secondary archival history of the Williams tube. Keeping those source types distinct helps readers judge which claims come from participants, which are later interpretation, and which pages preserve historical material.

The Baby’s lasting contribution was not raw speed or commercial scale. It showed that a computer’s memory could hold the instructions that directed its own operation, and that an electronic storage device could survive the repeated accesses of a running program. That was an architectural threshold: the stored program became an operating fact, not only a proposal on paper.

Related:

Sources:

Comments