How the World's First Computer Worked

Photo: Ruben Boekeloo / Pexels
There's no single answer to "what was the world's first computer." The answer depends on which features you insist on. Programmable? Electronic? General-purpose? Stored-program? Each combination crowns a different machine. The five strongest candidates are ENIAC, the Z3, Colossus, the Atanasoff-Berry Computer, and Babbage's never-built Analytical Engine.
Here's how each one worked and which question each one answers.
ENIAC (1945–1946) — First General-Purpose Electronic Programmable Computer
ENIAC (Electronic Numerical Integrator and Computer) is the machine most often called "the first computer" in American sources. Built at the University of Pennsylvania by J. Presper Eckert and John Mauchly, it was completed in late 1945 and publicly unveiled in February 1946.
The numbers are still staggering:
- 17,468 vacuum tubes
- 30 tons of weight
- 167 square meters of floor space
- 150 kilowatts of power consumption
- About 5,000 additions per second
ENIAC used decimal arithmetic (not binary), with each digit represented by a ring of ten vacuum tubes. It was programmed not by writing software but by physically rewiring it — moving cables on plugboards and setting switches. A change in program could take days.
Its primary purpose was calculating artillery firing tables for the U.S. Army. A human "computer" (the original meaning of the word — a person who computed) might take 20 hours to work out a single trajectory. ENIAC did it in 30 seconds.
The ENIAC Programmers
The original ENIAC programmers were six women — Kay McNulty, Betty Jennings, Betty Snyder, Marlyn Wescoff, Fran Bilas, and Ruth Lichterman — recruited from the ranks of human "computers." They wired the programs by hand and debugged the hardware. For decades they were left out of the historical record entirely; they were finally given official recognition in 1997 when they were inducted into the Women in Technology International Hall of Fame.
Z3 (1941) — First Programmable Electromechanical Computer
Two years before ENIAC, in Berlin, Konrad Zuse completed the Z3 — a fully programmable, electromechanical computer built from about 2,000 telephone relays. It used binary arithmetic and floating-point numbers (years ahead of ENIAC).
The Z3 was destroyed by Allied bombing in 1943 and remained essentially unknown outside Germany until decades later. In 1998, computer scientist Raúl Rojas proved that the Z3 was Turing-complete in principle. Zuse's work was a parallel, independent track of computer development that the war effectively erased from mainstream history.
Colossus (1943) — First Programmable Digital Electronic Computer
At Bletchley Park in England, engineer Tommy Flowers built Colossus to help break the German Lorenz cipher (a higher-level system than Enigma). The first Colossus ran in December 1943, with ten machines eventually in operation by the end of WWII.
Colossus was electronic (1,500 vacuum tubes in Mark 1, 2,400 in Mark 2), digital, and programmable via switches and plugboards. It was not general-purpose — it was designed specifically for cryptanalysis.
Because of British secrecy laws, the existence of Colossus remained classified until the 1970s. Several machines were physically destroyed after the war. This is why most American textbooks credit ENIAC as "first": for decades, no one outside British intelligence knew Colossus existed.
Atanasoff–Berry Computer (1942) — First Electronic Computer
The ABC was built at Iowa State College by John Atanasoff and his graduate student Clifford Berry. It was electronic (vacuum tubes), used binary arithmetic, and could solve systems of linear equations. But it was not programmable — it could only do the one task it was wired for.
In 1973, a famous U.S. federal court ruling (Honeywell v. Sperry Rand) declared the ABC the legal originator of the electronic computer, invalidating ENIAC's patent. So in a strictly legal sense, the ABC is "first."
Babbage's Analytical Engine (1837) — First Designed (Never Built)
Charles Babbage designed the Analytical Engine in the 1830s — a mechanical, programmable, general-purpose computer using punched cards. He never finished building it; the precision engineering required exceeded what Victorian machine shops could deliver.
In 1843, Ada Lovelace wrote what is considered the world's first computer program — an algorithm for the Analytical Engine to compute Bernoulli numbers. She wrote software for hardware that didn't yet exist.
A working Analytical Engine was eventually built — partially — by the Science Museum in London in the 1990s. It worked.
Comparison Table: The Five Candidates
| Machine | Year | Country | Electronic? | Programmable? | General-Purpose? | Notes |
|---|---|---|---|---|---|---|
| Analytical Engine | Designed 1837 | UK | No (mechanical) | Yes | Yes | Never finished in Babbage's lifetime |
| ABC | 1942 | USA | Yes | No | No | First electronic; one task only |
| Z3 | 1941 | Germany | No (relays) | Yes | Yes (Turing-complete) | Destroyed in WWII bombing |
| Colossus | 1943 | UK | Yes | Partially | No (cryptanalysis only) | Classified until 1970s |
| ENIAC | 1945–1946 | USA | Yes | Yes | Yes | First general-purpose electronic programmable |
How ENIAC Actually Computed
ENIAC's basic operation was decimal addition. Each digit of a 10-digit accumulator was stored as a ring of ten flip-flop circuits — only one of the ten was "on" at any time, representing the digit. Numbers were sent between modules over thick patch cables. Multiplication used repeated addition; division used trial subtraction.
There was no stored program. The instructions lived in the wiring itself. Want to run a different calculation? Pull the cables out and rewire. This is why John von Neumann's 1945 paper on the EDVAC architecture — proposing that programs be stored in the same memory as data — was revolutionary. Every computer you've ever used follows the von Neumann architecture (EDVAC, 1949), not the ENIAC pattern.
The Origin of "Bug" and "Debug"
In September 1947, Grace Hopper and her team at Harvard logged an actual moth that had gotten stuck in a relay of the Harvard Mark II computer. They taped the moth into the logbook with the note: "First actual case of bug being found." The terms bug (for hardware fault) and debug (for fixing it) had been used in engineering before, but Hopper's logbook entry is the moment they entered computing folklore.
The women programmers behind ENIAC: erased history
While Eckert and Mauchly built the machine, six women actually made it work: Kay McNulty, Betty Jennings, Betty Snyder, Marlyn Wescoff, Fran Bilas, and Ruth Lichterman. These "ENIAC programmers" faced a task that had no precedent: the machine had no manual, no software, no debugging tools. They had to understand the hardware deeply enough to wire programs directly into it.
Their achievement was extraordinary. They debugged hardware problems by reading voltage traces. They optimized programs by hand. They solved problems that the engineers who built ENIAC couldn't. Betty Snyder famously discovered that a tube going bad could be identified by listening to the pitch of the hum it produced — she literally debugged by ear.
Yet they were invisible. Newspapers in 1946 called ENIAC a "giant brain," as if the machine itself had generated intelligence. The programmers were depicted as knob-turners. For decades, "computer science" history proceeded as if the programmers didn't matter — only the engineers who designed the hardware.
A 1997 documentary, "Top Secret Rosies," finally recovered their stories. By then, decades of computer history had been written with them erased from it. This erasure had real consequences: women's contributions to early computing were systematically undervalued, and computer science developed a culture that treated software as secondary to hardware — a gender division that persists today.
Source: McCartney, S. (1999) — ENIAC: The Triumphs and Tragedies of the World's First Computer; also the 1997 documentary "Top Secret Rosies."
From ENIAC to Your Phone
The path from 30 tons to your pocket spans the entire history of solid-state electronics:
- 1947 — Transistor invented at Bell Labs (Shockley, Bardeen, Brattain), beginning the end of the vacuum tube era.
- 1958 — Integrated circuit (Jack Kilby at Texas Instruments and Robert Noyce at Fairchild Semiconductor independently), putting multiple transistors on one piece of silicon.
- 1971 — Intel 4004 microprocessor — 2,300 transistors on one chip, proving Moore's Law was for real.
- 1975 — MITS Altair 8800, the first true personal computer kit, which sparked the home computer revolution.
- 2024 — Apple M4 chip — approximately 28 billion transistors, each one smaller than a virus.
ENIAC's 5,000 additions per second now happens in your phone in less time than a single neuron fires. The transformation from room-sized room to pocket-sized miracle, from days to rewire to microseconds to reprogram, required not just engineering but a revolution in materials science, manufacturing, and software architecture.
The architecture revolution: von Neumann's stroke of genius
John von Neumann's 1945 proposal for the EDVAC (Electronic Discrete Variable Automatic Computer) introduced a conceptual breakthrough that changed computing forever. His key insight: the computer's program could be stored in memory, just like data.
Before von Neumann, computers like ENIAC had the program wired in. Every different problem required physical rewiring — days or weeks of work. Von Neumann's stored-program concept meant: load the program into memory as data, execute it, then load a different program. This single idea made computers programmable in the modern sense.
The Manchester "Baby" (Small-Scale Experimental Machine) became the first stored-program computer to actually run, on June 21, 1948. It was small (by standards of the time), fast-ish for the era, and proved the concept worked. Every computer you've ever used — including your phone, your laptop, and servers powering the cloud — follows the von Neumann architecture. It's the unifying principle of computing.
Source: von Neumann, J. (1945) — "First Draft of a Report on the EDVAC"; also the Manchester "Baby" documentation, archived at the University of Manchester Computing Laboratory.
Why this history matters: lessons for technology today
The story of computing's origins contains three critical lessons often missed:
First: The answer to "who invented X" is usually wrong. Computing wasn't invented by one person or team. It emerged from overlapping tracks (Babbage, Zuse, Turing, Atanasoff, Eckert, Mauchly, Flowers, von Neumann) in different countries, often working in isolation, building on abstract mathematics and engineering traditions. The "first computer" is a story about how we choose to define things, not about objective history.
Second: Economic context shapes what gets remembered. ENIAC is famous because it was built in America and no one classified it; its story was told and retold. Colossus was equally innovative but spent decades hidden. Z3 was brilliant but Germany lost the war. Babbage's engine was ahead of its time but impossible to build. History remembers the winners.
Third: The human element gets systematically erased. ENIAC is remembered as a achievement of Eckert and Mauchly's engineering. The ENIAC programmers — the women who actually made it work — were invisible for 50 years. Similarly, Grace Hopper's contributions to compilation and the term "bug" were largely credited to the men around her. In modern tech, this pattern continues: women write the majority of production code but are underrepresented in leadership and technical fame.
Understanding this history is not nostalgia; it's a reality check on how we credit achievement and whose contributions we forget to see.
The Birth of Programming Languages and Software
ENIAC had no software — programs were the hardware configuration. But this limitation drove innovation. Grace Hopper, who worked on the Harvard Mark II and later on UNIVAC, pioneered the first compiler (A-0, 1952) — software that translated human-readable instructions into machine code. Before compilers, programmers hand-wrote binary. Hopper's compiler automated this translation, making programming vastly more accessible.
Hopper later developed COBOL (1959), specifically designed for business applications. COBOL is verbose (almost English-like) and designed for clarity over elegance. Despite being mocked by computer scientists as inelegant, COBOL powered banking, insurance, and government systems for decades — and still does. Hopper's insight was that programming languages should be designed for human readability, not machine efficiency. This principle remains central to modern language design.
FORTRAN (1957, Backus et al.) was the first widely-used high-level language for scientific computing. ALGOL (1958) established syntactic conventions (block structure, if-else statements) that shaped every programming language since.
These innovations happened because ENIAC and its successors exposed a bottleneck: human effort to write programs vastly exceeded machine time. Automating that translation was economically essential. This is why programming languages emerged so rapidly — economic pressure drove their development.
Source: Hopper, G. (1981). "The First Compiler." Systems and Software — Hopper's own account of inventing the compiler.
The Transistor Revolution: From Tubes to Silicon
ENIAC used vacuum tubes — costly, power-hungry, unreliable (tubes burned out after ~1,000 hours). The transistor (invented at Bell Labs in 1947 by Shockley, Bardeen, and Brattain) offered a replacement: smaller, faster, more reliable, vastly cheaper. Yet adoption was slow.
The first computers using transistors appeared in 1955-1958 (TRADIC, TX-0, Philco). Early transistors were expensive — a computer-sized transistor cost ~$20 in 1954 (equivalent to ~$300 in 2024). But production ramped up, and costs fell exponentially. By 1960, transistors were cheaper and more reliable than tubes.
The integrated circuit (1958, independently by Kilby and Noyce) put thousands of transistors on a single silicon chip. This single invention — enabling mass production of complex circuits — was the foundation for everything that followed. Without it, computers would still be room-sized and unaffordable for most users.
Moore's Law (observed by Intel co-founder Gordon Moore in 1965): the number of transistors on a chip doubles roughly every two years. This exponential growth has held for six decades, enabling the smartphone in your pocket to have 28 billion transistors (compared to ENIAC's 17,468).
Source: Moore, G. E. (1965). "Cramming more components onto integrated circuits." Electronics Magazine. — The original Moore's Law paper.
Computing Before Computers: Mechanical and Human Calculation
We tend to think of "computers" as electronic, but the word originally meant something else: a person who computes. Throughout history, calculations were performed by human computers — often women — performing routine arithmetic. These weren't amateurs; they were skilled at rapid mental math, checking errors, and organizing complex multi-step calculations.
Babbage's failed Analytical Engine was designed partly because manual human computation was expensive and error-prone. Creating a machine that could automate calculation would free up human computers for more creative work. The irony is that Babbage himself spent years trying to build a machine that turned out to be as complex to design and build as the hiring and training of human computers — the "automation" problem is perennial.
Mechanical calculators (Pascaline, 1642; Stepped Reckoner, 1673) automated arithmetic but required manual operation for each calculation. They were faster than paper-and-pencil but vastly slower than modern computers and infinitely less versatile.
The ENIAC programmers (Kay McNulty, Betty Jennings, et al.) were hired from the ranks of human computers — women who had been computing artillery firing tables by hand. They already understood mathematical procedures and the logic of multi-step calculation. This background prepared them perfectly to program ENIAC, even though the skill set was novel.
The shift from human to electronic computation wasn't just technological; it was social and economic. It eliminated vast numbers of human computing jobs, disproportionately affecting women. The irony of this workforce transition — women built the machines that automated away women's work — deserves far more historical attention than it has received.
Source: Grier, D. A. (2005). When Computers Were Human. Princeton University Press. — Social history of human computation.
The Legacy of Early Computers: Von Neumann's Architecture
While John von Neumann didn't invent any specific computer, his 1945 "First Draft" report proposing a stored-program architecture profoundly shaped all subsequent computing. His key insight: if a computer can read instructions from memory (like data), then the same machine can run different programs without rewiring.
This concept, implemented in the EDVAC (Electronic Discrete Variable Automatic Computer, 1949, partially) and Manchester Baby (1948, fully), defined what we mean by a "computer" today. Every computer you've ever used — from your phone's processor to a supercomputer — follows von Neumann architecture:
- Memory: stores both instructions (programs) and data
- Control unit: fetches instructions from memory, decodes them, and directs their execution
- ALU (arithmetic-logic unit): performs calculations
- Input/output: interfaces with the outside world
This architecture is so fundamental that alternative proposals (like dataflow computers, which don't use a traditional control unit) remain niche research topics. Von Neumann architecture won because it's simple, flexible, and proved universally applicable.
The limiting principle Von Neumann architecture introduces is the Von Neumann Bottleneck: memory access is much slower than computation, so most computer time is spent waiting for data to move between memory and CPU. All modern computer design — from caching strategies to GPU parallelization — is an attempt to mitigate this bottleneck.
Source: Von Neumann, J. (1945). "First Draft of a Report on the EDVAC." — Foundational paper on stored-program architecture; also later retrospectives on Von Neumann architecture limitations.
Computing Goes Commercial and Personal
The mid-1950s to 1960s saw computers transition from research novelties to commercial products. IBM dominated — their System/360 (1964) was the first modular computer line, where different models could run the same software. This modularity and compatibility drove IBM's market dominance for decades.
Minicomputers (PDP-11, Data General Nova, 1960s-1970s) brought computing to departments and universities, replacing the centralized mainframe model. Personal computers (Apple II, 1977; Commodore 64, 1982; IBM PC, 1981) brought computing to homes.
What's remarkable is how quickly this happened. ENIAC was built in 1945. The Apple II shipped in 1977 — 32 years later. In that time, computer power increased ~10-millionfold (ENIAC: ~5,000 operations/second; Apple II: ~1 million), and cost per operation fell from millions of dollars to pennies.
This exponential progress — predicted by Moore's Law but no less astonishing in retrospect — is the foundation of everything we call the "digital age."
The takeaway
There's no single "first computer" because the definition matters. Babbage designed the first programmable computer in 1837 but never finished building it. Zuse built the first working programmable computer in 1941 but it was destroyed in WWII and forgotten for decades. Colossus cracked the Lorenz cipher in 1943 but stayed classified. The ABC was the first electronic computer in 1942 but couldn't be programmed. ENIAC arrived in 1946 as the first general-purpose, electronic, programmable computer — and it's the one history chose to remember, partly because the U.S. won WWII and could tell the story.
What matters historically is not which machine won the "first" title, but recognizing that computing emerged from a convergence of ideas: Babbage's algorithmic thinking, Boole's logic, Turing's theoretical framework, Shannon's information theory, and the post-WWII engineering resources to actually build machines. It required the transistor's invention, the integrated circuit's commercialization, and programming languages (FORTRAN, COBOL) to make machines usable. And crucially, it required people — engineers, programmers, and particularly the women programmers who have been largely written out of the story. The computer you're reading this on is a direct descendant of all these parallel developments, erased differences, and forgotten contributors. Computing didn't spring from any single genius; it emerged from a global scientific and industrial effort that spanned a century of incremental breakthroughs, war-driven urgency, and collaborative genius — most of which remains unknown to the public that uses these machines every day.
Frequently Asked Questions
Q: Was ENIAC really the first computer?
A: It depends on your definition. ENIAC was the first general-purpose electronic programmable computer, but the Z3 (Germany, 1941) was the first programmable computer using relays, and Colossus (UK, 1943) was the first programmable digital electronic computer for specialized cryptanalysis. Each claim is legitimate depending on what features you prioritize.
Q: Who invented the computer?
A: There's no single inventor. Charles Babbage designed the first programmable computer (1837). Konrad Zuse built the first working programmable computer (Z3, 1941). Eckert and Mauchly built the first general-purpose electronic one (ENIAC, 1946). All have a claim.
Q: Why don't we hear more about Colossus?
A: British secrecy laws classified everything done at Bletchley Park until the 1970s. By the time the story could be told, ENIAC had already been credited as "first" in textbooks worldwide. Also, Colossus was destroyed after WWII, so no physical machine existed to study.
Q: Did Ada Lovelace really write the first computer program?
A: Yes. Her 1843 notes on Babbage's Analytical Engine include a detailed algorithm for computing Bernoulli numbers — widely considered the first published algorithm intended for a machine. She was writing software for hardware that didn't yet exist.
Q: How was ENIAC programmed?
A: By physical rewiring. Programmers moved patch cables between modules and set rotary switches. There was no software in the modern sense — the program lived in the hardware configuration. A new program could take days or weeks to set up.
Q: When did the first stored-program computer appear?
A: The Manchester "Baby" (Small-Scale Experimental Machine) ran the first stored program on June 21, 1948. It implemented von Neumann's architecture and is the direct ancestor of every modern computer, including your phone and laptop.
Read next:
Follow new articles
Add SciHub101 to your feed reader to see new science and technology stories.
About the Author
SciHub101 is an independent science and technology publication founded and edited by Buğra Sözeri, a software engineer and app developer based in Türkiye. AI tools assist with drafting and research. Source documentation in the existing archive is uneven, and articles are being reviewed and corrected. The Editorial Team byline identifies editorial responsibility; it does not certify specialist or independent human review. Where we compare products, anything built by our own team is labelled as such — see the editorial guidelines and About page for how corrections and disclosures work.
Related Articles

Top 5 Productivity Tools for Remote Work
Notion, Linear, Slack, Loom, Calendly — the five tools remote teams actually use in 2026, with open-source alternatives and evidence-based picks.

Countries with the Most Robots in Manufacturing (Robot Density Ranked)
South Korea has 1,012 industrial robots per 10,000 manufacturing workers — the highest robot density ever recorded for a major economy. That is more than six times the global average of 162, and more than double Germany's figure. The IFR World Robotics 2024 report shows a world where automation in factories is accelerating faster than at any point in industrial history.

Complete Technology Guide 2026 — How Modern Tech Works
The complete guide to technology in 2026: how the internet, semiconductors, and quantum computing work, AI hardware, cybersecurity, and what's coming next.

Cybersecurity Threats in 2026: What the Data Actually Shows
Ransomware attacks tripled year-over-year between Q1 2024 and Q1 2025. The average time attackers spend exploiting a known vulnerability dropped from 700 days in 2020 to 44 days in 2025. AI is now on both sides of every attack. Here is what the current threat landscape looks like, what is driving it, and what organizations and individuals can do about it.

How the TikTok Algorithm Works in 2026
TikTok's For You Page (FYP) is powered by a recommendation engine that does one thing obsessively: predict which video you will watch longest. It uses watch time, replays, shares, and dozens of secondary signals to build a real-time model of your interests — then tests that model continuously by mixing in new content. Understanding the mechanics explains why the feed feels eerily accurate and why some videos reach millions of people who have never heard of the creator.

How to Build Your First Website With No Coding Experience
Building a website in 2026 requires zero coding knowledge for most use cases — but the choices you make in the first hour determine whether you're fighting the tool for years or growing smoothly. Here is what the options actually are, what they cost, and the path most first-timers should take.