MUD Dictionary

A networked, usually text-driven shared world where multiple users interact with one another and a persistent or semi-persistent environment.

Examplelook · north · say Hello

Context: Historically Multi-User Dungeon. Dimension, Domain, and Dialogue are later variants.

An umbrella term for MUDs, MOOs, MUSHes, MUCKs, MUXes, and related multi-user text worlds.

Example“This behavior appears on several MU* servers.”

Context: Use it as a category, not as an engine name.

Mudding means participating in a MUD; a mudder is someone who does so.

Example“I was mudding last night.”

The shared virtual environment and, by extension, the running service and community.

Example“Which world do you play?”

Context: Social worlds may prefer world, community, MOO, or MUSH over game.

Either the human participant or the database entity representing that participant, depending on context.

Examplepage Bob=Hello

Context: Never assume the word means only the human or only the stored object.

The in-world identity through which a human participates.

ExampleAlice is the player; Arwen is her character.

Context: Some engines combine player and character; others separate accounts from characters.

Login identity that may control one or more characters when the engine separates authentication from in-world identity.

ExampleOne account selects two different characters.

Context: Common in modern frameworks; many classic engines instead log directly into a Player object.

A location that normally contains characters or objects and connects to other locations.

Examplelook · north

Context: MUX uses a Room type; MOO commonly uses objects descended from a room class; Diku stores room records; Evennia uses a Room typeclass.

A traversable connection, command, or link leading from one location toward another.

Examplenorth · out · enter portal

Context: The user-facing idea is portable; the underlying object and parser behavior are not.

A generic thing represented in a world database or object system.

Examplelook sword · examine #123

Context: In MOO it is the fundamental entity. In MUSH/MUX, Thing is one specific object type while object may refer to every database type.

Usually a carryable or manipulable object, distinguished from a player, room, or exit.

Example@create Brass Key

Context: In MUSH/MUX a Player or Room is an object but is not a Thing.

Objects contained inside a room, container, or character; inventory usually means what a character carries.

Exampleinventory · get key · drop key

Context: The containment implementation differs even when the commands look familiar.

Text entered by a participant to request an action.

Examplelook statue · say hello · get sword

Context: Commands may resolve to hardcoded behavior, exits, MOO verbs, MUSH $-commands, or framework Command objects.

The machinery that turns typed text into a command, target, arguments, and behavior.

Exampleget sword → resolve sword → execute get

Context: This is one of the least portable areas between engines.

Observe the current room, an object, or another participant.

Examplelook · look painting

Context: The syntax is widespread; visibility rules are game-specific.

Inspect an object at a technical level, often revealing ownership, flags, attributes, links, or code details.

Exampleexamine #123

Context: Usually a builder or debugging command, not a synonym for look.

Send speech to people in the same local location.

Examplesay Hello everyone.

Context: Some engines support quotation-mark shorthand.

Produce an action-style third-person message rather than quoted speech.

Example:waves. → “Aria waves.”

Context: MUSHes commonly say pose; traditional MUDs often say emote.

Related forms of private or non-local communication.

Examplepage Bob=Are you free?

Context: Combat MUDs often use tell, MUSH/MUX use page, and whisper may mean local private speech.

A named multi-user communication stream independent of the current room.

Example+pub Hello

Context: Comsys, channel aliases, and game-written packages have different syntax and behavior.

A command or display listing connected users, often with status information.

ExampleWHO

Context: A softcoded +who may be different from hardcoded WHO.

Software used to connect to a MUD, often adding saved worlds, logging, triggers, macros, or mapping.

ExampleConnect to host.example:4000.

Context: Modern clients may use Telnet, TLS, WebSocket, or a browser interface.

A participant authorized to create or modify world content.

Example@dig Observatory

Context: Builder may be a permission bit, staff rank, informal role, or all three.

A privileged administrator or programmer with capabilities unavailable to ordinary users.

ExampleA wizard repairs a broken world object.

Context: MOO, MUSH, MUCK, and LP wizard roles have materially different authority.

An ordinary non-administrative player, contrasted with wizard or immortal staff.

ExampleMortals cannot inspect that object.

Context: Especially common in game-oriented MUDs.

Database reference number, conventionally written with #, used by TinyMUD-family engines.

Exampleexamine #123

Context: Penn and TinyMUX may recycle dbrefs. Classic LambdaMOO object numbers are not reused.

Named data attached to an object; on MUSH-family servers it may also contain executable softcode or command patterns.

Example&DESC statue=A weathered statue.

Context: The closest MOO analogue is property, but MOO keeps executable behavior in verbs.

A named value associated with an object, especially in MOO and MUCK.

ExampleMOO: object.foo · MUCK: _reg/name

Context: Inheritance, permissions, hierarchy, and executable behavior differ by family.

A named action or behavior; in MOO, specifically a program attached to an object.

Example#123:open()

Context: Outside MOO the word may only describe natural-language parser behavior.

A boolean state attached to an object that changes behavior or permissions.

Example@set box=DARK

Context: Flag names and security effects vary substantially by engine and game.

An access-control condition governing whether an actor may perform an operation involving an object.

Example@lock door=...

Context: Syntax and evaluation differ among MUSH, MUX, MUCK, and modern frameworks.

The object or player recorded as responsible for an object and normally granted authority over it.

Exampleexamine object → owner information

Context: Ownership is not identical to control.

Having permission to modify or act through an object, whether through ownership, privilege, flags, powers, or locks.

ExampleA wizard controls an object owned by another player.

Context: An administrator may control an object without being its ordinary owner.

A relationship through which an object receives data or behavior from an ancestor, prototype, or class.

Example@parent child=prototype

Context: Exactly what is inherited differs by engine.

Code written and stored inside the running world rather than compiled into the native server.

Example&hello me=$hello:@pemit %#=Hi!

Context: MOO usually says MOO code or verbs; MUCK uses MUF and MPI.

The native server implementation beneath in-world programming.

ExampleA softcode sqrt() function calls native server code.

Context: Other families may call this server code, driver, runtime, or engine.

A currently executing or suspended unit of work, formalized by the MOO execution model.

ExampleA command invokes a verb and creates a task.

Context: Related to queues, but not an exact synonym.

A mechanism for scheduling deferred commands or actions, especially in MUSH-family servers.

Example@wait 5=@emit Done

Context: Queue internals and preserved execution context vary by engine.

An object through which a player can remotely perceive or cause actions.

Example@force test=:squeaks.

Context: A MUSH-family design, not the generic word for every NPC.

An automated participant or object, sometimes controlled by an external program.

ExampleAn external client logs in and responds automatically.

Context: ROBOT may be a formal legacy flag; bot is broader modern usage.

In Character versus Out of Character communication or behavior.

ExampleOOC: My connection is unstable.

Context: A social convention whose channels and formatting vary by game.

A computer-controlled character; mobile is the formal Diku-family world-data term and mob its common shortening.

Examplekill goblin

Context: Social worlds more often say NPC, puppet, bot, or programmed character.

A world-building grouping of rooms and content.

ExampleThe castle area contains twenty rooms.

Context: Often overlaps with Diku zone in casual speech, but server definitions vary.

A grouping or control abstraction whose exact meaning depends strongly on engine family.

ExampleThe castle is in zone 30.

Context: A Diku reset zone is not the same thing as a TinyMUX zone relationship.

Restoration of configured world state, commonly respawning mobiles and items.

ExampleThe zone reset loads guards after earlier copies disappear.

Context: Characteristic of Diku-family worlds and not generally a social-world primitive.

A new or inexperienced participant.

Example“Could someone show this newbie where to train?”

Context: Newbie is usually neutral or friendly; newb and noob can be dismissive.

An alternate character or identity controlled by the same player.

Example“My healer is an alt.”

Context: Rules about disclosure and interaction between alts vary by world.

Connected but inactive; AFK means away from keyboard.

ExampleWHO shows Aria idle for 12 minutes.

Context: Servers calculate and expose idle time differently.

Still represented in the world after the network connection has been lost.

ExampleThe character stopped responding and went linkdead.

Context: Some games preserve the character briefly; others disconnect immediately.

Noticeable delay between input and response caused by network or server latency.

Example“The game lagged during combat.”

Context: Not every delayed response is network lag; queued or intensive code can also pause output.

Player killing or player-versus-player conflict.

ExampleThis area permits PvP.

Context: Consent, safety, and mechanical rules are world-specific.

Player-versus-environment play against game-controlled challenges.

ExampleThe dungeon is designed for group PvE.

Context: A broad online-game term rather than a specific MUD architecture.

Roleplay: portraying a character within a shared fiction.

ExampleThe tavern is an RP scene.

Context: Communities range from optional roleplay to fully in-character play.

Excessive repeated output that overwhelms conversation or useful game text.

ExampleA looping trigger floods the room with spam.

Context: May be accidental code output or deliberate disruption.

Output made to appear as though it came from another source or from ordinary room text.

Example@emit can produce unattributed text.

Context: Some MUSH-family servers provide NOSPOOF tools to reveal the source.

Force a connected user off the server or restart the server, depending on context.

ExampleAn administrator boots an abusive connection.

Context: The two senses should be clear from context.

A restriction preventing connections from a network address, host, or site pattern.

ExampleA repeated abuser receives a siteban.

Context: Scope and evasion resistance depend on the server.

MUD, Object Oriented: a programmable text-world family deriving from Stephen White’s MOO and especially LambdaMOO.

Example“This world runs a LambdaMOO-derived server.”

The fundamental database entity in MOO; rooms, players, exits, and ordinary items are all objects.

Example#17

Context: Objects combine structural attributes, properties, and verbs.

A numeric MOO object identity displayed as #n.

Example#17

Context: Classic LambdaMOO never reuses an object number after recycling.

A named slot on an object holding a MOO value, with ownership, permissions, and inheritance behavior.

Examplethis.description

Context: Executable behavior belongs in verbs, not properties.

A server-recognized structural value such as name, owner, location, contents, programmer, wizard, or permission bits.

Exampleobject.owner · object.location

Context: Distinct from database-defined properties inherited through the hierarchy.

A named MOO program attached to an object, used as a command handler or method called by other code.

Exampleobject:verb(args)

Context: A MOO verb is not simply a grammatical verb.

Each MOO verb has an owner plus r, w, x, and d permission bits governing visibility, editing, execution, and debugging.

ExampleInspect verb_info() before editing.

Context: Wizard-owned verbs require particular care because code runs with verb-owner authority.

The object-inheritance relationship through which descendants receive properties and verbs.

Examplecreate(parent)

Context: This is a fuller object hierarchy than MUSH attribute inheritance.

Permission bit allowing non-owners to create children of a parent or reparent objects beneath it.

ExampleA generic class is made fertile for builders.

Context: A strongly MOO-specific permission.

Privilege on a player-representing object that permits use of MOO programming facilities.

ExampleA player receives programmer status before editing verbs.

Context: Not equivalent to coder as an informal community role.

High-privilege status on a player object granting special server operations.

ExampleA wizard-owned administrative verb.

Context: Do not assume it matches MUSH or LP wizard authority.

Reciprocal containment properties: location is the containing object; contents lists contained objects.

Examplemove(player, room)

Context: The server move() operation maintains their consistency.

Direct-object, indirect-object, and preposition specifications used by command verbs.

Exampleput book in box → book is dobj; box is iobj.

Context: MOO parser terminology, not generic MUSH syntax.

One execution of a MOO program, created by commands, server events, forks, suspension, or input waits.

ExampleA command invokes a verb and creates a task.

Context: Compare with a MUSH queue entry, but do not call them identical.

An operation-count budget preventing a MOO task from monopolizing the server.

ExampleA runaway loop exhausts its ticks and aborts.

Context: MUSH-family evaluators have different limits and terminology.

MOO language mechanism scheduling another task, optionally after a delay.

Examplefork (5) … endfork

Context: Compare with @wait and queued actions on MUSH-family servers.

Pause the current MOO task so it can resume later.

Examplesuspend(2);

Context: Suspends execution rather than changing object state.

Irrevocably destroy a MOO object.

Examplerecycle(#123)

Context: Classic LambdaMOO does not make that object number available for reuse.

A state in which an inherited MOO property uses its inherited/default value instead of an independent local value.

Exampleclear_property(object, "color")

Context: There is no direct one-word MUSH equivalent.

A MOO database supplying high-level classes, commands, and facilities beyond the bare server.

ExampleStart a server using LambdaCore.

Context: Conceptually resembles an LP mudlib, but the architecture differs.

The canonical core database associated with LambdaMOO, providing building, movement, messaging, and programming facilities.

Example@dig north,n to "The North Pole"

Context: The LambdaMOO server and LambdaCore database are separate components.

A core convention limiting how many objects an owner may create.

ExampleA builder with exhausted quota cannot create another object.

Context: Not every contemporary MOO uses the same quota policy.

A TinyMUD-descended family of social and roleplaying text worlds with user building and attribute-based programming.

ExamplePennMUSH, TinyMUSH, TinyMUX, and RhostMUSH.

Context: Commonly expanded as Multi-User Shared Hallucination(s), but historical expansions vary.

A #number identifying an object in a MUSH database.

Example#3

Context: Recycling makes long-lived bare dbrefs unsafe; Penn provides objids.

PennMUSH identifier combining a dbref with creation identity so recycled references can be detected.

Example#123:creation-time

Context: Penn-specific behavior should not be assumed on every MUSH-family server.

Named string-valued data attached to an object and used for descriptions, configuration, and code.

Example&favorite_color me=blue

Context: The same attribute system can hold data or executable patterns.

In-world language composed from commands, functions, substitutions, and attribute evaluation.

Example&cmd_test Foo=$test:@emit Hello

Context: Function names and evaluator rules differ among PennMUSH, TinyMUSH, TinyMUX, and RhostMUSH.

A user-defined command stored in an attribute as a $pattern followed by an action.

Example&cmd_wave me=$wave *:@emit ...

Context: Shared convention does not guarantee evaluator portability.

An attribute pattern triggered by matching emitted text rather than directly typed command text.

Example&HEAR box=^Hello:@emit Heard you.

Context: Scope and monitor requirements vary by implementation.

The object that caused a command or code path to happen; in PennMUSH %# is its dbref.

Example%# identifies the player who triggered a $-command.

Context: The enactor need not be the executor.

The object actually running the current command or code; represented by %! in PennMUSH.

ExampleCode stored on Foo runs with Foo as executor.

Context: The executor and enactor may be different objects.

The object that caused an attribute or function to be evaluated; represented by %@ in PennMUSH.

Exampleufun(Bar/fun_test) records the invoking object as caller.

Context: A third execution-context role, distinct from executor.

A sequence of MUSH commands carried out from an attribute or triggered behavior.

Example@emit One; @emit Two

Context: Separators and evaluation semantics vary by server and configuration.

Scheduler for commands, waits, and deferred softcode actions.

Example@wait 5=@emit Done

Context: Queue internals are not common law across Penn, MUX, TinyMUSH, and Rhost.

Temporary softcode register carrying values through evaluation and action contexts.

Example%q0 · %q<name>

Context: Named-register extensions and preservation rules vary.

A mechanism for coordinating queued softcode until an event releases waiting work.

Example@wait semaphore=command

Context: Implementation details are engine-specific.

An object whose attributes and command patterns may be inherited by another object.

Example@parent #200=#100

Context: Attribute-oriented inheritance differs from MOO’s property-and-verb hierarchy.

Boolean object state such as DARK, SAFE, HAVEN, WIZARD, or PUPPET.

Example@set box=SAFE

Context: Available flags and their effects vary by server and game.

A predicate governing use, entry, page reception, teleportation, or another operation.

Example@lock/page me=...

Context: Examples must be scoped to a server and version.

A flag and design pattern making a Thing a remote listening or acting extension of its owner.

Example@set test=PUPPET

Context: Behavior and restrictions vary by server and game.

A historical player-like entity or flag convention intended for automated or externally controlled use.

ExampleAn external program controls the connection.

Context: Bot is the broader modern term.

An anti-spoofing facility that identifies the source of output resembling ordinary room text.

ExampleEnable NOSPOOF while debugging suspicious emits.

Context: Output format and exact guarantees depend on server and version.

@emit produces unwrapped text; @pemit sends output to a selected target.

Example@pemit Bob=Hello

Context: Switches and permission rules diverge across implementations.

A softcoded command intended to be available across much or all of a game.

ExampleA +who command available from every room.

Context: May use master-room objects, zones, packages, or server configuration.

A MUSH-family server descending through TinyMUSH and continuing with its own modern architecture.

ExampleEngine: TinyMUX

Context: Version scope matters when discussing evaluator, database, queue, and JIT behavior.

Five database states/types are documented: Player, Thing, Exit, Room, and Garbage, with intrinsic ownership, containment, parent, zone, flags, powers, and attributes.

ExampleRooms connect through Exits and contain Players or Things.

Context: The four usable world types are strongly TinyMUD-like compared with MOO’s uniform model.

A #number identifying a database object.

Example#1234

Context: Dbrefs can be recycled after destruction, unlike classic MOO object numbers.

The process of translating player text into an internal object reference using a defined precedence.

Exampleget sword · look here · get #123

Context: Matching behavior can affect softcode portability from PennMUSH.

Commands and functions supplied by hardcode, composed and stored in object attributes.

Example&sqrt.cmd MyCode=$sqrt *:@pemit %#=...

Context: A shared MUSH-family concept implemented by the MUX evaluator.

The native C++ server layer beneath softcode.

Examplesoftcode sqrt() → native fun_sqrt()

Context: Comparable to server code, not to an LP mudlib.

Attribute beginning with a $ match pattern, followed by a colon and action.

Example&sqrt.cmd MyCode=$sqrt *:@pemit %#=...

Context: Penn-like syntax does not guarantee exact evaluator compatibility.

The object responsible for causing the current softcoded action.

Example@pemit %#=Done.

Context: Closely parallels PennMUSH and is shared family terminology.

A captured wildcard argument made available to TinyMUX softcode.

Examplesqrt 2 → %0 is 2

Context: Related substitutions exist in PennMUSH but should be portability-tested.

Square brackets request evaluation of a softcode function or expression in the current context.

Example[sqrt(%0)]

Context: Parser and evaluator differences often surface here.

A queued command sequence carrying execution context such as executor, enactor, caller, arguments, and registers.

Example@emit one; @emit two

Context: Do not assume Penn queue entries preserve identical context.

The scheduler for delayed and deferred TinyMUX softcode.

Example@wait 5=@emit Done

Context: The queue architecture has diverged from related MUSH servers.

An optional intrinsic relationship used for grouping, control, or zone-based command matching.

ExampleAssociate locations with a zone object.

Context: This is not a Diku reset zone.

A set of granted capabilities distinct from ordinary boolean flags.

ExampleGrant an administrative capability independently of a flag.

Context: Other MUSH-family servers divide privilege differently.

A TinyMUD-descended family oriented toward user construction and programmable social or roleplaying worlds.

Example@dig · @open · @program

Context: Common acronym expansions are retrospective; historical accounts treat MUCK as a play on MUD.

The principal continuing MUCK server tradition, with current MUCK, MUF, and MPI documentation.

ExampleA world runs Fuzzball 7.x.

Multi-User Forth: the stack-oriented programming language associated with TinyMUCK descendants.

Example@program test.muf

Context: Compare with MOO verbs and MUSH softcode as concepts, not compatible syntax.

A database object containing executable MUF code.

Example@program · @edit

Context: A program is an object type; MOO instead attaches verbs to objects.

Message Parsing Interpreter: a lighter embedded expression facility used alongside MUF.

ExampleAn expression embedded in an object description.

Context: Related in purpose to MUSH evaluation, but syntactically unrelated.

A hierarchical organization of MUCK properties.

Example_reg/myroom

Context: Distinct from MOO property inheritance and MUSH attributes.

The engine tradition Lars Pensjö began in 1989 around an LPC virtual machine and programmable mudlib.

ExampleGenesis was the first public world using the original LP driver.

Context: Architecturally closer to runtime plus game library than TinyMUD database softcode.

The native server and virtual-machine layer that hosts an LPMud and executes LPC.

ExampleFluffOS, LDMud, or DGD.

Context: An engine/runtime layer, not a MUSH hardcoded command.

The LPC programs and configuration defining rooms, NPCs, items, handlers, commands, and game behavior.

Example/room/... and NPC source files

Context: Comparable to a MOO core database only as a loose architectural analogy.

A C-like object-oriented language executed by LP-family drivers to implement a mudlib.

ExampleAn LPC file defines a room or NPC.

Context: Traditionally filesystem and source-file oriented rather than attribute softcode.

An external function supplied by the LP driver and callable from LPC.

Examplethis_player() · this_object() · write()

Context: Available efuns and signatures depend on the driver.

The influential C codebase whose world model shaped many descendants and their building vocabulary.

ExampleArea files contain rooms, mobiles, objects, shops, and zones.

Context: Publicly opened in February 1991 after development began in 1990.

A major DikuMUD descendant whose builder manual clearly documents classic Diku-family world files.

Examplelib/world/wld · mob · obj · shp · zon

An NPC definition in Diku-family world data.

ExampleA guard mobile is loaded into room 3001.

Context: Mob later spread into wider gaming usage and often narrowed to hostile NPC.

A modular world unit grouping rooms and content while specifying reset behavior.

ExampleZone 30 contains the castle and its reset commands.

Context: Not the same abstraction as a TinyMUX zone.

Virtual number used by Circle/Diku builders to identify rooms, mobiles, objects, and zones.

ExampleRoom 3001 · mobile 3001

Context: Different entity types can have the same numeric vnum in separate namespaces.

A zone command or event restoring configured NPC, object, equipment, or door state.

ExampleLoad one guard if none remains.

Context: Often called a repop by players and builders.

A Python text-world framework whose defaults provide Object, Room, Exit, and Character typeclasses that projects can extend.

ExampleCustomize typeclasses in a game directory.

Context: A framework rather than a stock RPG.

A persistent typeclassed in-game entity; default Characters, Rooms, and Exits are specialized Objects.

ExampleA chair, monster, room, or character can be an Object.

Context: Evennia commonly separates Accounts from Characters.

An Evennia Python class whose instances are connected to persistent database entities and game behavior.

Exampleclass Room(DefaultRoom): ...

Context: Compare with MOO parents or MUSH prototypes only conceptually.

An intelligent collection of commands made available to an account, object, exit, or context and merged by priority and rules.

ExampleAttach build commands through a CmdSet.

Context: Strongly contrasts with MUSH $-commands stored in attributes.

A one-way Object with a destination that contributes a movement command named for the exit.

ExampleAn Exit named north points to another Room.

Context: Shows how a familiar player term can have a framework-specific implementation.