The Internet Almost Became a Menu

IT HISTORY

The Internet Almost Became a Menu

Every website you open today runs on the same thing underneath: a URL, an HTTP request, an HTML document. That whole arrangement has an official name: WWW.

But in 1993, the most popular thing on the internet wasn’t WWW. It was Gopher (not Golang). Built at the University of Minnesota, it ran on port 70, plain text only, menu-driven browsing: one screen of options, pick one, get the next screen. That year, its traffic grew 997%, leaving WWW far behind.

Go online back then and the first thing you saw was a menu.

Here’s where it gets dramatic. Just eighteen months later, Gopher had all but vanished from the internet. The turning point was a single page in February 1993: the University of Minnesota announced that commercial Gopher servers would now require a paid license.

Gopher Is Still Running

I connected to it while writing this piece.

Port 70 can’t get out of my machine, so I pointed a browser at Floodgap’s HTTP gateway instead. It blocked me. What came back wasn’t a menu; it was an interception notice: any Chrome client without valid reverse DNS gets rejected, citing the bandwidth cost of bot scraping. Signed, Cameron Kaiser.

I sat with that page for a moment. Thirty years ago Gopher lost to the Web. Thirty years later, AI crawlers are forcing Gopherspace to shut its own HTTP door.

Switched to curl, and the menu came out as-is:

That’s all it is. One screen of options, hit enter, next screen, nothing extra in between.

I pulled the menu from top to bottom: 124 entries. Item 17 is a document the server hosts itself, titled At age 30, WWW is not the web we wanted.

The Veronica-2 database currently lists 357 Gopher servers still running, 5.5 million entries between them. The largest is in Poland, ftp.icm.edu.pl, with north of two million entries. Floodgap’s box has been up since 1999, running Bucktooth 0.2.9 on an IBM Power 520 under AIX, and its menu carries one line: Plain text is beautiful.

Thirty-odd years, and the interface hasn’t moved a pixel.

Five People Went Around the Committee

Gopher was not born with dignity.

In 1990, the University of Minnesota set out to build a campus information system. Twenty-some department heads and computing specialists spent months in meetings and produced one very long requirements list, plus zero lines of code. Anyone who has sat through that kind of meeting recognizes the scene.

Years later, Farhad Anklesaria described it without mercy:

“A classic design-by-committee monstrosity.”

Mark McCahill didn’t wait for the meetings to finish. He pulled in Anklesaria, Paul Lindner, Daniel Torrey, and Bob Alberti, the five of them shut the door and wrote, and something usable came out fast.

But the committee wouldn’t approve it. So they put the code on FTP and gave it away for free.

Alberti remembers users from all over the country calling the president’s office to say this Gopher thing was great, and asking when the next version was coming out. The president, on the other end of the line, asked: “What are you people talking about?”

He genuinely had no idea. Even the name was a campus in-joke: the football team is the Golden Gophers, and go-fer sounds like “go fetch.” That’s exactly what the protocol does: you want something, I hand you a menu, you pick, I hand you another menu.

Back Then the Web Was Called World Wide Wait

Getting online in the early nineties meant a painfully slow modem, and a single image was a luxury. Gopher went text-first, so pages arrived the instant you asked. The image-carrying Web of the same era was slow enough to earn a nickname: World Wide Wait.

We barely feel that constraint today. Back then, saving a byte meant saving real money, and Gopher’s entire design turned on exactly that.

It even had its own search engines early on, Veronica and Jughead, years ahead of anything on the Web. In March 1993, the protocol was finalized as RFC 1436.

Holding all of this up were five people: writing the protocol, answering mail from users around the world, keeping thousands of servers running, on top of their actual university jobs. I don’t want to imagine what their inboxes looked like during those two years.

One Page

The February 1993 notice ran to a single page: Gopher servers stay free for education and non-profits; commercial use has to contact the university. How much it would cost, how to negotiate, who to talk to: not a word on any of it. Just one line: please contact us.

Within hours, panic had spread through the entire Gopher community.

The university’s math actually made sense. In March, the team sent out a letter defending the decision, and it didn’t mince words:

“In a time where we are having budgets slashed, it is impossible to justify continued resources being allocated to Gopher development unless some good things result for the University of Minnesota.”

The community wasn’t buying it. Developers shelved their projects. Sysadmins said publicly they weren’t going to bet production systems on a protocol with an uncertain future.

I get this completely. I’d have done the same thing. Betting on a protocol was never a bet on what it costs today; it’s a bet on who controls it three years out. Educational institutions stayed free, the fee schedule never actually materialized, and none of it mattered anymore. The panic alone had already finished the job.

Bob Alberti’s verdict, later, came down to one line:

“That socially killed Gopher.”

CERN Gave Theirs Away

At almost the same moment, CERN made the opposite call. On April 30, 1993, Tim Berners-Lee’s WWW was placed into the public domain. CERN waived every right to it. Take it. Use it. That same year, NCSA’s Mosaic put images directly in the browser window for the first time.

Two institutions, three months apart, gave opposite answers to the same question.

Paul Lindner put it less kindly:

“Who wants text menus when you can look at pictures?”

It Died Without a Sound

The team tried to save Gopher. In 1993, they shipped Gopher+, adding images and metadata, but server admins couldn’t be bothered to upgrade because barely anyone was using Gopher anymore.

Between 1994 and 1995, UMTC hit a budget crisis, and McCahill and Lindner were reassigned to build Web management systems. People left, so development stopped, and nobody ever announced anything from start to finish.

McCahill says he realized it was over while standing on a street. A bus went past with a URL printed on its side:

“That’s when I knew the Web was all about advertising. Gopher was not good for advertising.”

The Primer Charge Was in the RFC

The licensing fee was the trigger, but the real cause was Gopher’s own design spec: RFC 1436. RFC 1436 specifies that every line in a Gopher menu looks like this:

Type  User_Name  <Tab>  Selector  <Tab>  Host  <Tab>  Port  <CR-LF>

The leading character is the type: 0 text, 1 menu, 7 search, 9 binary, I image. The client renders it straight off that character, no guessing, no negotiation. That was the right call in 1993, when every byte you saved on a 14.4k modem was money, was speed.

The field that actually killed it is the third one. Here’s what the RFC says about the selector:

“The selector string should mean nothing to the client software; it should never be modified by the client.”

Flip back a page, and the protocol says it even more directly:

“The user only sees the user-visible name.”

Put the two together, and it’s one sentence: Gopher doesn’t support hyperlinks. The user never sees the selector string, start to finish. The client receives it and isn’t allowed to understand it or change it: take it as-is, hand it back as-is. It’s a password the server made up for itself, and only the server knows what it means. To go anywhere in Gopher, you never worked out the path yourself. You had to wait for the server to write that line into the menu it sent you. Outside the menu, there’s no way through.

This isn’t the client software being lazy. The protocol itself never left an opening. A type-0 item is plain text, and there’s nowhere in the grammar to mark “these characters are a link.” You could, of course, type an address into the body by hand, but that’s no different from a street address printed in a paperback book. The client won’t recognize it as anything special; you have to copy it down yourself and type it into another window. I pulled a real type-0 file off magical.fish and counted the hyperlinks in the body: zero. Because nobody wanted to write one. Because it can’t be done.

So in Gopher, you read an article, you hit a person’s name, and there’s no way to point from that sentence to anyone else. To jump anywhere, you back out a level first and check whether the menu the server built for you happens to have that item on it.

On the Web, by contrast, <a href> can sit behind any character in the body, pointing at any machine on Earth, with no one's permission required in advance.

In 1998 Rohit Khare wrote Who Killed Gopher?, listing a lineup of suspects: the licensing fee, Mosaic, hyperlinks, advertising. Tim Berners-Lee, in 1999’s Weaving the Web, pinned it on just one: the licensing fee. Both readings hold. They’re just answering different questions. TBL is describing what happened that particular winter. Khare’s longer list is describing something else: even without that letter, this design was never going to get far.

There’s some irony in how it ends. In 2005, the IETF published RFC 4266, formally defining gopher:// as a URI scheme. Gopher survived, in the end, as a branch of the URL.

A modern Gopher menu (2020, rendered by a Gophernicus server), nearly identical to the 1991 interface. Screenshot: Emil Engler, CC0, via Wikimedia Commons.

Menus and Permissions

In September 2000, the University of Minnesota open-sourced Gopher under the GPL. Seven years too late.

Before I closed the terminal, I looked at that menu one more time. It’s tidier than any website I opened today, and it loads fast enough to be a joke. If that letter had never gone out in February 1993, you’d probably still be online today. It’s just that every time you wanted to go somewhere else, you’d have to back out a level first and check whether their menu had that item on it.

Links won. Links don’t have to ask anyone for permission.