<!--
	Title: The History of Zork -- First in a Series
	Author: Tim Anderson
	Source: The New Zork Times, v4(1)
	Date: Winter 1985
	Transcription by Steve Derby
-->

In the beginning, back in the 1960's, DEC (Digital Equipment Corporation)
created the PDP-10, a medium-sized computer. The "10", as it was
called, became popular at many research installations, and a great
deal of software was written for it, some of which is still far in advance
of systems on more modern machines. At MIT's Artificial Intelligence
Lab, an operating system called ITS (Incompatible Timesharing
System) was written for the 10. ITS was designed to make software
development easy. The designers of the system assumed that it
would have a small, knowledgeable, friendly group of users, so they did
not include any security features.

Around 1970, the ARPAnet was invented. ARPAnet made it possible
for researchers all over the country (indeed, all over the world) to
communicate with each other, and to use each other's machines. In those
halcyon days, access was unrestricted; you could get on from any
machine connected to the net, or by knowing an appropriate phone
number. Budding hackers from around the country soon discovered
that this made a wonderful playground. They also discovered that
there were some computers at MIT with some neat stuff on them and no
security — anyone who could connect to the machines could log in.

Also around 1970, a language called MUDDLE (later renamed
MDL) was developed as a successor to LISP. It never succeeded in fully
replacing LISP, but it developed a loyal user community of its own,
primarily at MIT's Project MAC (now called the Laboratory for
Computer Science) and especially in the Dynamic Modelling Group (later
the Programming Technology Division). The Dynamic Modelling
Group (DM), in addition to its other accomplishments, was responsible
for some famous games. The first of these was a multi-player graphics
game called *Maze*, in which players wandered around a maze shooting
each other. Each user's screen showed the view of the maze that his
or her computerized alter-ego saw, updated in real time. Dave Lebling
was among those chiefly responsible (to blame?) for the existence of the
game.

The next game of note was *Trivia* (who says research labs aren't ahead
of their time?), an ongoing "can you top this" contest for the truly crazed.
*Trivia*, unlike *Maze*, could be played by network users, and achieved wide
popularity on the ARPAnet. Marc Blank wrote the second version, and
I maintained/hacked it; it was actually a legitimate test of a database
system the group used for a research project.

In early 1977, *Adventure* swept the ARPAnet. Willie Crowther was the
original author, but Don Woods greatly expanded the game and
unleashed it on an unsuspecting network. When *Adventure* arrived at
MIT, the reaction was typical: after everybody spent a lot of time doing
nothing but solving the game (it's estimated that *Adventure* set the
entire computer industry back two weeks), the true lunatics began to
think about how they could do it better. *Adventure* was written in
FORTRAN, after all, so it couldn't be very smart. It accepted only two-word
commands, it was obviously hard to change, and the problems
were sometimes not everything one could desire. (I was present when
Bruce Daniels, one of the DM'ers, figured out how to get the last point
in *Adventure* by examining the game with a machine-language debugger.
There was no other way to do it.)

By late May, *Adventure* had been solved, and various DM'ers were
looking for ways to have fun. Marc Blank was enjoying a respite from
medical school; I had just finished my master's degree; Bruce Daniels
was getting bored with his Ph.D. topic; and Dave Lebling was heartily
sick of Morse code. Dave wrote (in MUDDLE) a command parser that
was almost as smart as *Adventure*'s; Marc and I, who were both in the
habit of hacking all night, took advantage of this to write a prototype
four-room game. It has long since vanished. There was a band, a
bandbox, a peanut room (the band was outside the door, playing "Hail
to the Chief"), and a "chamber filled with deadlines." Dave played and
tested the game, saw that it was pretty awful, and left to spend two
weeks basking in the sun.

Marc, Bruce, and I sat down to write a real game. We began by
drawing some maps, inventing some problems, and arguing a lot about
how to make things work. Bruce still had some thoughts of graduating,
thus preferring design to implementation, so Marc and I spent the rest of
Dave's vacation in the terminal room implementing the first version of
*Zork*. *Zork*, by the way, was never really named. "Zork" was a nonsense
word floating around; it was usually a verb, as in "zork the fweep," and
may have been derived from "zorch." ("Zorch" is another
nonsense word implying total destruction.) We tended to name our
programs with the word "zork" until they were ready to be installed on the
system.

By the time Dave got back, there was a (more-or-less) working game.
It probably wasn't as big as *Adventure*, and was certainly less than half
the size of the final version, but it had the thief, the cyclops, the troll,
the reservoir and dam, the house, part of the forest, the glacier, the
maze, and a bunch of other stuff. The problems were not as interesting as
those that came later: it took time for people to learn how to write good
problems, and the early parsers wouldn't support complicated
solutions anyway. What we had done right was all in the "substratum."
There was a well-defined (and easily-changed) theory governing
interactions among objects, verbs, and rooms. It was easy to drop in
new parsers, which happened frequently, since everyone and his
uncle tried his hand at writing a parser (Marc finally became
obsessed with it, and wrote the last 40 or 50 of them himself). And it
was easy to add new rooms, objects, and creatures (I won't discuss the
difficulty of adding new concepts yet).

*Zork*, like *Adventure*, survived only because it was played by people
outside the small community that developed it. In the case of
*Adventure*, this was possible because it was written in FORTRAN and
could run on practically any machine. *Zork* was written in MUDDLE,
which ran on only some PDP-10s. Its user community was the
group of "net randoms" that infested the MIT systems; remember that we
had no security at all at this time. DM had developed an active
community largely because of *Trivia*. Since *Trivia* was pretty dead
by the time *Zork* came along, there weren't many other things for the
randoms to do, so they hung around waiting for the next game. Early
players of *Zork* ranged from John McCarthy, the inventor of LISP (we
actually have a copy of the connectivity matrix that McCarthy used
instead of a map), to twelve-year-olds from Northern Virginia. No one
ever officially announced Zork: people would log in to DM, see that
someone was running a program named *Zork*, and get interested. They
would then "snoop" on the console of the person running *Zork*, and see
that it was an *Adventure*-like game. From there, it only took a little more
effort to find out how to start it up. For a long time, the magic incantation
was ":MARC;ZORK"; people who had never heard of ITS, DM, or
PDP-10s somehow heard that if they got to something called "host 70" on
the ARPAnet, logged in, and typed the magic word, they could play a
game.

<figure class="float-right-half">
<img src="/public/img/articles/nzt-the-history-of-zork-part-1/unused-zork-puzzle-map.jpg" alt="A map of an unused puzzle idea for the original Zork">
<figcaption><em>Marc Blank’s sketch for an underwater problem designed for, but never put
into, the original </em>Zork<em>. The treasures would have been pearls and a trunk of
jewels.</em></figcaption>
</figure>

Although *Zork* in June 1977 was infinitely more primitive than, say,
*Zork I*, it still had pretty much the same flavor. The Flathead family
was represented, in the person of Lord Dimwit Flathead the Excessive,
ruler of the Great Underground Empire; and the official currency
was the zorkmid. Bruce was responsible for the purplish prose where
these were first mentioned.

Many of the details of the GUE were whimsical (if not silly), but we
weren't completely immune to reality. In those days, if one
wandered around in the dark area of the dungeon, one fell into a bottomless
pit. Many users pointed out that a bottomless pit in an attic should be
noticeable from the ground floor of the house. Dave came up with the
notion of grues, and he wrote their description. From the beginning (or
almost the beginning, anyway), the living room had a copy of "US News
& Dungeon Report," describing recent changes in the game. All
changes were credited to some group of implementers, but not necessarily
to those actually responsible: one of the issues describe Bruce working
for weeks to fill in all the bottomless pits in the dungeon, thus forcing
packs of grues to roam around.

The first major addition to the game, done in June 1977, was the
river section, designed and implemented by Marc. It survives largely
unchanged in *Zork I*, but illustrates very well the problems of building
reality. There were minor problems of consistency — some parts of the
river were sunlit (and even reachable from outside), but others were dark.
The major problem resulted from the new concept Marc introduced:
vehicles. In the original game, there were rooms, objects, and a player;
the player always existed in some room. Vehicles were objects that
became, in effect, mobile rooms. This required changes in the (always
delicate) interactions among verbs, objects, and rooms (we had to have
some way of making "walk" do something reasonable when the
player was in the boat). In addition, ever-resourceful Zorkers tried to use
the boat anywhere they thought they could. The code for the boat itself
was not designed to function outside the river section, but nothing kept the
player from carrying the deflated boat to the reservoir and trying to
sail across. Eventually the boat was allowed in the reservoir, but the
general problem always remained: anything that changes the world
you're modelling changes practically everything in the world you're
modelling.

Although *Zork* was only a month old, it could already surprise its
authors. The boat, due to the details of its implementation, turned into a
"bag of holding": players could put practically anything into it and carry
it around, even if the weight of the contents far exceeded what a player
was allowed to carry. The boat was two separate objects: the "inflated
boat" object contained the objects, but the player carried the "deflated
boat" object around. We knew nothing about this: someone finally
reported it to us as a bug. As far as I know, the bug is still there.

[Coming up in the next issue: [*Zork* Assumes an Alias](/library/nzt-the-history-of-zork-part-2).]
