This webpage is an attempt at a central catalog of new and original
codebases of the MUD world. I will try to take a look at the projects
every 6 months or so, and appropriately update the "last updated"
information. This was last done in January 2006.

If you want to submit new information to this list, either as project
author or just interested party, email me and be sure to
include as much of the following information as possible:

Name of the project

URL to its website

Principal Authors - including homepage or email

Status (being designed, in early development, available and working, abandoned?)

Timeline - when did the development start, when was the last updated

License - GPL or something else?

Language - primary languages used

Platforms - UNIX, Windows, Macintosh?

Technology - other information (e.g. what database is used)

Description - 10 or so lines that describe the codebase. Concise description, no marketing filler, no vague long-term plans

Your project should at minimum have a web page with a large amount of
design information if no source is available yet. Otherwise there must
be a way to download the source code directly (no registration). No
more Diku-derivatives, please.

As of May 2001, I am using XML/XSLT to generate this pages. You can download the
XML file as well as the XSL stylesheet. For quickest
response time, send me a filled out <codebase> tag.

If you are interested in even smaller code bases (which aren't necessarily ordinary or basic!) take a look at the 16K competition results.

Written in C++ with an OO design, designed to provide utmost flexibility for
the designer to create complex worlds (not 50,000 worthless locations but
5000 highly detailed locations/mobiles/items). Fully functional builder
port, online interpreted specials code, flexible levels/quest/profession
track system to allow the game owners to set up any world they can imagine.
For the most part, if you can think it up, this codebase can probably
facilitate it.

AMC is an attempt to refresh the world of both Star Wars MUDs and
other Space Based games. The Team for the Project consists of 35
members from across the globe with varied backgrounds in both MUDs and
general Game Design. The aim is to produce a highly detailed, yet
exciting and addictive game for the players whilst minimising the need
for Staff Control. The Project includes everything from Fast based
Space battles to hand-to-hand combat on the ground, as well as
maximising the involvement of players in the game by allowing them to
run Factions, Manage Planets, Organise Spaceship Battlegroups and
Command Squads of NPC Troops.

The Aedon MUD server is a test bed implementationon of what we (me and some
other guys that don't have time to write code but much time to discuss ideas
about mudding) think would be a nice server for both players and developers.
Aedon supports (or will support) global and local commands, online building,
rules, stacked parsers and more. Development is characterized by long sleeps
interrupted by bursts of activity leading to the implementation of some new
feature discussed the night before. Aedon is *not ready* for a production
environment running a real MUD.

AweMUD is a MUD that focuses on flexibility of world design. The system will
allow full customization of nearly everything, with only the barest of rules
(combat, basic spell systems, etc.) hard-coded into the game.

Bluemud is a project to architect and build a mud server and driver. We
have several main goals while doing this. The first is to implement the
server and driver in Java using Jython, and extend the ideas from the
Varium project to create a solid mud server that is both easy to maintain
and gives the in-game developers a lot of freedom for creativity allowing
them to create a rich world environment. We're going to code the driver
and server components in Java taking advantage of Java security and strong
typing. This allows folks to do in-game World development in Python in a
safe and controlled manner.
The second goal is to produce a server and mudlib package that folks can
install on their system and have a basic mud up and running in ten or
fifteen minutes. We're using Jython which is a complete Python interpreter
written in Java. Because of this Bluemud will run on any system with
Jython and the JSDK or JRE installed. Bluemud is very portable (we're
already running it on several environments from Linux to Windows) and
should work fine on many platforms.
We're not looking for contributors yet. We might rethink this after our
alpha release.
We hit a snag with code-level security which we are researching. This may
cause a partial rearchitecture of the underlying code-base.
We are not yet running a mud on top of the bluemud code-base. When we
release our alpha (we're thinking 2 months--pending when we fix our snag),
we'll have an online tavern up and running.
Up-to-date status information is available on the web-site at:
http://bluemud.sourceforge.net/

The Break of Dawn Java codebase was originally meant to be a
Diku->ROM clone written in Java, but as it was developed many
new ideas have been taking shape. We are still trying to stay
true to our MUD roots, but we're trying to make the user
interface as friendly as possible. So far, it features
multi-threading, crash protection (Each player runs in their own
thread, and all exceptions from commands are caught before
causing their thread to crash.), dynamic editing of everything,
including the master command list, the score sheet (wrote a
formatting language to display stats), look command, etc. The
latest feature to be added is command line editing and history.
You can connect using regular telnet, and use the arrow keys to
go back and edit the current command, or use the UP/DOWN arrows
to browse your command history.
I currently am the only active developer, and it's a lot of work
for one person. I'm seeking experienced Java coders who would
like to help out.

ACM is written in C, and uses MySQL to store all data for the
mud. However, all objects, creatures, rooms, etc are still
loaded into memory; this is not a DB-driven mud. MySQL is only
used for saving data. While ACM is a custom base, areas for MERC
can be converted to MySQL into usable areas. The MUD itself is
meant for developers, and will be free of combat systems, magic
systems, classes, levels, affects, so that it will be an actual
codeBASE for MUDs of any genre or design. The theme behind the
design of the code was ease of use for builders and coders
alike. Therefore, the functions are very powerful and cut down
on repetitive code.

A very simple codebase started in C. It supports connections, and has minimal
and functional versions of "say", "who", "halt", and "quit" commands. Just
around 1000 lines, it's perfect for a person wanting to develop thier own
codebase without restriction and with 90% of networking code already taken
care of.

Calypso is a MUD (multi-user dungeon) codebase written in C/C++. The goal is to
provide the mudding community with a codebase capable of change and to adjust
readily to different ideas. The motive is to improve a somewhat stale climate
in which many of the muds today have to flourish in.
The more prominent aspects of the codebase are 1. being free from
external control or constraint from in-game elements, 2. being generic
with no tendency to lean toward a specific type of game-play. Its
dynamic design promotes the sharing of in-game elements and rules. The
result should be a codebase that is easy, for an administrator, to
create a fun role-play environment with.

A fresh, stable, full featured fantasy MUD codebase with a classic
look and feel. Includes a Web-based GUI Areas designer and an internal
Web Server. Features include everything observed in DikuMUD plus
dozens of classes, and over 1000 spells, chants, prayers, songs,
skills, and abilities. CoffeMUD can import and use the area files from
ROM, CircleMUD, Diku, Crimson, and others. ANSI support, plus tons of
traps, pits, mazes, and zone types. MOBs that can fly, fall, speak,
learn, climb, spellcast, follow, and stalk. There are languages,
professional skills, storms, resources and more.

Offline grid-based .wld file layout tool. With it you can create the
layouts for complete areas in minutes.(src included)
Integral online custom Win32 GUI editing client. Full ability to browse
and edit every mob/obj/wld/reset etc table in the game, with full
security of course. (src included)
100% from scratch code base, strict package prefixing naming scheme.
Integral ANSI-color (lots of it, user configurable), built in Hint
system to help new players.
All data files are text based to help with easy maintenance. All area
files are diku compatible, adding areas is particularly easy, the server
will even renumber them on the fly when it loads them (if its necessary)
Full C-like scripting language, complete with security so that you cant
bring the mud down. Allows the ability to code custom behavior (easily)
for any mob, obj, wld, reset, or area.
Full online command line based editing.
Complete documentation on C4 scripting language.
Unique race/class system, every combination is different.

DUMB MUD implements a Lisp dialect which is specialized
to allow the construction of multi-user environments.
Although no environment written in this language has
reached the development stage, the tools for doing so
are actively maintained, and guidance is available for
the interested hacker. No extensive knowledge of Java
is needed for building a world.
It will be useful to
have previous experience with some type of network
programming, and possibly with Common Lisp or Scheme,
but it should certainly be possible to begin using DUMB
MUD just based on the example code provided.

A graphical RPG. Focus is on extensibility and ease of use. Open source and
free, anyone is welcome to start their own world or edit the code at wish,
although it is unlikely that much editing would be necessary for the average
user thanks to a scripting language and other features.

Started in 1995, constant (albeit slow) development,
last updated January 2006

License:

Aristic or GPL

Technology:

Ruby/C
.
MySQL / PostgreSQL / BerkelyDB optional

Platforms:

UNIX

The FaerieMUD project aims to create a game that provides an even balance of
role-playing and action, with an emphasis on storytelling, believable
characters, a rich, detailed, and fully interactive environment, and a design
that focuses on maintaining the suspension of disbelief throughout the game.
The project is divided into two separate codebases -- an Open Source game
engine called MUES (Multi-User Environment Server) written in Ruby and C, and
a world hosted on that engine. The engine does not assume any particular game
design, but will provide such things as socket IO and database abstraction
layers, a game object metaclass library, a distributed services (middleware)
framework, an event scheduler and dispatcher, natural language parsing
services, and an extendible player shell.

Description: An early version of the codebase for Aliens vs Predator:
The MUD, from about 7 years ago. This is a science fiction MUD
codebase built for race-wars style no-penalty Player-Killing, and
regular mob-killing play. It is a fully functional codebase with
DG-Script derived script engine and IMC support. It should compile and
run out of the box, but no support is provided in getting it working.
Aliens vs Predator: The MUD is still open, although the codebase has
evolved much over the last 7 years from what this snapshot represents.

A MUD codebase written in Lua, using some object-oriented techniques. Was
originally a multithreaded C++ codebase that used Lua to handle data files,
but in September, I decided to rewrite the whole thing in pure Lua. The MUD
itself is very Diku-esque, small, and flexible. In most places of the code,
performance was sacrificed for simplicity. It has also been influenced very
heavily by CircleMUD, GodWars, and Final Fantasy III, V, and Tactics. Intended
to be mostly a hack & slash MUD, but I plan to add some things that will make
it more RP-ish.

A codebase started from scratch to take advantage of C++ object-oriented
programming. MUD++ includes a complete String and Socket classes and has
adjusted over time to include a byte-code compiled scripting language.
While not finished (or even developed), it is quite a lofty design that
would be very clean when finished.

MaeveenMUD will offer admins the unique feature of creating custom
commandlib's. All that is required is some knowledge in Visual Basic/C++ and
ActiveX. Admins now don't have to dig into the mud server source code to add
commands and features. They can simply start a new activex dll project and
link the maeveenmud programming API to it. Then they have access to the
maeveenmud structure and can code custom commands etc.

Mica is a persistent, object oriented virtual machine / interpreter which
can be used for building multiuser, multiprogrammer, multiagent
applications. In this sense it is a little like MOO, ColdMUD, CoolMUD,
etc. -- that is, the driver itself defines almost no behaviour, and the
"world" is programmed in-db using the Mica scripting language.
Unlike MOO, however, the driver is fully "disk-based", and the Mica
scripting language has multiple prototype inheritance, mix-ins/object
composites, tighter object encapsulation, private lightweight
"objects-as-values" in addition to global ("published")
objects-as-references, anonymous lambda expressions, exceptions, scatter
assignment, and much much more.

Moebius is an attempt to write a base engine which is completely vanilla
- in theory, it should support everything from simple talkers through to
the most complex of mud-worlds (with potential support for "roomless" 3D
environs as well). It's pure python, with a (currently) MySQL backend. All
data and most code is database-stored rather than file-stored - that removes
any 'load/save' issues, and allows for on-the-fly changes to the game. It's
currently running a demo copy at mud.bofh.net.au:5000, and is looking for
people interested in developing either the base code, or interesting worlds.

The goal of Momoko is to develop a multi-user environment for developing
multi-user environments. Everything should be modular and portable.
Everything should be editable from inside the MUD. Any protocol (telnet,
FTP, HTTP, IRC, SMTP) or database backend (flat-file, filesystem, SQL)
should be able to be used. Any language should be able to be used for
scripting (Java, Python, Scheme, C), not just a special toy language. Momoko
is designed to be modular enough to do anything. It is a response to the
problems the author noticed in attempting to extend MOO to do things it was
not designed for, such as distributed objects and integrating protocols such
as HTTP and IRC. Momoko is suitable not just for standard text-based MUDs,
but any kind of multi-user application, such as IRC servers, web-based
community forums, and graphical multi-user games.

Muq is positioned as a completely incompatible successor to MOO and
tinyMUCK, pushing the envelope in the areas of better programmability,
persistence, state factoring, garbage collection, time and space
efficiency, security, distributed operation, reliability and
administratibility.
Focus is on scalable construction of distributed worlds via
anarchic federation, and on maximizing the space of creative
contributions available to unprivileged users. The intent of
Muq is to provide the tools enabling and catalysing creation of a new
generation of online applications and communities -- not on being
yet another clone of existing servers aimed at building more clones
of existing games and worlds.

NakedMud is built on top of SocketMud, by Brian Graversen. It
aims to provide a rich set of utilities to aid the development of
new ideas for muds. It comes with no stock combat, magic, skills,
or other major parts of muds. NakedMud leaves these important
design decisions to you, so your mud can be exactly how you want
it to be.

OpenMUD is an open-source clone of the popular ROM codebase. Goals
include engineering a UI of a comparable level, and providing for
easy expandability in a modular format. Many interfaces are planned
for OpenMUD, including the standard telnet-style and http
connections. OpenMUD will use MySQL and possibly XML for data st
orage, and online building will be the standard method.
The main sources of code and fixes for OpenMUD will be the core
authors and the userbase at large. A wide range of developers will be
able to identify problems and write new code very effectively and
quickly.

The Paladin MUD Codebase endeavors to provide a theme-free codebase which
can be almost completely customized by changing the script language. Also,
the Paladin MUD paradigm includes providing a "persistent-state" environment
where there are no "zone resets" or "reboots" required (e.g. if you leave a
sword on the ground in a room, it will still be there tomorrow unless
something happens to it.)
Status: Currently, the datamodel is being reconstructed and the code on
sourceforge will compile, but not run, as we move from a completely XML
database, to a mmap() immediate storage system and XML for imports/exports.
If anyone would like to contribute, please email, or visit the sourceforge
site and check out the forums.

PoeMUD is a MUD driver written in Perl using the POE module. Designed with a
modular OOP approach, PoeMUD is highly extensible and can be turned into any
type of MU*.
PoeMUD is designed to be an open-source, generic, modular framework text MUD
which allows admins to build an underlying server for their MUD worlds that
is as full-featured as they need, without including unwanted features such as
command sets that do not match the general "feel" desired for the game
environment.

RPMUD is based on Jaruzel's MUD32, with additional commands, features
and XML data storage. RPMUD caters for non-coders, so world-builders
can use a friendly interface to populate their locations with NPCs,
groups, items, traps, secret doors and obstacles. A Quests creator
allows the DM to integrate Quest triggers and completers based upon
player interaction, with administrative commands stored for both
stages. RPMUD is a working server which uses the D20 Dungeons and
Dragons rules as a model. It includes a persistent memory, ensuring
consistency in a players experience of the World. For developers, the
full Visual Basic 6 source code is available for modification and
development. Support is provided via the website.

Incorporating code from 5 leading codebases, ResortMUD aims to make
itself easy for anyone to learn by using a command structure similar to
that of each of the codebases used to create it. In addition, many
functions have more then one command for those who are used to other
codebase terminology for those functions.
A short list of the more popular features includes the Oasis OLC,
ability to use furniture, freekill arena, webserver, IMC2, I3 and user
friendly immortal functions.

Originally designed as a quick-start codebase with most popular features and
snippets implemented. Rogue development has been purely code oriented and
lacks a unique world filled with areas. No stock zones are included and is up
to the mud developer to create the world from scratch. Much of the code is
influenced by Circle and LexiMUD as well as other sources.

Scratch is a MUD that was inspired by a
programmer to create a somewhat easy to use codebase
in C++. At the moment, there is no game content as I'm
still thinking of what I plan to do game-wise. There
is a barebones version of Scratch available. The
source for Scratch is available on request and the
barebones version of Scratch is available from the
website.

Description: Shattered Worlds is an attempt to create a MUD that is the most
realistic as possible while being very flexible. It will allow the players to
change the world within certain bounds. Skill system will be based on
Dragonrealms-type system. It has a custom client and a fully functional World
Editor. Our goal is to create a very good MUD that is free to play.

SocketMud is a bareboned mud codebase written in C, its features are mainly
oriented around sockets, some highlights are support for the mud client compression
protocol (version 1 and 2), ANSI color support and threaded calls to gethostbyaddr_r()
to avoid freezes when doing difficult DNS lookups. A very simple command interpreter
allows connected players to use a few pre-made commands like say, who, quit and
shutdown, but basicly it is just a bareboned codebase for people wanting to create
something from scratch without thinking about sockets.

TAMS is an acronym for Technologically Advanced Mud Server. The
plans for TAMS include first making a stable C++ mud that
extensively makes use of the STL to it's advantage. Currently,
TAMS is undergoing a complete revamp of the class hierarchy to
create a more abstracted interface (using inheritance from base
objects) for programmers to use. Afterwards, it will incorporate
a system to store the states of the world using MySQL, while XML
stores large database for future access. The worlds coordinate
planes will be stored using hexagonal grids to represent spatial
data. At a usable stage, a Java client will access special
extensions to TAMS, enabling it to provide players with such
things as health information and even scores to display in
formatted web tables.

Originally called "Gladiator Pits" and entered into the 16K mud competition,
this is a player-vs-player deathmatch game set in a fictional fighting arena.
Players are given a number of points which they can use to customise their
characters before engaging in one-on-one fights against other characters.
Glad 2.0 is a fairly small, bare-bones codebase containing slightly over 7000
lines of code. It contains socket code, a combat system, loading and saving
of ascii player files, context-sensitive help files, and various other
features. The codebase is not designed for newbie mud coders, but is ideal
for those who just need a little help to get started.

An attempt at creating a solid, fast, and stable MUD server
codebase that runs natively on Windows and Linux. Operational
features include IPv6 support, a plugin architecture, enhanced
scripting, copyover, and numerous other features.

TigerMUD's code is multithreaded and written in object oriented C#,
using Microsoft Visual Studio.NET 2003. Alternatively, you can code
TigerMUD with the free alternative Visual C# compiler named
SharpDevelop. TigerMUD uses an internal Access database as a back-end
data store, but uses ODBC so you can alternatively use MySQL or
Microsoft SQL databases. TigerMUD reads a tiny XML configuration file
and then loads all game data from the database. This startup data
includes all users, items, mobs, rooms, etc. For runtime performance,
TigerMUD reads all game data from RAM, but writes data changes back to
RAM and the database, so in the event of a MUD shutdown the world
comes back up as you left it.

Re-Inventing the Wheel perse. The development goal of WheelMUD is to push
the limits of current MUDDING technology. Current Goals include Queued
Fighting, dynamic rooms. Our Major Objectives are heavy documentation,
intuitive world design, and a GUI approach to administration.

WolfMUD is a new codebase created from scratch and written in 100% Java. It
is intended to be very easy for anyone to use. Just download and run. There
is no need for compiles to get it up and running. Also to make things easy
there is now a prototype World Builder which provides a GUI interface for
creating complete worlds, from zones and locations to mobiles,objects and
skills. Also included are features to help groups of designers work together
(can distribute work in editable or non-editable formats). Currently tested
on Win95/98/NT, OS/2, Linux, Solaris and AS/400. Easy to setup and configure
for small networks or internet use. Also has custom client but will also
work with other Telnet clients. Still at the Alpha stage but now the World
Builder is released more work is now being done to the main game engine to
add new features.

WolfshadeMUD strives for stability, play-ability, and addiction. We are
completely original code base, but we have strive for an original spell and
skill system. Our spell system is based on mana points like many other MUDs
but with an interesting twist. As you prepare spells your mana points
decrease when you cast them you get them back. Our skill system is set up
in tiers sort of like D&D's proficiencies. Not to mention that our race war
is four sided (Alien, Good, Evil, Neutral), and based on alignment (except
for alien) rather than race, through race plays an big part. The feel of
the mud is diku-ish but it's original code model is felt as well. We are
currently in beta testing.