You think the Internet started in the 90s. You’re not alone. Most people trace their digital lineage back to the dial-up screech of the World Wide Web. That was the user experience. It wasn’t the origin.
The actual hardware roots go back much further. To a place called ARPANET.
This isn’t just a footnote. It’s the skeleton the modern web is built on.
Why the government needed a backup plan
It started in 1966. The Advanced Research Projects Agency (ARPA ) was looking at a specific problem. How do you keep information alive if the world ends?
Specifically, a nuclear one.
The U.S. government wanted decentralized storage. If a bomb hit a central server, data dies. If that server is part of a network, the network reroutes. The system survives. It’s about resilience. ARPA hosted a program called Resource Sharing Computer Networks. The goal was simple: link computers together to increase power and spread the risk.
From theory to bids took two years. In 1968, ARPA sent out a Request for Quotation (RFQ ). They wanted the first wide area network.
The machines that started it all
Bolt, Beranek and Newman (BBN) won the contract. They were an acoustics firm. Not a computer giant. But they designed the Interface Message Processors (IMPs ).
Four of them.
These machines were the routers of their era. They created open communication between four distinct computers. Each computer ran a different operating system. None of them spoke the same language. The IMPs made them listen to each other.
The team building this wasn’t a monolith. Electrical engineers. Computer scientists. Applied mathematicians. Graduate students. They documented everything in Request for Comments (RFCs ). You can still read them today at the Internet RFC/STD/FYI/BCP Archives. It’s the raw code of how we talk to machines now.
What made ARPANET tick?
We’re going to look at the gear. The original four-node setup.
You’ll see the protocols that allowed disparate systems to share data. You’ll see where the functions you use every day—email, file transfer, basic connectivity—actually came from. And yes, we’ll look at how it ended. But first, the hardware.
ARPANET Computers
The First Four Nodes and the Honeywell IMP
Before ARPANET, your computing experience was rigid. You sat at a terminal. It was hardwired to a massive mainframe, often filling an entire room. Timesharing let multiple users tap into that single beast simultaneously. Other early networks were even more restrictive. They demanded direct connections between hosts. Only one path existed for data to flow. These setups became known as local area networks (LANs ). They couldn’t scale.
ARPA had a bigger vision. They wanted a national network linking government and scientific bodies. The first phase was modest by design. Four computers. Four locations. Existing phone lines. Four Interface Message Processors (IMPs ).
ARPA picked the initial sites based on existing research ties to the US government. Each site had engineers tasked with connecting their host to the new network. The lineup was specific:
- UCLA ran an SDS Sigma 7 on the Sigma Experimental OS.
- Stanford Research Institute used an SDS-90 Computer running Genie.
- The University of California’s Culler-Fried Interactive Mathematics center operated an IBM 360/75 on OS/MVT.
- The University of Utah hosted a DEC PDP-10 with the Tenex OS.
August 1969 marked the start. UCLA connected its host to an IMP first. That IMP was a Honeywell DDP 516. Within days, the two machines exchanged info. Stanford joined in October. At 10:30 p.m. on October 29, UCLA and Stanford talked over a 50 kilobit per second phone line.
The first attempt crashed. UCLA couldn’t send a full command. The second try worked. The other two sites joined before 1969 ended. Scientists could finally leverage remote compute power.
Comparing 1969 Hardware to Modern Specs
Put the Honeywell DDP 516 next to a modern desktop. It looks like a toy. The IMP had 12 kilobytes of memory. You can buy a new PC today with over 1 gigabyte. That’s 1,000,000 kilobytes. The processing power gap is staggering.
How ARPANET Protocols Were Built
We take the internet for granted now. Email loads. Websites render. But ARPANET had no rules. No systems to share data. Everything had to be invented from scratch.
The team made a critical choice. They created standardized protocols for hosts and IMPs to follow. The Network Working Group took charge. Early development was messy. Chaotic. The team designed protocols via Request for Comments documents, or RFCs.
Two tasks emerged early. Remote login. File transfer. Remote login became Telnet. Moving files became the File Transfer Protocol (FTP ). Larry Roberts, the project head, rejected these initial protocols. Not ambitious enough. He demanded more functions.
The team pivoted to the Network Control Program (NCP ). It was a symmetric host-host protocol. In plain terms, it let computers talk and allowed new hosts to join. NCP controlled data flow and paths. It introduced numeric host addresses. This was the ancestor of today’s domain name servers (DNS).
Why Packet Switching Changed Everything
ARPANET used a revolutionary method: packet switching. Host computers broke files into small segments called packets. Once transferred, the pieces reassembled into the original file.
This matters today. Packet switching makes the internet fast. One huge file blocks the path. It eats bandwidth. Smaller packets take different routes. If one path fails, blocked packets find another way. The rest of the data keeps loading.
NCP laid the groundwork for the Transmission Control Protocol/ Internet Protocol (TCP/IP) suite. Robert Kahn and Vinton Cerf designed TCP/IP. It dictates how info moves and verifies delivery. Think of it as traffic control. Without it, computers wouldn’t know available paths. The network would crash.
Early Capabilities of the Network
ARPANET enabled things previously impossible or limited to tiny scales. It changed how people used computers.
How ARPANET users actually communicated
Remote access changed everything. Before this, if you wanted data on a machine in California and you were in Massachusetts, you traveled. Or you waited. ARPANET let you log into a system miles away. Researchers stopped commuting to libraries of hard drives. They just dialed in.
1971 brought the Terminal Interface Processor (TIP ). This hardware let individual terminals connect to the network. It wasn’t just for mainframes anymore.
Files moved too. By late 1970, ARPA updated the IMP software. One IMP could download new code from another. Then it pushed that code to every other IMP. Centralized updates. No more manual patches at every site.
Then came the big one. E-mail.
Ray Tomlinson wrote it in 1972. He used two Tenex OS apps: SNDMSG and READMAIL. He needed a separator between the user name and the computer name. He picked “@”.
We still use it. He didn’t know it would stick for half a century. He just needed something not used in names.
Team members started abusing it immediately. Mailing lists popped up. You could blast a message to a group in one click. SF-LOVERS was the first. Science fiction fans bonding over the network.
ARPA hated it. They wanted the net for work. Not fan fiction. They ordered the lists dissolved. Users fought back. Their argument? The lists tested the mail capacity. More traffic meant better stress tests. ARPA eventually caved.
Why connecting networks was harder than expected
- Robert Kahn started an experiment called internetting. The goal: merge two separate networks. One was ARPANET. The other was the Defense Advanced Research Projects Agency’s (DARPA ) Packet Radio Network.
Radio waves carry data differently than cables. Combining them wasn’t plug-and-play. It required a new way to handle routing. Kahn looked at how to make these distinct systems talk without breaking each other.
It took ten years to get it right.
The protocol switch that saved the internet
1983 marked the hard deadline. ARPANET ditched NCP. It switched to the TCP/IP suite.
This wasn’t a minor update. It was a structural overhaul. The architecture ARPANET built foreshadowed the modern Internet. But the protocols? Those had to change to survive.
The apps users built—email, file transfers, mailing lists—paved the way for today’s web. The infrastructure followed the behavior.
Who actually built ARPANET?
It wasn’t one genius. It was hundreds. Here are the names that matter:
- J.C.R. Licklider : ARPA head. Dreamed of an “Intergalactic Network”.
- Larry Roberts : Program manager. Made the dream happen.
- Robert Kahn : Designed the network protocols for internetting.
- Vinton Cerf : Co-author of TCP/IP. The other half of the protocol brain.
- Will Crowther and Dave Walden : BBN programmers.
- Mike Wingfield : Built the first hardware interface linking a computer to an IMP.
- Paul Baran, Donald Davies, Leonard Kleinrock : Mathematicians. They developed packet switching.
The end of an era
ARPANET didn’t just vanish. It faded into the infrastructure it created.
By the 80s, the military split off to MILNET. The academic parts merged into the NSFNET. ARPANET as a distinct entity shut down in 1990.
But the code remained. The email addresses stayed. The concept of linking networks became the default.
We take it for granted now. Clicking a link. Sending a file. Logging in remotely.
It started with a radio network and a science fiction mailing list.
The network outlived its creators. That’s the point.
how the internet split from arpanet and why it matters today
The growth wasn’t just linear. It was explosive. Between 1969 and 1977, ARPANET went from four nodes to 111. These weren’t random machines. They were heavy hitters. Universities. Research labs. The military. Satellite links stretched the reach from the continental US to Hawaii and Europe. A global footprint, essentially.
Yet. Almost no one saw it. The public had no idea ARPANET existed. It was a secret garden of data, walled off from the average user.
But the walls were porous. Other networks started popping up. USENET. Ethernet. CSNET. BITNET. They didn’t just sit next to ARPANET. They needed to talk to it.
Enter RFC 827. This document changed everything. It established the External Gateway Protocol. Suddenly, separate networks could access each other. The silos broke down. Even though ARPANET remained restricted for official use, the infrastructure for a connected world was laid.
Then came 1983. A clean break. The military section of ARPANET split off. Its only tether to the larger network was a few e-mail gateways. The military renamed its slice MILNET. This would eventually fold into the Department of Defense Data Network (DDN). The civilian side kept going, but the military had its own lane now.
the birth of the modern internet backbone
1986 brought a new player. Five supercomputer centers formed a network called NSFNET. It was fast. It was powerful. And it invited universities to join.
NSFNET grew. Rapidly. Other networks consolidated into larger systems. People started calling this tangled web of networks and gateways the Internet.
Note the distinction. ARPANET was the prototype. The Internet was the ecosystem.
The personal computer era had begun in the late 70s, but the Internet? That was still a resource for institutions. Universities. Corporations. Government. You couldn’t just plug in your home PC and browse the web. Not yet.
By then, ARPANET’s infrastructure was tired. The IMPs (Interface Message Processors) were clunky. Slow. Outclassed by the computer nodes in newer networks like NSFNET. Organizations migrated. They left ARPANET for the faster, more efficient options.
In 1990, DARPA pulled the plug. The project ended. The goals had been met. The US had a nationwide computer network that linked powerful resources. It could survive if large chunks of it went down. Resilience by design. And it spanned the globe. From one side of the world to the other.
hacking culture in the early days
Was it a sterile environment? No. Hacking culture flourished within ARPANET.
Most hackers weren’t criminals. They were contributors. They uploaded useful programs. They improved applications. They built a community for programmers to talk shop. They even invented jargon that stuck. Words we still use today were born in those early terminals.
But it wasn’t all altruism.
A computer virus distributed on the network led to a total system crash in 1980. Chaos.
Then there were the outliers. Hackers like Kevin Poulsen, known as Dark Dante, targeted ARPANET. He gained unauthorized access in 1983. He was caught, obviously. But it showed the vulnerability. The network was a prize.
The distribution of a computer virus led a total system crash in 1980.
Is ARPANET still active? No. It was replaced by NSFNet. The name is gone. The technology? Everywhere.
You might wonder how this connects to your daily life. Every time you load a webpage, send an email, or stream a video, you’re using protocols and concepts refined during this transition. The shift from ARPANET to NSFNet to the commercial Internet is why you have broadband today instead of a dial-up modem screeching at 28.8kbps.
The infrastructure evolved. The users changed. But the core idea—connecting disparate networks into a single, resilient system—remained the same.
How the first hackers built the internet
Jeremy N. Smith laid out the blueprint in his 2007 piece for World Trade Magazine. “The Making of the Internet” isn’t just a history lesson. It’s a receipt. It shows exactly who paid for the infrastructure that now runs your life.
Most people think the web appeared out of thin air. It didn’t. It was built by people who wanted to connect computers. They used protocols. They wrote code. They argued about standards until someone caved. That friction created the structure.
Smith’s work highlights the transition from isolated networks to a global mesh. It wasn’t a smooth ride. There were dead ends. There were proprietary systems that refused to talk to each other. The internet won because it was open. Or at least, it pretended to be.
The human side of code
Mark Ward’s 2000 BBC News article, “Hacking: A history,” zooms in on the people. Not the guys in hoodies breaking into banks. The original hackers. The tinkerers.
These weren’t criminals. They were curious. They wanted to see how things worked. If it was closed, they opened it. If it was slow, they sped it up. This ethos shaped the early internet. It made the web resilient. It also made it chaotic.
Ward points out that this culture didn’t just build software. It built a mindset. One that values access over permission. That attitude is still here. You see it in open-source projects. You see it in bug bounties. You see it in the way users bypass DRM.
Why this history matters now
You might wonder why we care about 2000 and 2007 articles. Because the current internet feels different. It’s walled. It’s curated. It’s expensive.
Reading these older perspectives reminds us of a different time. A time when the net felt wilder. Less controlled by a handful of Silicon Valley giants. More driven by individual curiosity.
Smith’s analysis of trade and technology shows how commerce followed the pipes. Ward’s look at hacking shows how culture followed the code. Both are still relevant. The fight between open access and closed gardens hasn’t ended. It just moved to a new platform.
We built the tools. Now we live in them. The question isn’t who built it. It’s who controls it now. And whether we can take it back.
