MUSH

MUSH is the scripting language - usually called MUSHcode or softcode - of the MUSH family of text-based virtual worlds. It was born in 1990 when Larry Foard rewrote Jim Aspnes’s TinyMUD so that players could not merely build rooms and objects but program them, storing snippets of code in named attributes on database objects and having the server evaluate those snippets in response to typed commands, overheard speech and timers. The result is an odd and durable little language: every value is a string, every program is an attribute, functions nest inside square brackets and evaluate Lisp-style from the inside out, and the “compiler” is a game server that has been continuously running somebody’s imaginary world since the first Bush administration.

MUSH was never a single implementation. The name originally “didn’t stand for anything” - it was a play on the Tiny- naming fashion of 1990 - and its authors later decided it meant “Multi-User Shared Hallucination”. The code forked almost immediately: MicroMUSH and its TinyMUSE descendants, PernMUSH and its PennMUSH descendant, the TinyMUSH 2.0 rewrite and its TinyMUSH 2.2, TinyMUX and TinyMUSH 3 offspring, and RhostMUSH. Each server family speaks a slightly different dialect, but as the PennMUSH FAQ puts it, someone fluent in one can code for another with only a little effort. The language is therefore best understood the way this page treats it: as a common core - attributes, substitutions, $-commands, @switch, u() and the queue - carried by four still-maintained open-source servers.

History and origins

TinyMUD and TestMUD (1989-1990)

Jim Aspnes announced TinyMUD to a few friends on 19 August 1989 from Carnegie Mellon, on port 4201 - his office number. Unlike the combat-oriented MUDs before it, TinyMUD “emphasizes world creation over competition”: any player could @dig rooms, @create objects and @open exits, and set a handful of fixed message attributes such as @desc, @succ and @fail. TinyMUD’s own database was retired on 29 April 1990, but by then a whole generation of Tiny- servers had sprung from its C source: TinyMUCK, TinyHELL, TinyTIM and the experiments that became MOO.

Among those experiments was a “TestMUD”, which Lauren Burka’s MUDline places in May 1990 and describes as a place “for the development of new MUD features, such as allowing players to recycle unwanted objects and save database space”; it “eventually mutates into the early versions of TinyMUSH”. Lydia Leong’s MUSH Manual, the standard reference of the era, dates the code to “spring of 1990, or so”.

Larry Foard’s TinyMUSH (1990)

The person behind the rewrite was Larry (Lawrence) Foard, known online as “leet”. TinyTIM’s official history records that in August 1990 Foard “decides that the generic MUD code could use major expansion to allow such things as carrying players, pages that contain messages, and the ability of objects to ’listen’ to other players and objects and react. He completely hacks over the code and creates a new variant, MUSH.” The PennMUSH README summarises the programming side more precisely: “vanilla” TinyMUSH “added the ‘v’ registers and functions to the basic TinyMUD building commands”. Those two additions - general-purpose attribute registers @va through @vz, and functions that could be evaluated inside any string - are the seed of MUSHcode.

The new variant “gains much notoriety in the MUD world”. TinyTIM, then being hounded from machine to machine, was converted to TinyMUSH in late August 1990 partly because the Xenix box it landed on could run MUSH but not TinyMUD; it has been a MUSH ever since and is the oldest one still running. Later that year - summer 1990 by Wikipedia’s account, autumn by the MUDline’s - Jin founded MicroMUSH - a 24th-century space station called Cyberion City - with Foard among its primary programmers. Leong’s manual lists TinyTIM, MicroMUSH and Glenn Crocker’s TinyCWRU as the three early games “based off the original TinyMUSH, which was a heavily modified TinyMUD, done by Lawrence Foard”, and notes that Foard’s “vanilla” code was already “a relic of the past” by 1995. TinyTIM never distributed its heavily modified fork.

PernMUSH, MicroMUSE and the 2.0 rewrite (1991)

In January 1991 fans of Anne McCaffrey’s Dragonriders of Pern opened PernMUSH on MicroMUSH-derived code, and JT Traub (Moonchilde) began distributing that code as PernMUSH 1.x. At about the same time MicroMUSH moved toward MIT, renamed itself MicroMUSE, and its codebase continued as TinyMUSE - a sibling branch that later hosted the first BattleTech games and from which RhostMUSH descends.

Foard’s original had by then “become a messy collection of hacks, and most of them were non-standard”, so in the spring of 1991 Traub, Glenn Crocker and Dave Peterson (Evinar of TinyDungeon) “got together to completely rewrite the MUSH code” as TinyMUSH 2.0. PernMUSH switched to 2.0 in November 1991, and Traub’s final PernMUSH 1.x distribution was 1.15. The 1.x line fragmented into three descendants - Spellbound, SouCon and PennMUSH - of which only the last was publicly distributed and survives.

PennMUSH (1992-)

In January 1992 Lydia Leong (Amberyl), then a student at the University of Pennsylvania, took the abandoned PernMUSH 1.15 code for a game called TinyKrynn, extended it, improved its compatibility with TinyMUSH 2.0 and renamed it PennMUSH “to avoid the confusion that resulted from PernMUSH actually running TinyMUSH 2.0”. Her 1.50 series ran through patchlevel 10 - patchlevel 7 alone introduced the powers system, @function (global functions written in MUSHcode) and the setq()/r() registers; in January 1995 she handed maintenance to Alan Schwartz (Javelin), whose first two releases were named “dune-1” and “dune-2” after DuneMUSH before he and Amberyl “agreed that it was silly to start a whole new numbering scheme” and shipped 1.50pl11 on 5 March 1995.

Schwartz formed a development team with T. Alexander Popiel (Talek) and Ralph Melton; their internal changes were large enough that PennMUSH 1.6.0p0 (10 January 1996) began a new numbering scheme, bringing “a new function parser with improved speed, sanity”, a rewritten chat system and 8.3 filenames “to support the win32 port”. Thorvald Natvig, who replaced Melton in 1997, rewrote the command parser for 1.7.0p0 (31 July 1997), and the 1.7.x series added Perl-compatible regular expressions through the PCRE library (the 1.7.3 change log introduces regedit() “like perl’s s///”). Shawn Wagner (Raevnos) took over as maintainer in July 2006 and, with Greg Millam (Walker), Mike Griffiths, Tim Krajcar and Mike Taylor, produced the 1.8.x line: 1.8.7p0 on 10 August 2018 and 1.8.8p0 on 20 April 2020, which added a built-in HTTP server and replaced the per-object queue with a single command queue. The GitHub repository was still receiving fixes in August 2026.

TinyMUSH 2.2, TinyMUX and the TinyMUSH 3 merger (1994-2011)

TinyMUSH 2.0 releases in 1993-94 “had been, by and large, fairly buggy”, so in the fall of 1994 wizards of several large games began TinyMUSH 2.2 as a stabilised continuation, led by Jean Marie Diaz (Ambar of PernMUSH), Devin Hooker (Tyleet of Two Moons) and Leong. Separately, David Passmore (Lauren of From the Ashes) forked TinyMUSH 2.0.10 patchlevel 6 as TinyMUX 1.0 around 1994-95, borrowing features from TinyMUSE and PennMUSH - the TinyMUX credits acknowledge “TinyMUSH 2.2, and PennMUSH 1.50 for many functions carried over for compatibility” and PennMUSH’s extended @mail as the basis of MUX’s mailer. The resulting rivalry was real enough that the TinyMUSH 3.0 credits thank “everyone who participated in the religious wars between TinyMUSH and TinyMUX, which ultimately spurred our decision to merge them”.

That merger began in the late 1990s, when Leong and Passmore started TinyMUSH 3.0 - in the project’s own words “a derivation/merger of TinyMUSH 2.2.5 and TinyMUX 1.6”; Robby Griffin (Alierak) and Scott Dorr (Myrddin) joined during the beta. The tags preserved in the Historical-TinyMUSH repository show beta 1 in September 1999 and the gamma release on 1 December 2000, after roughly a year of beta testing on games such as From the Ashes, Blood of Amber and Babylon 5: The Last Best Hope. TinyMUSH 3.1 went gamma in June 2004 and 3.2 - “almost all (if not all)” of it Leong’s work - in June 2011. Eddy Beaupre (Tyr), who joined at 3.1, later carried the code to GitHub as TinyMUSH 3.3 (last tag 3.3.0.12, December 2020) and began the TinyMUSH 4 alpha in November 2023, a CMake-based modernisation with an LMDB database backend that reached v4.0.0.530 in January 2026.

Meanwhile TinyMUX went its own way. According to the project’s own HISTORY.md, Stephen Dennis (Brazil) began TinyMUX 2.0 in September 1998 as a Windows NT port of TinyMUX 1.6, first called “Win32MUX” and renamed in March 1999; unlike TinyMUSH 3 it continued the pure TinyMUX line while adding native Windows support. Release cycles then ran roughly yearly - 2.1 through 2.4 in about 2001-2006, then 2.6, 2.7, 2.9 and 2.10 (the last adding 256-colour and truecolour output) between about 2006 and 2012, and 2.12 with PCRE2 - though the project’s HISTORY.md, DISTRIBUTIONS.md and repository tags each give slightly different dates. The 2.13 branch (tagged 2.13.0.0 in March 2021 and still receiving builds, 2.13.0.16 on 7 August 2026) added SQLite storage, a new networking layer and Unicode 16. The 2.14 line, whose first tagged builds date from 20 March 2026 and whose alpha and beta periods the project describes as concluded, deletes the classic character-by-character parser in favour of an AST-based evaluator and JIT compiler and embeds a sandboxed Lua 5.4 engine. Build 2.14.0.11 followed on 7 August 2026.

RhostMUSH

The fourth surviving family, RhostMUSH, descends from TinyMUD by way of TinyMUSE rather than TinyMUSH 2.0, and has long been maintained by the developer known as Ashen-Shugar - who also turns up in the PennMUSH and TinyMUSH change logs as a prolific bug reporter. It describes itself as “a security hardened text-based multiplayer RPG server” with “granular permission systems”, was published as open source (first on Google Code, now as the RhostMUSH/trunk repository on GitHub) and was still receiving commits in August 2026.

Design philosophy

MUSH’s defining idea is that the database is the program. There is no source file: a MUSH is a persistent collection of numbered objects (#0 is the starting room, #1 is God), each with an owner, flags, locks and an open-ended set of named attributes. Code is simply the contents of attributes. The server evaluates attribute text in response to events - a player typing a command that matches a $-pattern, speech that matches a ^-pattern, an object being entered, a @trigger, a @wait timer - and the results are more commands or output. Because attributes are data, they can be examined, @decompiled, @cpattr’d between objects, locked, chowned and inherited; a MUSH programmer edits live code on a running system with the same commands used to describe a teapot.

Leong’s manual frames the language’s ancestry plainly: “The programming language of MUSH is most similar to LISP, in its emphasis on lists and the way functions are evaluated.” Everything is a string, lists are space-separated strings, functions are called as name(arg,arg) and nest to arbitrary depth, and the setq()/r() register functions take their “odd name” from Lisp. Unlike Lisp, however, MUSHcode has no reader: parsing and evaluation are the same textual pass, driven by a small set of magic characters - % for substitutions, [ ] to force evaluation, { } to defer it, ; to separate commands, = and , to separate arguments - and much of the craft of MUSH programming lies in controlling when a piece of text gets evaluated.

The other governing principle is security through ownership. Any player can build and program by default, so the server checks, on every attribute fetch and every triggered action, whether the object doing the work controls the object it is acting on. Attributes can be flagged VISUAL (readable by anyone), NO_COMMAND (never scanned for $-commands) or NO_INHERIT; players’ objects can be marked INHERIT to gain their owner’s powers; and functions such as escape() and secure() exist purely to neutralise text supplied by other players before it is evaluated. The manual devotes a section to “Security problems in programming” for good reason - a MUSH is a multi-user system where every user is, potentially, a programmer of every other user’s objects.

Key features

Objects, attributes and registers

Every object carries standard attributes with @-commands (@desc, @succ, @fail, @listen, @ahear, @aenter) and 26 general registers, @va through @vz, which Foard’s original introduced. Later servers allow arbitrarily named attributes set with &name object=value:

1
2
3
4
5
6
7
8
9

> @create Test
Test created as object #1034
> &purpose Test=Demonstrates attributes; see Amberyl's manual section 6.2
Set.
> @va Test=:explodes.; @destroy me
Set.
> @trigger Test/va
Triggered.
Test explodes.

An attribute holding a list of commands is an action list; @trigger object/attribute queues it for execution.

Substitutions and the stack

Percent substitutions are expanded before a command runs: %N is the enactor’s name, %# its database reference, %! the object executing the code, %va a register, %p/%s/%o pronouns chosen from the player’s @sex. The “stack” is not a stack in the computer-science sense but ten string slots %0-%9 filled by pattern matching; setq(0,value) and %q0 provide scratch registers. Capitalising the substitution capitalises the result:

1
2
3
4
5

> @sex me=female
> say %N is demonstrating %p example.
You say "Amberyl is demonstrating her example."
> say [setq(0,testing for fun)]-- %Q0
You say "-- Testing for fun"

$-commands and ^-listens

User-defined commands are attributes whose contents begin with $pattern:. Wildcards in the pattern bind %0, %1 and so on, and the rest is an action list. The pair below, from Leong’s manual, implements a tiny key-value store on an object - foo x=y stores y in an attribute named rx, and bar x reads it back:

1
2

@va object=$foo *=*:&r%0 me=%1
@vb object=$bar *:@pemit %N=get(me/r%0)

The same mechanism with ^ instead of $ lets a LISTENER object react to text it hears in a room, which is how vehicles, puppets and NPCs are built. PennMUSH later added REGEXP attribute flags so patterns can be Perl-style regular expressions rather than wildcards.

Functions, u() and evaluation control

Functions are evaluated inside square brackets or wherever a server expects a function argument. Besides string, list and math primitives (extract(), words(), match(), first(), rest(), add(), rand()), the key ones are get(), which fetches an attribute as text; get_eval() and u(), which evaluate it; and u(object/attribute, arg, arg), which passes arguments as %0, %1… - the MUSH equivalent of a function call. The difference between them is who counts as the enactor:

1
2
3
4
5

> @va test=Enactor: %# -- Me: %!
> @vb test=$test: @pemit %#=Get_Eval: [get_eval(me/va)]%rU: [u(va)]
> test
Get_Eval: Enactor: #1034 -- Me: #1034
U: Enactor: #3 -- Me: #1034

Conditionals are @switch value=pattern,{action},pattern,{action},default at the command level and switch() at the function level; PennMUSH 1.50 patchlevel 7 raised switch() to 100 arguments that “are not evaluated until needed”. Loops are @dolist list={commands with ##} or the functional iter(list, expression with ##), and filter(), map() and friends followed. The manual’s own before-and-after shows why these mattered - a recursive @trigger loop over a room’s exits became a single line:

1

VA: $name-exits: @dolist [lexits(here)]="[name(##)]

The queue, waits and semaphores

Commands do not run immediately; they go onto a queue that the server drains a few entries per player per cycle, which is how a single-threaded C process serves dozens of players and their objects without any one of them monopolising it. @wait seconds=command delays, @wait object=command blocks on a semaphore until @notify object releases it, @ps shows the queue and @halt clears it. PennMUSH 1.8.8 warned upgraders that with the old object queue gone, an attribute that @triggers itself “will now happen up to several thousand times per second” without an @wait.

Locks, parents and zones

@lock object=key accepts boolean expressions over players, objects, attributes (@lock door=sex:female) and, later, evaluated softcode; indirect locks reference another object’s lock. PennMUSH 1.50 added @parent so objects inherit attributes from a parent, and zones (zfun()) for shared command sets across areas - features TinyMUSH, TinyMUX and RhostMUSH adopted in their own forms.

Evolution

MUSHcode’s history is one of parallel dialects converging under pressure from their users. The 1.x era (1990-91) was Foard’s code and its MicroMUSH and PernMUSH patch sets; TinyMUSH 2.0 (1991) regularised it and made it “highly configurable” with @list options; PennMUSH 1.50 and TinyMUSH 2.2 (1992-95) added parents, zones, attribute flags, iter() and richer list functions and were documented side by side in Leong’s manual, which repeatedly notes where “1.50” and “2.0” differ. TinyMUX (c. 1995) and TinyMUSH 3 (2000) pulled features from each other and from PennMUSH - PennMUSH’s change logs tag borrowed code as [3], [MUX] and [Rhost], and TinyMUX 2.14’s change log lists softcode functions adopted from PennMUSH and RhostMUSH, from bound() to while(). The 1999 TinyMUSH Development FAQ that Wikipedia cites made the goal explicit: “particular interest in ensuring that common MUSHcode features work similarly across servers”.

The servers underneath the language have changed far more than the language itself. PennMUSH gained PCRE regular expressions (around 2000), SQL connectivity, SSL, Unicode and an HTTP server (2020); TinyMUX became a native Windows and Unix server with the 2.0 line begun in 1998 and, in 2026, gained a JIT-compiled evaluator and embedded Lua; TinyMUSH 4 swapped GDBM for LMDB. A $-command written for PernMUSH in 1991 still looks like a $-command today.

Current relevance

MUSH is dormant as a language design - nobody is adding new syntax - but far from dead as a platform. All four major servers are open source and maintained: PennMUSH’s GitHub repository was still merging fixes in August 2026; TinyMUX tagged both 2.13.0.16 and 2.14.0.11 on 7 August 2026, and tinymux.org still presents 2.13 as the current release; TinyMUSH 4 saw commits in May 2026; RhostMUSH’s trunk was pushed to in August 2026. Games such as TinyTIM (1990), Elendor (1991) and MUS*H are still online, and the SharpMUSH project (first commits February 2024) is reimplementing the server in .NET “with a PennMUSH compatibility layer” - a sign that the softcode dialect, not any particular C codebase, is what the community wants to preserve. Community sites such as mushcode.com archive Leong’s manual and decades of shared softcode systems (+finger, +who, bulletin boards, combat systems), and the language is documented in Alan Schwartz’s Guide for PennMUSH Gods and in each server’s built-in help system.

Why it matters

MUSH is one of the earliest examples of a live, multi-user, end-user programming environment: ordinary players, not administrators, extended the world by writing code into the objects around them, and that code ran the moment it was saved. Its attribute-as-program model, string-only typing, $-command pattern matching and queue-based cooperative multitasking were all answers to the question of how to let hundreds of untrusted people program the same running system safely - the same question that spreadsheets, wikis and later scriptable web platforms would face. Alongside its cousins MOO and MUF, which took the object-oriented and Forth-based roads out of TinyMUD in the same year, MUSH shows how a 1990 social game became a laboratory for language design, and why its descendants are still compiling in 2026.

Further reading

• Lydia Leong, MUSH Manual Version 2.008 (22 May 1995), the standard reference for PennMUSH 1.50 and TinyMUSH 2.0/2.2, mirrored at duh.com/discordia/mushman and mushcode.com
• PennMUSH README.md, FAQ.md and CHANGES.* files in the pennmush/pennmush repository - the most complete written history of any MUSH server
• TinyMUSH AUTHORS.md and the TinyMUSH/Historical-TinyMUSH repository (TinyMUX 1.x and TinyMUSH 3.0-3.2 history converted from SourceForge CVS)
• The brazilofmux/tinymux repository (mux/CHANGES.md, mux/docs/HISTORY.md, mux/docs/DISTRIBUTIONS.md) and tinymux.org
• Lauren P. Burka, The MUDline (1995), and the TinyTIM Historical Facts Page at tim.org, for the 1989-91 chronology