Free mud software for linux

BMUD project is a GNOME mud client.
Its a GNOME/gtk+ mud client designed to make muds more enjoyable.
Enhancements:
- Aliases (thanks Dan Tenner)
- New networking code (thanks Robert Hansen)
- Internationalization/localization (I think...)
- New preferences dialog
- Lots of fixes for compatability with muds, like
- the is appended as per rfc854 (Thanks David Knight)
- handles escape codes that dont end in m (Thanks Stephan Gtter)
- Lots of code cleanup
- Lots of bug fixes
- Connection wizard is now buttons (click on which mud you want

JMud project is an experimental MUD server written in Java.
JMud is a MUD server written in Java from scratch, available in Brazilian Portuguese.
Multi-lingual support is in progress for Spanish and English.
Enhancements:
- This version brings basic instruction manual
- more Windows-friendly (wmake.bat)
- improvements in playability with guilds and guildmasters.

mudFTP is a protocol used for transfer of text files between a MUD server and a mudFTP client program. The text files can be notes, programs, room descriptions, etc. Once the file is transferred to the client, it is edited locally using the users favorite text editor.

In order to install mudFTP on your server, your server must have a centralized mechanism for editing text entries. In case of most MERC derivatives, this happens via the function string_append which takes a char** and takes over the control over input from the user, reallocating the text string as necessary. In any case, a fair knowledge of the C programming language and your MUD server is required in order to install mudFTP.

Once installed on the server side, mudFTP will listen on another port - typically youd wand this to be 6 higher than the normal port (e.g. if your mud is on port 4444, your mudFTP port would be on port 4450).

You users then use the mudFTP client program to connect. The client program identifies itself to the server with the MUD username/password and then waits for a request.

When a user with mudFTP enabled then edits a text using the text editing mechanism, it notices that there is a mudFTP connection and sends the text there instead of to the normal user screen. The users mudFTP client reads the text, saves it to a temporary file and spawns an editor. The user edits the file, and when satisfied, exits the editor. This causes the mudFTP client to send the text back to the server - which in turn replaces the text the user was editing with the new text from the client.

The server source code is ported to following platforms:

* Diku-like servers:
o Envy 2.2 with ILAB OLC
o Mythran 3.1.6b
o ROM 2.4b6 with Ivans OLC 1.72 (by Jessica Boyd)
o ROT 1.4 (by Dominic J. Eidson)
o Circle 3.0 (by George Greer)
* Non-Diku
o LDMUD (by Markus Peter) - should be portable to any LP [New!]

Ports under development:

If you are interested in porting to a new server platform, please email me. mudFTP should be portable to your server as long as your server has some central mechanism for editing text strings.

The C version of the client code works under the following platforms:

* Linux (libc5 as well as glibc)
* Any UNIX (untested, but the code is fairly compatible)
* Windows 95 and NT (port by Cath Allen)
* Windows 98 (untested)

The Java version of the client will work on any Java-capable platform.
Id very much like someone to port the client to the Macintosh platform

tnMUD project is a flexible and modular MUD server.
tnMUD is MUD (Multi-User Dungeon) server written in C++. It uses XML (via libXML2) for handling data files.
Its lightweight core can by easily extended by modules, which are loadable/unloadable at runtime.
Maybe youre asking why were writing new MUD server, when there is a lot of others. Well, when I started MUDding, I want to make my own MUD. I try MUDOS with Lima mudlib and also some DIKU-based codebases, but it was too difficult to make it work.
Main features:
- Easily creating new areas. New area can by simply made by writing new module, which will take care of the creation. Currently, the only one thing needed is load all the area from XML file. The area can be written in one big file or in many small files. XML format makes it clear and editable in any plain-text editor.
- Clearly extending objects. New objects behaviour is done through the actions and objects parameters are stored as attributes (string or integers). It is clear and there is no need to inherit classes for room, NPC or item.
- Stable & fast. Because tnMUD doesnt use any scripting language (LPC, Python, Perl), it is quite fast. And if theres any bug, it the server will receive SEGV signal and crashes. The bug is fixed and the server is more stable.
Enhancements:
- Added support for equipment, channels and room types.
- Improved color handling.

GNOME-Mud project consists of a MUD client for the GNOME platform.

GNOME-Mud (formerly AMCL) is a Multi-User Dungeon (MUD) client that aims to make mudding a bit easier.

It can define aliases, triggers, variables, keyboard shortcuts, and has a connection wizard for easy management of different player characters and MUDs.

A Small MUD project is a minimal MUD implementation.

A Small MUD is a minimal MUD implementation, with some mildly intelligent mobs running around creating rooms.

A few pointers when reading the source code... the World class contains the "cells" in the dungeon - all those are created randomly by the mobs.

The MobFactory class contains and controls all mobs in the world - the class holds a reference to the World class.

Cells are specified by the World::CELL struct and mobs by the MobFactory::MOB struct. The SmallHandler class contains the World, MobFactory, and active sockets list (via SocketHandler).

Finally, the SmallSocket class handles all socket communication and the ListenSocket template class acts as the socket listen server.

MUDMapper project is a tool for mapping MUD locations.

MUDMapper is a simple tool that uses Python and DiaCanvas to draw maps of MUD locations. It can save and reload maps and keep descriptions for every room.

Calypso MUD project is a MUD (multi-user dungeon) framework.
Calypso is a MUD code base written in C. The goal is a code base capable of change and of adjusting readily to different ideas.
The motive is to improve a somewhat stale climate in which many of the MUDs today have to flourish.
It is a simple mud server written entirely in C, using TCP/IP for data transmission. It was my first attempt using a modular design for a project.
Enhancements:
- Mud core now completely independent from the library package!
- New library loading procedures, used with new command-line parameter
- Implemented special libraries
- Replaced control script with event script database
- Event scheduler in progress
- Autorun script added
- Autorun procedure fixed
- Background command-line parameter added