Draft Document

This article is in this final draft stages before release. This document should not be considered final until approved.


Commands are how players (also referred to as users) on the SpinDizzy MUCK interact with the system, other players, and themselves. This page serves as the starting point for learning more about commands and programs on the SpinDizzy MUCK.

Table of contents:


A command is how a player invokes a program -- a sequence of pre-programmed instructions -- to cause a specific result. In the case of the SpinDizzy MUCK, commands are how players interact with the system, other users, and their own objects. Speaking, looking at an object, and moving from room to room all rely on invocation of a command. Commands may accept information as an input (parameters), and will almost always return results (output) of the operations they are programmed to execute. Commands on a MUCK system are usually defined by three different attributes: to whom they are accessible (Scope), where they come from (Source), and how the underlying command programs run (Persistence).


Scope describes how accessible a given command is to players on the SpinDizzy MUCK. Commands are either public or private.

Public Commands

Public commands are accessible to all users of the SpinDizzy MUCK system. A player can be present at any location and utilize any publically-accessible command, with the exception of locally overriden commands in private spaces.

Private Commands

Private commands are accessible to only a small subset of individuals. Access to these commands may be restricted through a variety of means, including locking, location, obfuscation, or other means.


Source describes where a software program package originated from. Software program packages are either built-in or global.

Built-in Commands

Main Article: List of SpinDizzy MUCK System Built-In and Local Commands

Built-in commands are programs which are generally available to users of the MUCK without having to extend the existing software or include additional software program packages. This is similar to how some computer operating systems provide certain command-line and graphical-user applications and functionality by default, such as a text editor or a web browser.

For example, in the Windows operating system, Notepad (notepad.exe), Task Manager (taskmgr.exe), and Command Prompt (cmd.exe) are basic programs included as part of the default install. In Linux and BSD distributions, and many flavors of UNIX (such as HPUX or AIX), your system distribution is likely to be installed with Stream Editor (sed), and a command line processor such as Korn Shell (ksh) or Bourne Again Shell (bash).

Lists of the built-in commands for the SpinDizzy MUCK are available in the MUCK system by using the Help (help) command.

Global Commands

Main Article: List of SpinDizzy MUCK Global Commands

Global Commands are software product packages installed in addition to the built-in software packages. These software programs often provide additional functionality to users, such as efficiently listing all of the properties of an object (lsprop), or having a text-user interface to edit all player attributes at once (editplayer). Sometimes these software programs extend or provide better functionality compared to already installed programs, such as the Find Everyone program (find) providing additional information and being inclusive of player puppets (also known as zombie objects) compared to the built-in Who Is Here program (who).

For example, in the Windows operating system, Notepad (notepad.exe) doesn't provide all of the functionality that Notepad++, a third party software text editor designed for programming, may provide. Additionally, if a Windows user needs a full office productivity suite to write letters, they may install Microsoft Office 2016 or LibreOffice to provide that additional functionality. In Linux and BSD distributions, and many flavors of UNIX, this would be akin to installing additional packages, such as a database (PostgreSQL), a window manager (XFCE), or a development environment (Eclipse).

Lists of the global commands for the SpinDizzy MUCK are available by using the Global Listing Utility and including the List parameter (globals #list)


Persistence describes how a command's program runs on the MUCK system. Commands are either non-persistent or persistent.

Non-Persistent Commands

Non-Persistent commands automatically quit once they complete their task. Non-persistent commands take input parameters, process them, and provide an immediate result, usually without starting other progams. Because non-persistent commands execute immediately and then quit, they do not usually require special input and output control. The majority of commands on a MUCK are classified as non-persistent.

Examples of non-persistent programs are the System Uptime (uptime) command and the Object Archive (@archive) command.

Persistent Commands

Persistent commands take player input and continue running until the player stops the program. These programs generally receive the player's input to the exclusion of everything else. These commands usually provide menu-driven or shortcut-driven text-user interfaces (TUIs) for interacting with the software. As a result, players often have a restricted set of general commands they can use while running programs associated with these commands. Persistent commands often provide specialized functions requiring additional control of input and output.

Examples of persistent programs are the Player Hammer (editplayer) and the List Editor (lsedit).


Commands have two distinct parts: the keyword and the parameters.

The Keyword

The keyword is the part of the command which instructs the MUCK system to execute a specific program. On a MUCK system, a link is created between a keyword and a software package program, which is how the system knows that a specific keyword should call a particular program in a software package. Command keywords can generally have alphanumeric characters (a-z, A-Z, 0-9), and some special characters (@,.,?,>,<,/,\,+,-,_ just to name a few). Command keywords generally do not contain whitespace. Command keywords also generally support shortening of their words to conserve keystrokes. For example, Teleport (@teleport) can be used as either @teleport, @tel, or @t.

Examples of command keywords are drop, @name, and +read.


Command parameters, or arguments, are additional pieces of information which help a program perform actions according to a player's specifications. Some commands do not take any parameters, such as the System Uptime (uptime) command, while other commands are entirely dependent on parameters in order to do anything, such as the Create Object (@create) command. Additionally, some commands also have optional parameters, which are not required to be defined when calling the command.

Examples of command parameters are an object's name (@create) a player's old password and new password (@password), a room name or database reference (@teleport), and a player's name (whisper)

Command Lifecycle

Commands have three distinct phases in which they operate: composition, execution, and return. There are slight difference between the lifecycles for persistent commands and non-persistent commands.


During the composition phase, a user determines the command they wish to invoke, gathers any needed parameter information, and composes the keyword and arguments into a command string by following the guidelines for the command's syntax. In general, the composition phase is the same for both persistent and non-persistent commands.

For example, a player named Violet wishes to send a private message to another player named Edgar. Edgar is not located in the same room as Violet, so she cannot whisper them. Instead, she must use the Page User command, which has the following usage guideline when using it to speak to far away players:

     page < player | zombie >=< message | action >

Following the guideline would result in Violet composing a command string that resembles the following:

     page Edgar=Meow


During the execution phase, a user submits a command to the SpinDizzy MUCK system to be executed. The command keyword calls the underlying linked program assigned to it, then processes and forwards the parameters along to the underlying program. Players submit commands to the system by pressing the "Enter" or "Return" key on their keyboard. Some simple programs may generate a single result which is returned at the end of the execution phase. Other programs may generate and return many results as part of their execution before the final results are prepared and returned.

If you are running a non-persistent command, the program called by the command performs its processing using the player-submitted parameters, generates any results based on that data, and returns them.

If you are running a persistent command, the program called by the command will continue to perform it's processing, usually by processing whatever commands the player wants and providing the results the player wants, until the player quits the program.


After the program has finished working with the parameters given, it returns its output to the player. The output will either indicate a successful execution of a command or will indicate an error.

Successful execution will often return a message to the player indicating that the parameters provided were processed and give the player the information or result of that processing. Sometimes, the command may simply return information; the implication is that the information returned is indicative of success. Very seldom will a MUCK command return nothing to indicate that requested commands have been executed.

Error messages are sometimes returned instead of success. If a command returns an error, it will often give the reason for the error. Most errors are caused by inappropriate, badly-formatted, or insufficient parameters, referencing nonexistent objects or players, or typos. Seldom are errors caused by bugs.

If you are running a non-persistent command, you would receive any final results from processing the parameters and the program called by the command would terminate.

If you are running a persistent command, the underlying program would terminate and there would likely be no additional significant data returned other than to indicate that the progam has quit.

For example, if Violet used the command string she wrote in the Composition section, the output for Violet to page Edgar would be the following:

        You page, "Meow" to Edgar.

The output would look like the following to Edgar:

        Violet pages, "Meow" to you.

Extending the Command Sets

Main Article: MUCK System Programming

The global command library can be extended in a number of ways: players may compose programs for general use using either Multi-User Forth (MUF), an advanced programming language often requiring additional, elevated privileges, or Message Parsing Interpreter (MPI), a lightweight, userspace-oriented, LISP-like evaluative language; system Wizards may download and implement global-scope programs for use by all individuals on the MUCK system.

Commands aren't only intended for general use by all members of the SpinDizzy MUCK. Individual players may compose programs solely for their own personal use. Specialized or personal programs can do things like control a puppet (zombie), lock and unlock exits to private rooms, change descriptions, and much more. Personal programs are an important tool for creating rich room descriptions, interactive areas, and simple utility functions that improve the player's and the player's friends' quality of experience.

Unless an individual has extensive programming experience in Forth or Multi-User Forth, they usually begin by writing applications and scriptlets in Message Parsing Interpreter (MPI). Message Parsing Interpreter (MPI) is an accessible, entry-level language for getting started with MUCK system programming, especially for individuals who have never programmed before. Most players begin by writing simple MPI programs for their own spaces. Some eventually choose to write more sophisticated programs for general use.


Main Article: SpinDizzy MUCK Building

Main Article: SpinDizzy MUCK System Programming

Some software program packages have restrictions on who may run them. For example, some commands, like the Database Dump (@dump), Player Create (@pcreate), and Reset Environment (@armageddon) commands may only be executed by individuals bearing a Wizard bit. Likewise, some programs can only be utilized by individuals designated as Builders or MUCKers.

Common Commands

Main Article: List of SpinDizzy MUCK System Built-In and Local Commands

Main Article: List of SpinDizzy MUCK Global Commands

Below is a table of some of the more common commands used on the SpinDizzy MUCK system. These commands represent a small sample of what players use to interact with others, manage their objects, and perform other system tasks.

Examples below presume that a player named Player is interacting with Alkani, another player.

Common Commands






Look Around

 look [ <object> | NULL ] 

 look Alkani 


Page User

 page <player | zombie> [ =<message> ]

 page Alkani 

 page Alkani=Hey!


Act Something

 pose <action> 

 pose jumps up in the air! 


 :jumps up in the air! 


Say Something

 say <phrase> 

 say May I have some more? 


 "May I have some more?


Show Occupied Public Rooms




Whisper User

 whisper <player | zombie> 

 whisper Alkani=That was something, huh? 


See Who's With You





Getting Help

While some commands in the SpinDizzy MUCK system may not require access to detailed instructions, other commands may need require further instruction or guidance. There are a variety of sources of help for the built-in and global commands.

For Built-in Commands

Built-in commands leverage the Help System (help) built in to the SpinDizzy MUCK system software. You can get program help by category (help category) or alphabetically (help alpha) or by a specific command.

For example, to get help for the Drop command (drop), you would use "help drop".

For Global Commands

Global commands have a separate help system that varies by implementation. Because global program packages are implemented by disparate groups of people, there is no single interface for getting help. The most common interfaces for retrieving help for a global command are by either looking at the command (look <command>) or by submitting an argument to display the help (<command> #help).

If a player cannot find help for a global command by using 'look <command>' or '<command> #help', players may leverage the Global Listing Utility (globals), to determine the specific method for getting help with a global program. A player should retrieve the list of global software programs (globals #list or globals #page), and view the entry for the global command you want help with. The method for calling help for that program will be in the third column titled "Help Info" (globals #list) or in the "Help" row (globals <command>).

For example, if a player wanted help for the Throw Object command (throw), they could first view the global program package entry for it (globals throw), then use the entry in the Help row to display the documentation (throw #help)

General Assistance

If you have a question that can't be answered by the documentation included with the commands, consider asking a local Builder or MUCKer for assistance. You can also ask local Help Staff or Wizards. Wizards and Help Staff are generally knowledgeable on most topics related to the SpinDizzy MUCK and can usually be of assistance.

See Also

List of SpinDizzy MUCK System Built-In and Local Commands

List of SpinDizzy MUCK Global Commands


No References Available

Additional Reading

A Player's First Day

SpinDizzy MUCK Building

SpinDizzy MUCK System Programming

External Links

No External Links Available


Commands (last edited 2017-11-02 09:14:09 by Alkani)