RFC 1436, “The Internet Gopher Protocol,” was published by the Network Working Group in March 1993. Its authors were six engineers from the University of Minnesota’s Computer and Information Services division: Farhad Anklesaria, Mark McCahill, Paul Lindner, David Johnson, Daniel Torrey, and Bob Alberti. The document is sixteen pages. Its abstract describes Gopher as a distributed document search and retrieval protocol. Its design philosophy section includes one line about the design target: “the simple nature of the protocol stems from the need to implement servers and clients for the slow, smaller desktop computers (1 MB Macs and DOS machines), quickly, and efficiently.”
That same month, at GopherCon ‘93, the University of Minnesota’s administrative director of the Gopher project, Shih Pau Yen, announced that for-profit organizations using the Minnesota Gopher software for internal commercial purposes would need to negotiate a licensing arrangement and pay a fee. Yen is not one of RFC 1436’s six authors.
The two documents came from the same building, the same month, from overlapping sets of people. Neither mentions the other.
The Specification
RFC 1436 is a confident document. Its protocol is simple: a client opens a TCP connection to port 70, sends a selector string (possibly empty), and the server responds with a tab-delimited directory listing or the requested document, then closes the connection. A directory entry is a one-character type code, a user-visible name, a selector, a hostname, and a port number — all separated by tabs, terminated by a period on its own line.
In practice, navigating a Gopher server meant moving through a hierarchy of menus. You connected to a server — the original, the “Mother Gopher,” ran on a machine in a closet in Shepherd Labs on the Minnesota campus — and saw a list of items. Each item was a pointer to a document or another menu, somewhere on the network. You selected one, the client opened a connection to whichever server held it, and the server returned what you asked for. The whole thing ran on the assumption that simplicity, not power, was the virtue. Intelligence lives in the server; clients can be minimal.
The design philosophy section explains the one-megabyte figure: in April 1991, when the Minnesota team first released Gopher, a one-megabyte Mac was representative of the machines people were actually using. The protocol was designed to serve those people. New features would be added “as new document types” rather than by modifying the core protocol. RFC 1436 is the formal specification of a design that had been running for two years by the time it was published. Mosaic had been released in January 1993, two months earlier, and its defining feature — inline images, photographs embedded in the document itself — was precisely what RFC 1436 had designed around.
What RFC 1436 does not mention, because it is a protocol specification and not a policy document: how the software implementing the protocol would be licensed, or by whom.
The Announcement, and What Came Before It
The GopherCon ‘93 announcement did not arrive unannounced. In comp.infosystems.gopher, a thread titled “gopher licensing” had been running since at least February 25, 1993 — before RFC 1436 was published — with participants including JQ Johnson (Director of Network Services at the University of Oregon), Paul Lindner (one of the RFC authors, posting as “Minnesota Gophermaster”), John Franks of Northwestern University, and Edward Vielmetti of Msen Inc. Mark McCahill, another RFC author, posted a detailed clarification of the Minnesota position in that thread on February 26.
The licensing concerns were already on the wire before the formal specification was published.
At the conference in March, Yen made the policy formal. What is known about the announcement comes primarily from the team’s written defense, posted on March 11, 1993, from Yen’s email address at boombox.micro.umn.edu and signed by “the Gopher development team.” It laid out four tiers:
Educational and nonprofit organizations offering free public access faced “no change. No fees.” Commercial organizations using the software internally would negotiate a license on a sliding scale by company size. Those selling information through Gopher would pay “some small fraction of your sales,” negotiated individually. Those whose Gopher server provided genuine public benefit could petition the university for an exemption.
The team’s defense included this: “We are not out to make big money here. We are simply facing the realities of our environment.”
The original GopherCon ‘93 announcement — the exact words Yen used, to what audience, in what form — has not been located. What exists in the public record is the team’s own account of what was announced, posted in response to the community’s response. The text of the announcement is being narrated by the people who made it.
The Community’s Response
The February thread and the March defense thread together show what the community was worried about, and what they kept asking for.
The worry was not, primarily, about the fee amounts. It was about vagueness, and about what vagueness required in practice.
JQ Johnson, Director of Network Services at the University of Oregon, was the first to put the community’s working interpretation on record: Minnesota was claiming rights to “the name ‘gopher’…to the specification documents, and to code based on the various U Minn gopher implementations, but not to code implementing the protocol but developed only using the specifications.” That reading was broader than what the team had said — Lindner had been explicit that the protocol documents would always be free — but Johnson was careful to flag it as his personal interpretation, not a formal statement from Minnesota. No written policy existed. He was steering his institution’s Gopher practice on the basis of informal forum posts, and he said so. The gap between what Johnson understood Minnesota to be claiming and what Minnesota said it was claiming is the piece’s argument in miniature.
Edward Vielmetti, running Gopher services at Msen Inc. in Ann Arbor, had a practical response to the uncertainty: propose that the community organize an IETF session to develop neutral Gopher specifications, and that commercial developers build independent server implementations that didn’t touch the Minnesota codebase at all. Not a complaint but a routing decision — treat the licensing situation as damage and route around it.
McCahill’s answer on this last point was clear and repeated across both threads: Minnesota owned the software the Minnesota team wrote. Independent implementations — and there were already several by early 1993 — faced no restrictions. The protocol documents would remain free. He put it directly in the February thread: “We own the stuff we wrote… you own the stuff you wrote.”
Arnold Bloemer, posting on March 17, cited Linux as a counterexample to the team’s UNIX-licensing analogy. Linux was about eighteen months old, had chosen the GPL, and was not charging for use. Mark Garrett at the University of New England, Australia, agreed: anything short of GNU-style licensing might cause developers to walk.
The team’s position was technically precise. There is a protocol, which is an agreement about how machines communicate, and there is an implementation, which is code that runs the protocol. These are different things. Minnesota’s implementation is what the Minnesota team wrote. The protocol is not being licensed; the University isn’t claiming to own the idea of menu-based hierarchical document retrieval. Independent implementations remain entirely free. Educational use remains entirely free.
The community kept hearing something different. A protocol whose only widely-deployed implementation requires a commercial license is, in practice, not freely usable by commercial organizations — regardless of what the protocol specification says. The distinction the team was making was legally precise and practically thin.
Bob Alberti, in a 2016 interview with MinnPost, gave his assessment of the community’s reaction: “That socially killed Gopher.” The “that” in Alberti’s sentence is ambiguous in the article — it could refer to the announcement, the reaction to it, or the whole situation. But the word he used was “socially.” The protocol didn’t stop working. The implementation didn’t change. What changed was the community’s disposition toward it.
Whether the fees were ever collected is not in the public record available here. The gap was between what the team said and what the community heard, and that gap is documented regardless of what happened to the fee schedule.
Bob Alberti’s “Internet Gopher: Bridge to the Web” was not accessible at time of drafting — the only archived copy found returned a 403. This piece has read what can be read.