1 History
1.1 Development at Manchester University
1.1.1 The "Baby" prototype (SSEM)
The Small-Scale Experimental Machine (SSEM), commonly nicknamed "Baby," was built at the University of Manchester between 1947 and 1948. Designed by Frederic C. Williams, Tom Kilburn, and Geoff Tootill, it was the first electronic stored-program computer to successfully execute a program. Baby used a single Williams-Kilburn cathode-ray tube (CRT) as its main memory, storing 32 words of 32 bits each. Its instruction set was minimal, with only seven instructions, and programs were entered via a set of switches. On 21 June 1948, Baby ran a program to compute the highest factor of a number, demonstrating the viability of the stored-program concept.
1.1.2 Expansion to the Mark I
Following Baby’s success, the team immediately began expanding the machine into a more practical and powerful system. The goal was to create a full-scale computer that could be used for real research. The expansion added a second Williams-Kilburn tube for memory, a larger instruction set, and improved input/output facilities. The new machine was named the Manchester Mark I. Its design incorporated a magnetic drum for secondary storage, a paper tape reader for program input, and a teleprinter for output. Construction proceeded through late 1948 and early 1949.
1.2 Operational timeline (1948–1949)
Development of the Mark I started in August 1948. By October 1948, the machine was able to run simple test programs. A major milestone occurred on 16 April 1949, when the Mark I successfully executed a program to calculate prime numbers. Throughout 1949, the machine was used for research in numerical analysis, including solving differential equations and computing mathematical tables. It remained operational until 1951, when it was superseded by the Ferranti Mark I.
1.3 Transition to commercial production (Ferranti Mark I)
The University of Manchester collaborated with Ferranti Ltd. to commercialize the design. The resulting Ferranti Mark I, delivered in February 1951, was the world’s first commercially available general-purpose electronic computer. It closely followed the Mark I architecture but included enhancements such as a larger memory (eight CRTs for 256 words) and additional instructions. The transition demonstrated the immediate practical impact of the Manchester research.
2 Architecture
2.1 Processor and registers
2.1.1 Accumulator and control unit
The processor contained a single accumulator (A-register) that held the result of arithmetic and logical operations. A separate B-register acted as a multiplier/quotient register for multiplication and division. The control unit used a program counter (also called the control instruction register) to sequence instructions. The accumulator and control unit were built from thermionic valves (vacuum tubes) and relays.
2.1.2 Instruction format and word length
The word length was 40 bits, divided into a 20-bit instruction and a 20-bit address field (though only 13 bits were actually used for addressing, allowing up to 8192 words). Each instruction occupied one word. The instruction set included addition, subtraction, multiplication, division, logical AND, conditional branching, and input/output operations. Instructions were fixed-length and executed sequentially.
2.2 Memory system
2.2.1 Williams-Kilburn cathode-ray tube memory
The main memory consisted of two Williams-Kilburn CRTs, each storing 32 words of 40 bits. This gave a total of 64 words of high-speed storage. Each CRT used a charged spot pattern on its phosphor screen to represent bits, with a read/write cycle time of about 1 millisecond. This was fast for its time but limited in capacity.
2.2.2 Secondary storage (magnetic drum)
To extend storage, a magnetic drum was added. The drum held 256 tracks, each track storing 20 words—initially a total of 5120 words. Data was transferred between the drum and the CRT memory under program control. The drum rotated at 3,000 rpm, giving an average access time of about 10 milliseconds.
2.3 Input/output mechanisms
2.3.1 Paper tape reader and teleprinter
Programs and data were entered via a five-track paper tape reader. The output was printed on a teleprinter (a modified Creed Teleprinter) capable of 7 characters per second. The paper tape reader operated at 200 characters per second. Both devices were electromechanical and connected through a control interface.
2.3.2 Early display output
The machine also had a direct visual output: the contents of the Williams-Kilburn tube could be displayed on a cathode-ray oscilloscope. This allowed operators to see memory contents in real time, which was useful for debugging and demonstration.
3 Programming and software
3.1 Machine code and instruction set
3.1.1 Arithmetic and logical operations
The instruction set included basic arithmetic operations (add, subtract, multiply, divide) and a logical AND operation. Arithmetic was performed using fixed-point binary numbers. The accumulator held the result; for multiplication, the B-regitor held the multiplier, and the product appeared in the accumulator and B-register combined.
3.1.2 Conditional branching implementation
Conditional branching was implemented using a "test" instruction that checked the sign of the accumulator. If the accumulator was negative, the next instruction was taken from the address field; otherwise execution continued sequentially. This allowed simple loops and conditional logic, essential for general-purpose programming.
3.2 Initial programs and algorithms
3.2.1 Prime number calculation (by Kilburn)
Tom Kilburn wrote the first substantial program for the Mark I: a routine to compute prime numbers. The program used trial division to find primes up to a given limit. It ran successfully in April 1949, producing a printed list of primes. This demonstrated the machine’s ability to perform iterative calculations reliably.
3.2.2 Early search and sort routines
Researchers at Manchester wrote a variety of algorithms, including search routines (linear search on the magnetic drum) and simple sorting methods. These programs tested the I/O and storage capabilities, and helped refine the instruction set and system design.
4 Legacy and influence
4.1 Impact on later Manchester computers
4.1.1 Ferranti Mark I and Mark I*
The Ferranti Mark I directly inherited the Mark I architecture, with improvements in memory size and reliability. The Mark I* was a further refinement used in several installations. The Manchester design thus formed the basis of the first commercial computer line.
4.1.2 MUSE (later Atlas) concepts
The Mark I’s design principles—particularly the use of a CRT store and magnetic drum hierarchy—influenced later Manchester projects, including the MUSE computer, which evolved into the Atlas. The concept of virtual memory and paging, though not present in the Mark I, emerged from the Manchester team’s subsequent work.
4.2 Role in the history of computing
4.2.1 Proof of stored-program viability
The Mark I was the first full-scale stored-program computer in operation. Together with the Baby, it proved that the concept proposed by John von Neumann and others could be realized in a practical, reliable machine. This established the foundation for all subsequent electronic computers.
4.2.2 Documentation and preservation
Detailed engineering drawings, logbooks, and operational notes from the Mark I project survive in the University of Manchester archives and the Science Museum, London. A replica of the Baby was built in 1998 and is on display at the Museum of Science and Industry in Manchester. The Mark I’s influence is recorded in numerous historical accounts of early computing.
5 Technical specifications
5.1 Physical dimensions and power consumption
The Mark I filled a large room, with separate cabinets for the processor, CRT memory, magnetic drum, and I/O equipment. It contained approximately 4,000 vacuum tubes and consumed about 25 kilowatts of electrical power. The entire system weighed several tons.
5.2 Speed and performance metrics
5.2.1 Addition and multiplication times
Addition of two 40-bit numbers took 1.2 milliseconds. Multiplication required 2.16 milliseconds (including operand fetch). These times were comparable to other first-generation computers.
5.2.2 Memory cycle times
The Williams-Kilburn CRT memory had a read/write cycle time of approximately 1 millisecond per word. Access to the magnetic drum averaged 10 milliseconds per sector, with a data transfer rate of about 2,000 words per second.