The AIME project is a mud creation project started by Slate and Marty. The code is being designed to be a flexible mud engine capable of allowing builders to express their creative minds fully. It will provide players a complex world that will be fairly straightforward to get into but allow for increasing complexity as the player progresses.
The AweMUD project aims to create an Open Source server capable of handling fully interactive worlds. Areas, or "Rooms" as they're called in AweMUD, can contain objects that can be fully interacted with: climbing trees, hiding items under benches, looking through windows, and opening secret doors by uttering mystic words, just to name a few possibilities.
Buyasta is a MUD engine which provides a simple-to-use framework for constructing MUDs with the Python programming language. The core library implements only the bare functionality required for every multi-user environment.
Calypso MUD is a simple mud server written entirely in C, using TCP/IP for data transmission.
Cancan is an interactive utility similar to telnet, but providing some functionality that is especially useful for playing text based multi-user games such as MUDs. However, its use is not limited to mudding. You can connect to normal telnet or any service that works with plain telnet.
CircleMUD is a multi-user dungeon game system (MUD) that is freeware. The code compiles under most versions of UNIX (including Solaris, SunOS 4.x, Ultrix, Linux, AIX, and HP/UX), Microsoft Windows (Windows 95 and Windows NT), IBM OS/2, Mac System 7/8, OpenVMS, and the Amiga. CircleMUD is a derivative of DikuMUD. While Circle still retains the "look and feel" of the original DikuMUD, it has dozens of additional features and bug fixes, and much of the code has been rewritten to be more flexible, efficient, easy to understand, and easy to extend.
Crystal Mud Client
At first glance Crystal Mud Client looks like telnet, but has full line editing and scrollback, character set conversion support, Unicode support, prompt grabbing, xterm titlebar setting, and window size negotiation.
The Dead Souls MUD Library is a multi-user text based adventure creation system. It allows the user to build their own adventure game which can be played over the internet simultaneously by many people. It is designed for both experienced and beginner MUD admins.
Deadlock Dungeons is a small MUD using Scheme as a MUD OS language.
Improving the LambdaMOO by adding modules, support grafic ssl moonets, making a client that is good for the programming, chatting and RPGing part of the new emerald city project.
ErisMUD is a MUD/MOO server/engine written in Python on top of SQLite. It currently supports many features and easy internal commands take care of the development and maintenance. Released under the GPL and 100% free.
ErlyMUD is a rather minimalistic MUD server, written in Erlang and making use of the excellent OTP libraries.
Ferox is a multi window mud client for Linux, based on the Qt-library and has a simple scripting language.
Fuzzball Muck is a networked multi-user MUD chat server. It is user-extensible, and newer versions (6.x) support advanced features such as GUI dialogs, through close client-server cooperation with Trebuchet or other clients that support MCP-GUI.
GammaMOO is a fork of the LambdaMOO server with numerous cleaned-up patches and modern MOO functionality.
GGMud is a multiplatform graphical MUD client that works on Linux, MacOSX, and Win32. It uses the GTK toolkit and is mostly similar to ZMud. Features include: ANSI 16 color output, aliases, triggers, highligths, gags, multiple windows support, fully scriptable through LUA, and logging.
gmoo is a gtk+ based MOO (and MUD) client for all platforms (exept M$ windows) that support gtk+. It features: full ansi color output, half transparent background, timestamping of all text, and MCP 2.1 support.
gMUDix is an improved version of MUDix, a MUD
client for the Linux console. It is designed to
run as an X application, and was developed with
GnoeMoe is a full featured Gnome MOO (MUD Object Oriented) Client which aims at integrating in the Gnome desktop as nice as possible adhering the Gnome philosophy. It aims to be simple and easy to use. Some of the main features are: Ansi, Multiworld (tabs), Builtin editor, Ruby script extensions, MCP 2.1.
GNOME-Mud is a simple Mud CLient, written in C, using GTK+.
GroundZero II MUD Client
GroundZero II MUD Client is a console MUD client that includes automatic mapping, map discovery, shortest path, an item db, and more.
gtinyfugue implements a graphical wrapper around the terminal MUD client tinyfugue. Programming will be done using C via GTK aiming for the Gnome2 platform.
industrialMUD is a free Multiple User Dungeon server that operates over telnet, developed for Linux, and written completely from scratch. Integrated with it is the lightweight "Weld" programming language in which you can script autonomous AI computer robots or other automata.
KildClient is a mud client using the GTK toolkit. Its main feature is the support for Perl scripting, which allows you to do basically whatever you want. Other standard features of mud clients (triggers, gags, macros, etc.) are also supported.
KLMCL is a graphical MUD client for KDE with support for aliases, regexp triggers, spellup spells management, and key bindings.
Kmc aims to be a mud client that is easy to use but powerful. The two top priorities are power through scripting and configurability, and user comfort. Features ANSI, mud profiles, logging, command history, split/full screen mode and scripting via Perl.
Kmud is a free graphical MUD client for KDE which features include: connection wizard / profiles, automapper, aliases, triggers, input history, split screen, ansi/vt100 support with color customising, logging facility, a programmable toolbar, and MCCP (mud client compression protocol) support.
KMuddy is a MUD client for the KDE desktop environment. It features configurable colors, short-cuts, split screen when viewing output history, command history, session transcript and speed-walking.
Koala Complete Mud Server
KoalaMud is a new mud source base designed around multithreading and stability. On top of this platform, Shadow of the Wheel is evolving to demonstrate its capabilities.
LDMud started as a project to clean up and modernize Amylaar's LPMud gamedriver. Primary goals are full documentation, a commented source body and out-of-the-box support for the major mudlibs, of which the commented source body has been pretty much completed.
Lyntin is a mature multi-platform multi-user-interface mud client written entirely in Python. It's also a framework on top of which you can code additional functionality to suit your needs.
Under Linux mcl uses the Virtual Console interfaces to access the screen at a high speed, but it can also run in a TTY mode, allowing it to run under any other UNIX and in an xterm. Embedded language support (currently Python and Perl) allows high tweakability.
Mmucl (pronounced muckle) is a mud client written in Tcl and distributed under the Gnu General Public License. Mmucl has a number of interfaces both graphical and text based.
mooix is a MOO built on top of a regular unix system. It uses every unix strength possible to the advantage of the MOO; its multiuser nature, preemptive multitasking, disk caching, device abstraction, numerous programming languages, editors, libraries, etc. With Mooix, unix is the MOO.
MOOzilla is a cross-platform MOO client capable of rendering inline HTML directly from a MOO. It is similar to Pueblo, but it is capable of rendering much more HTML, and it is available on any platform which can run the Mozilla web browser.
Mud Magic Mud Client
Mud Magic Mud Client is a GTK/GNOME multi-platform MUD client that provides aliases, triggers, multiple connections, plugins, MCCP, ZMP, MSP, tabbed sessions and ANSI color.
MUDAid is a graphical MUD client for Linux. It is written in C using the GNOME libraries. It will feature actions (triggers), aliases, mapping, and anything else a hardcore mudder could want. Using the ZvtTerm widget, MUDAid should be fast and Fully ANSI compatible.
MUDix is a simple MUD client for Linux with triggers and aliases and supporting ANSI colors.
nethack-el is an Emacs major mode for playing nethack. Separate buffers are used for the map, status, messages, and menus. It features customization of keys and colors and user programmable hooks on game events.
Original Gamer's Client
Original Gamer's Client aims to combine the convenience of a GUI-based MUD client with the power that seems reserved for TUI-based clients. OGC implements its GUI using Tk, and will eventually add a powerful Python-based scripting language.
Papaya is a fully featured GTK/Gnome MUD client for UNIX (including Linux, *BSD and Solaris), Windows and MacOS X. Features include: Multiple simultaneous connections, fully configurable ANSI colour, a fully-featured trigger and alias system, MCCP support, and plugins to enable extra features without adding unnecessary bloat.
PennMUSH is a MUD server that is often used for running social or role-playing games, with an extensive internal programming language. PennMUSH keeps its database in the computer's memory. This makes PennMUSH suitable for computers which have plenty of memory or little disk space.
Perlmoo is a Lambdamoo-like moo, written and extensible in perl. Perlmoo has been supersceded by its successor, mooix.
(shareware) PerlMUD is a MultiUser Dimension (MUD), a text-based environment that allows multiple users to converse, explore, and interact. PerlMUD is written in Perl 5 and is highly compatible with the well-known TinyMUD command set, which provides a friendly interface to your online environment.
powwow is a client program, which replaces telnet for the lazy mudder who wants some (only some?) extra features. It is primarily designed for DikuMUDs, but nothing prevents its use for other types of muds.
PyGCS is a VERY stripped down MUD-like chat-server that runs in a small amount of memory.
RMOO is a MOO client for Emacs, a powerful, extensible text editor used mostly on Unix-like systems. In addition to the basic functionality you would expect in a MOO client, RMOO includes more powerful features, such as the ability to edit MOO text, mail, and code in separate Emacs buffers. In addition, newer versions of RMOO support the Emacspeak audio desktop, thus enabling blind people who use Emacspeak to use a MOO more easily.
SClient is an small and fast mud client to be used under X Windows. Features: Connection wizard, logger, trigger, macros, aliases, ansi support, command line history etc.
ScryMUD is a MUD written completely from scratch in C++. It has a full feature set, including persistant belongings, a tree-based skill/spell system, game-navigated vehicles, complex scripting and player-owned stores.
SMM++ Mud Client is a mud client with extended and unique features. SMM++ features a highly customizable user interface (labels, buttons, and menus), unique and powerful mapping capabilities. Powerful scripting, even classes!
The Grendel Project
The Grendel Project is a modularized mud server: most functionality has been placed inside seperate modules which can be loaded/unloaded at will.
TinTin++ is a mud client that runs in console mode. TinTin++ should run on any unix/linux system (BSD, SuSe, Slackware, Debian, Mandrake, to name a few) and emulators, such as Cygwin for windows.
TinyFugue, aka "tf", is a flexible, screen-oriented MUD client, for use with any type of MUD. Features include: text terminal UI, with separate panes for user input and server output, a powerful scripting language, perl-compatible regular expressions, locale support, user-defined keybindings, and more.
TinyMUSH 3 is a descendant of the TinyMUD server, and thus supports multi-user communication in a text-based "virtual world" format, via TCP/IP connections (presumably, but not necessarily, Internet connections). The end result looks much like text adventures games of the mid-1980s. Though its simplest application is as a chat server, TinyMUSH 3 is intended to have the flexibility and power to support highly complex roleplaying environments.
TinyMUX is a text-based game server in the MUSH family. It is a platform that allows several thousand players to connect to a single text-driven environment, and interact with each other and with the environment (which is maintained in a database). The rich programming environment can be used to build almost anything, limited only by the developer's imagination.
tkMOO-light is an advanced chat client suitable for use with muds and especially MOO systems. The client runs on UNIX, Windows and Macintosh platforms.
tnMUD is a modular MUD server written in C++. Its lightweight core can by easily extended by modules, which are loadable/unloadable at runtime. The tnMUD project aims to create a fast and full-featured MUD server.
Trebuchet Tk is a client program for connecting to TinyMUD style social MUD servers on the InterNet. This program is designed to be used with TinyMUD, TinyMUCK, TinyMUSH, MOO, and several other variants. It's probably not well designed for combat oriented MUDs like LPMUD and Diku, but it does support them.
UnsignedByte is a modern MUD server. It uses an SQLite3 database as its backend instead of text-files.
The (VME) Valhalla Mud Engine is a commercial mud (Multi User Dungeon) server.
Wolfshade is a MUD (Multi-User Dimension), completely written in C++, with an object-oriented model and open source code. It is complete with full ANSI color, thousands of rooms, 27 races, 13 classes, 300+ spells, moving maps, God-run quests, race wars, and much more.
Xpertmud is an extensible perl, python and ruby scriptable MUD client. It is based on Qt and KDE. There's a native Linux/KDE version as well as a native Windows/Win32 build. It supports multiple windows (which are scriptable), and you can use triggers, aliases or whatever you want on every bit of text that comes from or goes to the server. There's a stable and intuitive plugin API, so you can extend the client with Qt-based C++ code. A sample plugin for the btech MUX is included.
ymusk is a perl/tk mush client. Written in Perl, its core engine is built on top and around the Tk and Net::Telnet Perl modules.