MOO

MOO - “MUD, Object-Oriented” - is both a family of text-based multi-user virtual-world servers and the programming language that lives inside them. Every room, exit, player and object in a MOO is an entry in a persistent object database; every command a player types is parsed by the server and dispatched to a verb, a small program written in MOO code and attached to an object; and any player the wizards trust can write new verbs, from inside the world, while hundreds of other people are connected. That combination - a dynamically typed, C-flavoured language with prototype-style inheritance, first-class error values and cooperative multitasking, sitting on top of a live, self-modifying database - was worked out in 1990 by Stephen White and Pavel Curtis, and it is still what runs LambdaMOO, Sindome and the Rust-based mooR in 2026.

The encyclopedia’s master list files MOO as a dormant object-oriented “virtual world” language of 1990. The year is right (White’s first server appeared in May 1990 and Curtis’s LambdaMOO on 30 October 1990). The status needs qualifying: the original LambdaMOO server went two decades without a tarball and is arguably dormant, but its lineage is not - ToastStunt had commits on 21 August 2026, LambdaMOO 1.9.0alpha appeared in September 2025, and mooR reached 1.0 in June 2026.

History and origins

Stephen White and AlphaMOO (1990)

MOO’s parent is Jim Aspnes’s TinyMUD (1989), the Carnegie Mellon server that removed combat, points and treasure from the MUD formula and made building the point of the game. In the winter of 1990 Stephen White, a computer-science student at the University of Waterloo who went by “ghond” (and “Ghondahrl”), extended TinyMUD 1.5.2 into TinyMUCK, the first of the programmable “social” MUD servers. Using TinyMUCK as his template, he then wrote a new server in which the programmability was not a bolt-on but the design: objects with properties and methods, single inheritance, and a real expression language. He called it MOO. Wikipedia gives 2 May 1990 as its release date and AlphaMOO as the world it ran; the source files of the LambdaMOO server still carry the line “Portions of this code were written by Stephen White, aka ghond.”

White went on to write CoolMUD (c. 1992), a similar but more distributed design that never gained MOO’s audience; Greg Hudson’s ColdMUD (c. 1993) and its ColdC language, later maintained by Brandon Gillespie as Genesis, are generally described as descending from MOO by way of CoolMUD.

Pavel Curtis and LambdaMOO (1990-1996)

Pavel Curtis was a programming-language researcher at Xerox PARC (he was there from 1983 to 1996, working on language design, environments and collaboration systems). He took White’s “basic design, language, and code”, fixed bugs, rewrote parts, added programming facilities and wrote documentation until, in his words, he had “a truly separate entity”. He named it LambdaMOO after his character Lambda - “and because it’s a key word in some of the other non-mud research that I do” - and opened it on 30 October 1990. The server’s ChangeLog.txt, which the current maintainer still ships, begins with “Version 1.0.0, 5 February 1991 – First public release”, and the world was announced on Usenet at about the same time. “Hundreds of players flocked to it.”

The server evolved quickly under Curtis. Version 1.4.0 (22 August 1991) “completely rewrote the MOO-code parser, unparser, and interpreter using a new program representation based on vectors of bytecodes instead of abstract syntax trees”, which let the interpreter run iteratively and save the whole state of a task - the prerequisite for the read() and suspend() functions added in the same release. Outbound network connections followed in 1.5.0 (November 1991), and version 1.7.0 (23 October 1992) brought reference-counted strings and lists, hashed property lookup, subrange assignment, the f (fertile) bit and a choice of networking implementations. The 1.8.0 cycle (alpha 29 November 1995, beta 7 February 1996, release 9 March 1996) is where the language reached its mature form: try/except/finally, the backquote catch expression, floating-point numbers (from patches by H. Peter Anvin, whom Curtis credits at length in the changelog), scattering assignment, multiple listening points and binary I/O. The copyright in the source is Xerox Corporation’s, 1992-1996, under a short permissive notice: “Use and copying of this software and preparation of derivative works based upon this software are permitted.”

Curtis was as interested in what people did with the thing as in the language. His “Mudding: Social Phenomena in Text-Based Virtual Realities” (DIAC ‘92, May 1992; PARC report CSL-92-4) is the first widely read study of MOO society. With David Nichols he built Jupiter, a PARC “network place” that grafted audio, video and shared windows onto a MOO world (“MUDs Grow Up”, 1993; “The Jupiter Audio/Video Architecture”, ACM Multimedia ‘95), and AstroVR for astronomers. After leaving PARC he co-founded PlaceWare, the web-conferencing company Microsoft bought in 2003.

Governance: the New Direction, Mr. Bungle and the ballot box

LambdaMOO is at least as famous for its politics as for its code. In a message dated 9 December 1992 Curtis, as the arch-wizard Haakon, posted “LambdaMOO Takes A New Direction” (LTAND): the wizards would henceforth refrain from making social decisions and act only as technicians. In March 1993 a player called Mr. Bungle used a “voodoo doll” object - a MOO program that attributes actions to other characters - to force sexually violent text on two other players in the living room. The community had no mechanism for dealing with it; after a mass meeting a wizard “toaded” (deleted) the character on his own authority, and that summer LambdaMOO introduced a petition-and-ballot system so that players could legislate. Julian Dibbell’s account, “A Rape in Cyberspace” (Village Voice, 21 December 1993; later part of My Tiny Life, 1998), became one of the most cited texts about online community, and Lawrence Lessig has said reading it drew him into the field. In a message dated 16 May 1996 Haakon posted “LambdaMOO Takes Another Direction”, conceding that “the line between ’technical’ and ‘social’ is not a clear one, and never can be”, and the wizards resumed responsibility. All of this happened in a world whose furniture, commands and voting machinery were written in MOO by its inhabitants.

The educational MOOs (1993-2003)

Because a MOO is programmable from inside, it was an obvious platform for online classrooms and research communities long before the web could host them. Amy Bruckman opened MediaMOO at the MIT Media Lab on 20 January 1993 as a professional space for media researchers (over 1,000 members by 1996), then built MOOSE Crossing (opened to children in October 1995, closed 2007), for which she designed MOOSE, a child-friendly language layered over MOO, and the MacMOOSE client - the subject of her 1997 MIT thesis. Jeanne McWhorter’s Diversity University (1993) was the first MOO dedicated to teaching; BioMOO (1993, Gustavo Glusman and Jaime Prilusky at the Weizmann Institute) served biologists; JaysHouseMOO (1992) produced JHCore and the first Gopher server written in MOO; BayMOO (October 1993) hosted Aerosmith’s “Cyberspace Tour” in December 1994; LinguaMOO (1995, Cynthia Haynes and Jan Rune Holmevik) spawned enCore, a core database reportedly built on the February 1997 LambdaCore with the web-based enCore Xpress interface, released in versions from 1997 to about 2003 and adopted by many humanities MOOs.

Maintainers, forks and the long pause (1997-2025)

Erik Ostrom took over the server at 1.8.0p6 (the version documented by the March 1997 Programmer’s Manual) and handed it to Ben Jackson and Jay Carlson, who released 1.8.1 on 10 January 2000 (announced 11 January) with “no significant user-visible changes” and moved the project to SourceForge. That was the last official release for over twenty years. Development continued in branches - Jackson’s WAIF datatype (August 2002), Rob Leslie’s XML parser (June 2008), a 1.8.3 tag (20 June 2008) that was never packaged, Kenny Root’s bitwise operators (February 2012) - and in the Codepoint fork, a 64-bit Unicode server by H. Peter Anvin, James Deikun, Rob Leslie and Kenny Root (final version 14 May 2011). The code running LambdaMOO itself since 2010 identifies as “1.8.3+47”; Roger Crew (“wrog”), who became maintainer around 2021, retroactively numbered it 1.8.4 (23 April 2010) and on 29 September 2025 published 1.9.0alpha, which reconciles the 1.8.4 and Codepoint lines and brings the branch features onto one autoconf-based build.

Meanwhile the forks did what the trunk could not. Todd Sundsted’s Stunt began as a multiple-inheritance patch against 1.8.1 (SourceForge patch #49, 2 April 2011) and became a full server with anonymous garbage-collected objects, a map datatype, JSON and HTTP parsing, modern hashing, task-local storage, verb calls on primitive values and a Ruby test suite (Release 8, March 2012; Release 9, January 2013; Release 10 a C++ rewrite). lisdude’s ToastStunt, forked from Stunt in 2017 for the space MOO Miriani, added SQLite, PCRE regular expressions, background threads, 64-bit integers, Argon2id, TLS, IPv6, profiling and much else, and has had steady releases from 2.0 (2017) to 2.7.3 (20 June 2025). Rob Leslie’s EtaMOO (Haskell, 2016) and Ryan Daum’s mooR (Rust, 1.0.0 on 5 June 2026) are complete reimplementations that read LambdaMOO databases.

Design and features

Everything is an object in the database

A MOO database is a numbered collection of objects - #0 is the system object, #1 the root class in LambdaCore, #-1 “nothing”. Each object has a parent (single inheritance in the classic server), children, an owner, and eight built-in properties: name, owner, location, contents, programmer, wizard, and the flags r (readable), w (writable) and f (fertile - may have children). Beyond those, objects carry arbitrary named properties (values, inherited from parents unless overridden) and verbs (code). The whole database is periodically checkpointed to disk, so the world - and every program in it - survives restarts. There is no separate source tree: the program is the database.

Names of the form $foo are shorthand for #0.foo, so a core defines $player, $room, $string_utils, $list_utils and so on as properties of the system object; the community calls this “corifying” an object.

Verbs and the command parser

A verb has a name (which may be a pattern like l*ook), a permissions string (r, w, x, d) and an argument specification of the form direct-object preposition indirect-object, e.g. this none none, any with any or none none none. When a player types put ball in box, the server tokenises the line, finds objects named “ball” and “box” in the player’s location and inventory, and searches the player, the room, the direct object and the indirect object (in that order) for a verb put whose specification matches. The verb then runs with the variables player, this, caller, verb, args, argstr, dobj, dobjstr, prep, iobj and iobjstr already bound. Verbs whose spec is this none this are not commands but methods, called from code as object:verb(args).

@verb rover:pet this none none
@program rover:pet
"Usage: pet rover -- pets Rover.";
player:tell("You pet ", this.name, ".");
this.location:announce_all_but({player}, player.name, " pets ", this.name, ".");
.

(@verb and @program are themselves verbs on $prog in LambdaCore; only .program was a server built-in, and the 1.7.0 changelog already calls it obsolete.)

Values and syntax

The classic server has six value types: integers (32-bit until 1.9.0 and Codepoint; 64-bit in ToastStunt and mooR), floats (since 1.8.0, IEEE doubles with NaN and infinity forbidden - they raise E_FLOAT), strings, object numbers, errors and lists. Errors are ordinary values - E_TYPE, E_PERM, E_PROPNF, E_VERBNF, E_RANGE, E_DIV, E_ARGS, E_QUOTA, E_INVARG and so on - which is why a property fetch can be written to return a default instead of throwing. Lists are written {1, "two", #3}, spliced with @, and indexed from 1 with $ for the last element; strings index the same way. Syntax is C-like but statement-terminated by keywords rather than braces:

count = 0;
for thing in (this.contents)
  if (is_player(thing) && !thing.wizard)
    count = count + 1;
  endif
endfor
for i in [1..count]
  player:tell(tostr(i), " of ", count);
endfor

Stunt added a map type (["key" -> value]), anonymous objects, multiple parents (parents(), chparents()), and verb calls on primitives; ToastStunt carries and extends Ben Jackson’s 2002 WAIFs (lightweight objects that inherit from a parent but have no object number); mooR adds booleans, symbols, lambdas, list comprehensions, begin/end lexical scopes and flyweights.

Errors, tasks and the tick budget

Version 1.8.0 gave MOO a full exception system - try ... except e (E_DIV) ... finally ... endtry - and the terser backquote form `this.color ! E_PROPNF => "grey"', which evaluates an expression and substitutes a value if one of the listed errors is raised. Verbs run with the permissions of their owner, not the caller, and the d (debug) bit decides whether an uncaught error aborts the task with a traceback or is returned as a value.

Every command becomes a task. The server is single-threaded and cooperative: a task gets a budget of ticks (30,000 for command tasks, 15,000 for forked or suspended ones in 1.8.x) and seconds, and is killed if it exceeds either, so no player’s infinite loop can freeze the world. Code yields explicitly with suspend(n), schedules future work with fork (60) ... endfork, and waits for input with read(). ToastStunt’s background-thread extension (2017) and mooR’s transactional, multithreaded runtime (2026) are both attempts to keep this programming model while escaping the single core.

Security model

Because arbitrary players write code that runs on the server, the permission system is not optional. Objects, properties and verbs have owners and r/w/x bits; only wizards can change ownership or set the wizard and programmer flags; set_task_perms() and caller_perms() let trusted core code run on behalf of a caller; quotas limit how many objects a player may build. Most of the practical security of a MOO is in the core database rather than the server, which is one reason LambdaCore, JHCore and enCore matter as much as the server version.

Evolution

The language itself has been remarkably stable: a verb written for LambdaMOO 1.8.0 in 1996 will run unchanged on ToastStunt 2.7.3 or mooR 1.0.2, and both projects treat the ability to load a 1.8.x database as a hard requirement. Almost all the evolution has been in what surrounds the language - data types, networking, threading, Unicode, persistence - rather than in its syntax.

Current relevance

In August 2026 MOO is a small but unmistakably living ecosystem:

• Servers are maintained. ToastStunt’s docs/ChangeLog.md lists 2.7.3 (20 June 2025) and an in-progress 2.8.0, and the repository had commits on 21 August 2026. mooR released 1.0.0 on 5 June 2026 and 1.0.2 on 22 July 2026 (Debian packages and Docker images for x86_64 and aarch64). Roger Crew’s LambdaMOO 1.9.0alpha (29 September 2025) is the first new version of the original server since 2000.
• Worlds are running. LambdaMOO itself answers at lambda.moo.mud.org:8888 on the 1.8.4 executable it has run for some fifteen years; Miriani and ChatMUD run ToastStunt; Sindome (online since 1997) reportedly does as well.
• Tooling exists. lisdude.com collects the servers, cores (LambdaCore, JHCore, enCore, Minimal.db), the Stunt-era Programmer’s Manual, a VS Code syntax package and the WiredWizard Docker images; the sevenecks/lambda-moo-programming repository maintains an updated manual in Markdown.
• The community is tiny. There is no package registry, no conference, no commercial user, and the educational MOOs that were its biggest constituency in the 1990s were largely abandoned once the web could do the same job with pictures.

“Dormant” is defensible for the original LambdaMOO server between 2000 and 2025; it is not an accurate description of the language.

Why it matters

MOO was the first widely used system in which a large, untrusted, geographically scattered population programmed a shared, persistent, live world from inside it - years before wikis, Second Life or the phrase “user-generated content”. Its answers to the problems that creates (verbs running with their owner’s permissions, per-task tick budgets, first-class error values, a checkpointed object database as the only source of truth) were worked out in 1990-1996 and still hold up.

It is also the substrate of an unusual amount of scholarship. Curtis’s “Mudding”, Dibbell’s “A Rape in Cyberspace”, Mnookin’s “Virtual(ly) Law”, Bruckman’s MediaMOO and MOOSE Crossing work and a shelf of composition-studies literature on LinguaMOO and enCore are all, at bottom, about what happens when a community can rewrite the rules of its own world in code. And the lineage runs on: the fact that a 1996 verb executes unchanged on a 2026 Rust server is a rare kind of longevity for a language that never had a standard, a vendor or a budget.

Further reading

• LambdaMOO Programmer’s Manual (1.8.0p6, March 1997) - Pavel Curtis’s reference for the classic language and server
• wrog/lambdamoo on GitHub - the original server, with ChangeLog.txt from 1.0.0 (1991) to 1.9.0alpha (2025)
• LambdaMOO - connection details for the original world and the MOO-Cows FAQ
• ToastStunt and lisdude’s MOO Resources - the most active classic-lineage server, manuals, cores and Docker images
• mooR - Ryan Daum’s Rust reimplementation (AGPL-3.0; GitHub mirror of the primary repository at codeberg.org/timbran/moor)
• Stunt - Todd Sundsted’s extensions (multiple inheritance, maps, JSON, HTTP)
• Pavel Curtis, “Mudding: Social Phenomena in Text-Based Virtual Realities” (1992)
• Amy Bruckman, “MOOSE Crossing: Construction, Community, and Learning in a Networked Virtual World for Kids” (MIT, 1997)
• Wikipedia: MOO and LambdaMOO