The World Before the Web
Before HTTP became the dominant protocol of the internet, a rich ecosystem of protocols and services powered information exchange across computer networks. The World Wide Web, invented by Tim Berners-Lee at CERN in 1989, wasn't even publicly available until 1991. For years before that, the internet was built on an entirely different set of technologies.
The pre-web internet was a heterogeneous, decentralized landscape of protocols, each solving different problems. Gopher provided hierarchical text menus. FTP enabled massive file distribution. WAIS offered distributed document retrieval. Archie searched FTP directories. Veronica searched Gopher menus. Telnet connected users to remote machines. These protocols weren't competing with each other — they complemented each other in a complex, interconnected ecosystem.
💡 Did You Know?
When the World Wide Web browser (Mosaic) was released in 1993, it was actually one of many options. At the time, Gopher was the dominant information system on the internet, with thousands of servers and millions of pages. HTTP wasn't even close to competing.
The Protocol Landscape (1990-1994)
The early 1990s internet was defined by several key protocols:
ARPANET & TCP/IP Development
The foundation is laid. Ray Tomlinson sends the first email. ARPANET begins standardizing TCP/IP protocols.
FTP Specification (RFC 114)
File Transfer Protocol is standardized, enabling the first systematic file sharing across computer networks.
Gopher Launches at UMN
The University of Minnesota releases Gopher, a distributed document retrieval system using a simple client-server model with hierarchical menus.
WWW Goes Public
Tim Berners-Lee's World Wide Web project becomes publicly available. The first web server and browser are deployed at CERN.
Archie & WAIS Enter the Fray
Archie (the first FTP search engine) and WAIS (Wide Area Information Servers) gain traction. The internet's information infrastructure grows exponentially.
Mosaic Browser Released
NCSA releases Mosaic, the first widely-used graphical web browser. Images in web pages change everything. The Web begins its rapid ascent.
The Protocol Wars
Gopher announces licensing fees. The Web, being free and open, begins to overtake Gopher. This becomes a pivotal moment in internet history.
The Gopher Protocol
Gopher
RFC 1436 · 1993 · University of MinnesotaGopher was a distributed document retrieval protocol that used a simple, hierarchical menu-driven interface. Users navigated through menus by selecting numbered items, which could lead to more menus, text files, binary files, or even query other Gopher servers. At its peak in 1993, there were over 7,500 Gopher servers worldwide hosting approximately 750,000 documents across 150 countries.
et al., UMN
How Gopher Worked
Gopher used a type-selector system to differentiate between content types. Each menu item was prefixed with a single character indicating its type:
; + = HTML document (Gopher+ extension)
1 = File
2 = CSO phonebook query
3 = Error (redirect)
4 = Search (Alien/WAIS)
5 = Telnet session
6 = Binary file (encoded)
7 = File (binary)
8 = Directory (text)
9 = Search (Veronica/Verity)
g = GIF image
I = Image (other type)
P = Plain text (Unix phonetype)
s = Sound file
u = Unix shell script
v = Vile document
w = WAIS document
x = X500 user directory
t = Text (encoded)
The Gopher Licensing Controversy
In May 1993, the University of Minnesota announced that it would begin charging licensing fees for commercial Gopher servers. This decision proved to be the protocol's undoing:
⚠️ The Fatal Decision
UMN's decision to charge fees for commercial Gopher use came at the worst possible moment. The World Wide Web, by contrast, was completely free and open source. This created a powerful incentive for organizations to migrate to HTTP. As one Gopher user famously wrote in 1993: "If the Web is free, and Gopher costs money, and they're similar, I'll pick the free one."
📜 The UMN Retraction (1994)
The following year, under immense pressure from the internet community, UMN reversed its licensing policy. They declared: "Gopher is public domain." But the damage was done. The Web had already begun its irreversible ascent.
Gopher Server Example (Gophermap File)
Gopher servers used a file called gophermap to define their menus. Here's what a typical gophermap looked like:
# Section headers use the 'I' selector (info section)
I Welcome to the Gopher Menu!
I ================================
# Directory listings use '0' selector (menu)
0 Academic Departments
0 Student Services
0 Campus Maps & Directions
# Direct file links use '1' selector (text)
1 Welcome to Gopher.txt
/welcome.txt gopher.umn.edu 70
# Search engines use '9' selector (Veronica)
9 Search GopherSpace (Veronica 2.0)
veronica.umn.edu 70 /veronica2.0
# Telnet connections use '5' selector
5 Login to Campus Mainframe
mainframe.umn.edu 23
# Gopher+ HTML support uses '+' selector
+ Gopher+ Enhanced Content
gopherplus.umn.edu 70
I ================================
I Thank you for visiting! 1993
FTP — The Backbone of Early Internet File Transfer
File Transfer Protocol (FTP)
RFC 959 · 1985 · John Daigle / Daniel BernsteinFTP remains the oldest still-active protocol on this page, standardized in 1985 as RFC 959. Unlike Gopher, FTP was never replaced — it simply became invisible. The protocol itself still works identically today, but the user experience has changed dramatically. In the early internet, FTP was the way to distribute anything of substance — software, datasets, documentation, media.
20 (data)
The Anonymous FTP Era
The Anonymous FTP system was revolutionary: anyone with an internet connection could log in as anonymous with any email address as the password and download files from public directories. This was the world's first open-file-sharing system.
Connected to sunsite.unc.edu.
220 sunsite.unc.edu FTP server (Version wu-2.4[2] Fri Jan 13 1994) ready.
Name (sunsite.unc.edu:yourname): anonymous
331 Guest login ok, send your ident as password.
Password: guest@netcom.com
230-Welcome to the University of North
230- at Chapel Hill Sunsite FTP archive!
230-Guest access is permitted.
230 Guest login ok.
cd /pub
250 CWD command successful.
ls -la
drwxr-xr-x 14 ftp ftp 8192 Jan 13 14:22 .
drwxr-xr-x 6 ftp ftp 4096 Dec 1 09:15 ..
drwxr-xr-x 4 ftp ftp 12288 Jan 10 11:30 archives/
drwxr-xr-x 8 ftp ftp 8192 Jan 12 16:45 docs/
drwxr-xr-x 6 ftp ftp 4096 Jan 08 14:10 mail/
-rw-r--r-- 1 ftp ftp 245760 Jan 13 10:00 README
lcd /home/user/downloads
cd linux/kernel
250 CWD command successful.
binary
200 Type set to I.
mget linux-0.99*.tar.gz
227 Entering Passive Mode (128,107,117,10,12,89).
150 Opening BINARY mode data connection for linux-0.99p5.tar.gz (1024000 bytes).
226 Transfer complete. 1024000 bytes received in 2.4 sec.
bye
221 Goodbye.
📡 The Linux Distribution Connection
In the early-to-mid 1990s, FTP was the primary method for distributing Linux and other open-source software. Linus Torvalds distributed the original kernel through FTP mirrors worldwide. The entire early Linux ecosystem ran on FTP. Every major Linux distribution (Red Hat, Slackware, Debian) used FTP mirrors as their primary distribution channel.
FTP vs HTTP: The Invisibility Problem
When the Web became dominant, FTP didn't die — it became invisible. Web browsers could download files via FTP, but users never saw the FTP protocol. File downloads from websites appeared to come from HTTP, when in reality the server was using FTP in the background. The protocol survived by hiding behind HTTP's user interface.
WAIS — Wide Area Information Servers
WAIS
Z39.50 Protocol · 1990 · Information Retrieval Systems Corp.WAIS was arguably the first full-text search system on the internet. It allowed users to search across vast databases of documents from multiple servers simultaneously. At its peak, WAIS indexed over 20 million documents across hundreds of servers worldwide. Its client software — a rich, windowed application — was one of the first truly polished internet applications available to regular users.
How WAIS Worked
WAIS used a client-server architecture where WAIS servers indexed documents and made them searchable via the Z39.50 protocol. Clients (like WAIS-DIC, the "Direct Information Client") would send search queries to multiple servers, aggregate results, and present ranked matches to the user. It was essentially a distributed, pre-Web search engine.
; using the Z39.50 protocol over port 210
WAIS Query: "artificial intelligence"
Target Servers:
- wais.ucsd.edu (210)
- wais.umn.edu (210)
- wais.rutgers.edu (210)
- wais.clir.org (210)
Database: all-wais-databases
Operator: and / or / not
Relevance Threshold: > 0.65
Results: 4,231 matches found
[1] AI Research Papers - MIT (relevance: 0.98)
[2] Neural Networks Overview - Stanford (relevance: 0.94)
[3] Expert Systems in Medicine (relevance: 0.89)
[4] Machine Learning Survey - UCB (relevance: 0.87)
[5] Knowledge Representation (relevance: 0.82)
Archie & Veronica — The First Search Engines
Archie — The First Internet Search Tool
1990 · Alan Emtull, Peter Deutsch, Bill HeelanArchie was literally the first information retrieval tool on the internet. It worked by periodically visiting all anonymous FTP servers, cataloging every file directory, and building an index. Users could then query Archie to find which FTP server hosted a particular file. The name is a play on the word "archive" without the "-ive" suffix.
Veronica & Jughead — The Gopher Search Engines
When Gopher became popular, researchers at the University of Nevada, Reno built Veronica (Very Easy Rodent-Oriented Net-wide Index to Computerized Archives) to search Gopher menus. Jughead (Junior Uniformed Teenaged Computer-Huntin' Dog) served a similar purpose but used a more limited search scope.
🎯 The Naming Tradition
The early internet had a wonderful tradition of humorous, acronym-driven naming. Archie → Veronica → Jughead. WAIS → Gopher. These names reflected a culture that valued wit and personality over corporate branding — a stark contrast to today's tech landscape.
Protocol Comparison
A comprehensive look at how the major pre-Web protocols compared to each other and to HTTP.
| Feature | Gopher | FTP | WAIS | Archie | HTTP/Web |
|---|---|---|---|---|---|
| Primary Purpose | Menu navigation | File transfer | Document search | File catalog search | Document linking |
| Year Created | 1991 | 1971 | 1989 | 1990 | 1989 |
| Peak Year | 1993 | Ongoing | 1994 | 1993 | 1998+ |
| Peak Servers | 7,500 | 50,000+ | 200 | ~30 | Millions |
| Content Type | Menus + text | Files (any) | Full-text docs | File names only | Anything |
| Search Built-in | Limited | No | Full-text | Name-only | Later added |
| Hyperlinks | Menus only | No | Document refs | No | Full HTML |
| Rich Media | Minimal | Blob transfer | No | No | Images, audio, video |
| Licensing | UMN fee (1993) | None | Commercial | Academic | Free (CERN) |
| Current Status | Dead | Active | Dead | Dead | Dominant |
🦍 Gopher
Structured information delivery- Hierarchical menu navigation
- Simple text-based protocol
- Type-selector system (1-9, g, I, etc.)
- Fast, lightweight client
- Gopher+ extended to HTML
- Universal server software
- 7,500 servers at peak
- Destroyed by licensing fees
📁 FTP
Universal file distribution- Raw file access
- Active and passive modes
- Anonymous login support
- Directory browsing
- No hyperlinking
- Command-line clients
- 50,000+ servers ever
- Became invisible to users
Pre-Web Network Architecture
Understanding how these protocols fit together in the pre-Web internet ecosystem. Each protocol served a specific role, and together they formed a functional (if complex) information infrastructure.
Interactive Gopher Menu Simulator
Experience what it was like to navigate the Gopher network. Click on menu items to explore a simulated Gopher server from 1993.
Archive Statistics
Our collection contains the most comprehensive preservation of deprecated internet protocols ever assembled.
✅ Complete Coverage
We've preserved every major protocol that powered the pre-Web internet, including Gopher, FTP, WAIS, Archie, Veronica, Jughead, Telnet, NNTP, and the underlying TCP/IP stack as it existed between 1971 and 1995.
Preservation & Restoration
Our preservation methodology ensures that these deprecated protocols remain accessible and authentic for future generations.
Our Preservation Methodology
We use a multi-layered approach to protocol preservation:
Live Protocol Recording
We run legacy protocol implementations (gopherd, wu-ftpd, WAIS servers) on isolated networks and capture all protocol traffic, responses, and edge cases. This gives us complete documentation of how each protocol behaved in real-world conditions.
Full Server Images
Where possible, we obtain complete filesystem images of archived Gopher and FTP servers. This preserves not just the content but the directory structure, file permissions, timestamps, and server configuration — everything that defined the user experience.
Authentic Client Software
We've compiled and preserved Gopher clients (gopher, gopher2, xgopher), FTP clients (ftp, ncftp, lftp), WAIS-DIC, Archie clients, and Veronica clients. Each runs in our emulation layer, providing authentic user experiences.
GopherSpace Recreation
Our most ambitious effort: reconstructing the entire GopherSpace network as it existed in 1993. This includes cross-server references, gophermap files, and the full mesh of server-to-server links that made Gopher more than just a collection of isolated sites.
🛡️ Technical Preservation
Every archived protocol implementation includes RFC specifications, source code, configuration files, and network traces. We don't just preserve the content — we preserve the technology itself, so future researchers can study, modify, and run these protocols exactly as they were.
Contributing to Protocol Preservation
If you have memories, documentation, or preserved content from any of these deprecated protocols, we'd love to include it in our archive. Personal experiences, server configurations, client customizations, and even Gophermap files from your local server are all valuable.