zMUD Scripting Language

The zMUD scripting language — later branded zScript — is the automation language embedded in zMUD, the Windows MUD client written by Mike “Zugg” Potter. It is a domain-specific language in the most literal sense: it has no compiler, no standalone interpreter, and no existence outside its host application. You type it into the same input box you use to say north or kill dragon, and that dual purpose shapes everything about its design. For a large slice of the text-gaming world between roughly 1996 and 2008, zScript was the first programming language people ever wrote, learned not from a book but from a guildmate pasting a healing trigger into a chat channel.

History and Origins

zMUD began as a hobby project in 1995. Zugg Software’s own version history dates v1.0 to August 1995, describing it as the first build “released to selected Wolverine beta testers” — Wolverine being the project’s original name before it became Zugg’s MUD Client. It arrived into an ecosystem already shaped by TinTin, Peter Unold’s small C client from 1992 that had established the alias-and-trigger vocabulary of MUD automation on Unix; zMUD brought that model to Windows and wrapped it in dialogs, tabs, and, in 1996, an automatic mapper.

The project turned commercial in 1996, around the 4.x line that introduced the automapper — the point at which, in Zugg Software’s own telling, zMUD moved from hobby to shareware business — and Potter left his management job to work on it full time in September 1997. The version histories from that period read like a diary of weekly releases: 4.51 on 16 March 1997, 4.52 on 23 March, 4.53 on 30 March, and so on through the spring. Much of the scripting language accreted in exactly this way, one user request at a time, which explains both its breadth and its irregularity.

Development of zMUD itself ended with version 7.21, dated 26 September 2005, the last entry in the official version history. Zugg Software rewrote the client in C++ as CMUD, which preserved the language — the vendor’s position was that the vast majority of zMUD scripts would run unchanged — while compiling scripts rather than re-parsing them and adding Lua from CMUD 2.0 onward. When CMUD was announced in 2006, Zugg Software stated that zMUD would not be supported on Windows Vista, though copies reportedly continued to circulate and run for years afterward.

Design Philosophy

zScript’s governing constraint is that the command line is shared with the game. Anything you type is presumed to be a MUD command unless it starts with a special character. This yields the language’s most recognizable trait: every built-in statement is prefixed with #.

#ALIAS dr {drink @container}
#TRIGGER {You are hungry} {eat bread}
#IF (@hp < 300) {quaff health} {kick @target}

The second consequence is a sigil-based namespace. @name refers to a user variable or function; %name refers to a built-in variable or function. Everything else is text destined for the socket.

The third — and the part that trips up newcomers to this day — is the deliberate separation of expansion from evaluation. Expansion means substituting variable references into text; evaluation means computing a result. Zugg’s own documentation draws the distinction precisely: expanding @a/@b where a is 100 and b is 5 produces the string 100/5, while evaluating it produces 20. The language gives you explicit control over which happens: quotation marks suppress expansion, angle brackets force it, and square brackets force evaluation. Commands differ in their default behavior too — #VAR expands its argument once, #MATH evaluates it, and #FUNC delays expansion until call time.

Formally, zMUD parses in four modes — verbatim (send text untouched), parse (expand variables), script (expand, then execute), and trigger-pattern mode (a distinct pattern syntax for matching MUD output). Most of the language’s reputation for subtlety comes from the boundaries between those modes.

Key Features

Underneath, zMUD was reportedly written in Borland Delphi, the Object Pascal environment — a detail that shows through in the client’s dialog-heavy UI and in the fact that the scripting engine was an interpreter re-parsing text on every trigger match, the cost CMUD’s compiled engine was built to eliminate. Zugg Software described the compiled engine as faster, but published no benchmark figures, so the size of the difference is undocumented.

A Worked Example

A modest but representative script — auto-healing, target tracking, and a speedwalk — shows the flavor:

#VAR target {}
#VAR hp {1000}

#ALIAS t {#VAR target %1;#SHOW Target set to @target}
#ALIAS k {kill @target}

#TRIGGER {^You have (%d) hit points} {#VAR hp %1}
#TRIGGER {~*~*~* HP: (%d) ~*~*~*} {#IF (%1 < 250) {quaff heal}}
#TRIGGER {(%w) screams and dies} {#SHOW %1 is down;get all corpse}

#ALIAS tobank {#WALK 3n2ew}

Every line here is doing something the language was explicitly shaped for: reacting to text a server emits, capturing pieces of it, and turning them back into commands — with the human still free to type north at any moment.

Evolution

The language grew in visible strata that map onto the client’s version history:

• 1.x–2.x (1995–96) — aliases, macros, basic triggers: an alias-and-trigger feature set comparable to TinTin’s, brought to Windows.
• 3.x (1996) — the vocabulary expansion: #SUB, #CW, string-list functions, alarm and expression triggers, and a Command Wizard for people who did not want to memorize #-commands.
• 4.x (1996–97) — the automapper and its speedwalk integration, plus the shareware transition that funded everything after it.
• 5.x–6.x (late 1990s–2003) — protocol work as much as language work (MXP, MCCP compression, MSP sound), which gave scripts new material to react to, alongside the 6.1x scripting tooling: syntax highlighting and a line-by-line debugger, acknowledging that people were writing real programs in this thing.
• 7.x (2004–05) — refinement and maintenance through to the final 7.21 release.
• CMUD (from 2006–07) — the same language, compiled, running on later Windows versions, with Lua available from 2.0 for anyone who wanted a general-purpose alternative.

The one piece of zMUD that escaped the client entirely was MXP. Building on ideas from the earlier Pueblo client, Zugg defined an HTML-like markup that MUD servers could emit for clickable commands, hyperlinks, and rich styling. Version 1.0 of the specification is dated 12 March 2003, and Zugg Software published it as an open specification so that any client or server could implement and extend it. It remains supported by MUD codebases and clients that never had anything to do with zMUD.

Current Relevance

zMUD is a Windows-only, discontinued shareware product; Zugg Software’s own press material scoped it to Windows 95, 98, ME, NT4, 2000, and XP, and the company stated it was not supported on Vista. There is no Docker image, no package manager, and no official port to Linux or macOS. Running it today means an old installer on a period-appropriate Windows or a virtual machine — a genuine archaeology exercise.

The language, though, is not quite dead. CMUD carried zScript forward, MUD wikis still host zMUD trigger tutorials, and the migration threads on the Mudlet forums — where players ask how to translate a decade-old zMUD script into Lua — are a steady, ongoing acknowledgment that a great deal of working automation was written in it. What survives most visibly is the shape of the idea: modern MUD clients still organize themselves around aliases, triggers, timers, and variables, because zMUD made that the expected interface.

Why It Matters

zScript matters for two reasons that have little to do with its technical merits.

The first is pedagogical. It was, for an enormous number of people, the on-ramp. A player who wanted their character to drink a healing potion automatically had to learn what a pattern is, what a variable holds, what a conditional does, and why the difference between “the text 100/5” and “the number 20” is not pedantry. They learned it because a game rewarded them for learning it, and many of them kept going. Few languages have converted so many non-programmers so incidentally.

The second is as a case study in the economics and design of embedded languages. zScript was built by one developer, funded by shareware registrations, extended weekly in response to user requests, and constrained throughout by a requirement no general-purpose language faces: it had to share a text box with a video game. Its #-prefixes, its @ and % sigils, its escape tilde, and its careful expansion/evaluation distinction are all direct consequences of that constraint. For a code archaeologist, it is an unusually clean specimen of a language whose entire syntax can be explained by where it had to live.