- Introduction
- Getting Started
- Compilation Issues
- Running the Server
- Administration
- Development
- Performance and Optimization
- Platform-Specific Issues
A: Don't try to run your own MUD first! There are two types of MUD users: players and administrators. If you've never played a MUD, you should start by playing on existing MUDs to understand how they work. Running a MUD without understanding the player experience will leave you very confused.
Recommendations:
- Play several different MUDs to understand the genre
- Try both player and builder roles if possible
- Learn the common commands and gameplay mechanics
- Understand MUD culture and community management
A: While possible, a MUD is not a good learning project for C programming. MUDs have tens of thousands of lines of complex code that can be difficult even for experienced programmers.
If you're determined to proceed:
- Get a good C reference book
- Start with small modifications to existing code
- Avoid complex files like
comm.cinitially - Practice with simple additions like new commands or items
- Use existing code as templates (copy, paste, modify)
- Be patient - learning takes time
A: Luminari MUD is a derivative of tbaMUD, which itself comes from CircleMUD and ultimately DikuMUD. It's designed as a stable, extensible foundation for creating your own unique MUD rather than just another stock game.
Key Features:
- Highly optimized and stable codebase
- Online creation (OLC) system
- Advanced scripting capabilities
- Cross-platform compatibility
- Extensive documentation
A: The Luminari MUD source code is available from the official repository. Make sure you download the latest stable version.
A: Luminari MUD supports most modern platforms:
- Linux (all major distributions)
- Unix variants (Solaris, AIX, HP-UX, etc.)
- macOS (10.0 and above)
- Windows (with Cygwin or WSL)
- BSD variants
- Other POSIX-compliant systems
A: Minimum (small/private MUD):
- 20 MB disk space
- 32 MB RAM
- Basic Unix-like environment
Recommended (production MUD):
- 50+ MB disk space
- 50+ MB RAM
- Dedicated server or VPS
- Regular backup system
A: This depends on your hardware and network connection. A typical server can handle 50-100 concurrent players comfortably. Monitor memory usage and response times to determine your limits. Memory is more important than CPU speed for MUDs.
A: Common compilation issues include:
Missing Dependencies:
- Development libraries not installed
- Compiler not available
- Make utility missing
Configuration Issues:
./configurenot run properly- Wrong compiler version
- Platform-specific problems
Solutions:
- Ensure all development tools are installed
- Run
./configurebefore compiling - Check error messages for specific missing components
- Consult platform-specific README files
A: Sun's default cc compiler is not ANSI C compliant. Use gcc instead:
CC=gcc ./configure
makeA: Some systems require linking with the crypt library. This is usually handled automatically by the configure script, but you may need to install development packages:
# On Debian/Ubuntu
sudo apt-get install libcrypt-dev
# On Red Hat/CentOS
sudo yum install glibc-develA: Your system may need additional libraries for socket functions. The configure script should handle this, but you might need:
# Check if network libraries are available
sudo apt-get install libc6-devA: Some older systems don't have strdup(). The MUD code should include a replacement function, but if not, you can define it yourself or use a more modern compiler.
A: Parse errors usually indicate syntax problems in the code:
- Check for missing semicolons or braces
- Verify all includes are present
- Make sure you haven't introduced syntax errors in modifications
- Use a syntax-highlighting editor to spot issues
A: The autorun script runs the MUD in the background. This is normal behavior. To see what's happening:
# Check if the MUD is running
ps aux | grep circle
# View the log files
tail -f log/syslogA: Yes! This means the MUD is running successfully and waiting for connections. It's not frozen - it's ready for players to connect.
A: Check these common issues:
- Wrong port: Make sure you're connecting to the correct port
- Firewall: Check if the port is blocked
- Binding issues: The MUD might not be binding to the correct interface
- Client problems: Try a different telnet client
A: The MUD is looking for bulletin board files that don't exist. Create empty board files:
touch lib/etc/board.mortal
touch lib/etc/board.immortalA: SIGPIPE occurs when the MUD tries to write to a closed connection. This is normal and the MUD should handle it gracefully. If it's causing crashes, check your network code modifications.
A:
- Check for core dumps: Look for
corefiles in your MUD directory - Review logs: Check
log/syslogandlog/syslog.CRASH - Restart: Use the autorun script to restart automatically
- Debug: Use
gdbto analyze core dumps if available
A:
# If you have a core dump
gdb bin/circle core
# Or attach to running process
gdb bin/circle <process_id>
# Common gdb commands
(gdb) bt # Show backtrace
(gdb) info locals # Show local variables
(gdb) print var # Print variable valueA: Use one of these methods:
# Using nohup
nohup ./autorun &
# Using screen
screen -S mud
./autorun
# Press Ctrl+A, then D to detach
# Using tmux
tmux new-session -s mud
./autorun
# Press Ctrl+B, then D to detachA:
- Connect to your MUD and create a character normally
- Log in as that character
- Use the advance command:
advance <yourname> 34 - Set appropriate privileges as needed
A: You can add areas in several ways:
- Use OLC (Online Creation): Build areas while the MUD is running
- Create world files manually: Write .wld, .mob, .obj files
- Import existing areas: Convert areas from other MUDs
Make sure to update the zone table and assign appropriate zone numbers.
A: Use administrative commands:
freeze <player>- Temporarily disable accountmute <player>- Prevent communicationban <site>- Ban by IP or hostnamepurge <player>- Permanently remove character
Always document incidents and maintain consistent policies.
A: Implement automated backups:
#!/bin/bash
# Daily backup script
DATE=$(date +%Y%m%d)
mkdir -p backups/$DATE
cp -r lib/plrfiles/ backups/$DATE/
cp -r lib/plrobjs/ backups/$DATE/
cp -r lib/etc/ backups/$DATE/Run this script daily via cron and test restore procedures regularly.
A: Modern MUD servers can run for weeks or months without restart. Only restart when:
- Installing updates
- Memory leaks become problematic
- Configuration changes require it
- Performance degrades significantly
A: Yes, partially:
- World building: Use OLC to modify areas, objects, and NPCs
- Text files: Edit help files, MOTD, etc. and use
reload - Code changes: Require compilation and restart
A: Follow these steps:
- Add the command to the command table in
interpreter.c - Create the command function (usually in an appropriate
act.*.cfile) - Add the function declaration to the appropriate header file
- Implement the command logic
- Add help file entry
A: This is a complex modification involving:
- Updating constants and definitions
- Modifying character creation code
- Adding class/race-specific abilities
- Updating save/load functions
- Creating appropriate help files
Consider using existing patches or tutorials for guidance.
A: Yes, use different:
- Port numbers
- lib directories
- Binary names (optional)
Ensure adequate system resources for all instances.
A:
- Define the spell/skill in appropriate header files
- Add entries to skill/spell tables
- Implement the spell/skill function
- Add learning/practice mechanisms
- Create help file entries
- Test thoroughly
A: Monitor these factors:
- Memory usage (most common cause of slowdown)
- CPU utilization
- Disk I/O (especially player file operations)
- Network connectivity
- Number of concurrent players
- Script efficiency (DG Scripts, etc.)
A:
- Memory management: Regular restarts if leaks exist
- Database optimization: Efficient player file handling
- Script optimization: Review and optimize DG Scripts
- Resource monitoring: Limit resource-intensive operations
- Code profiling: Use profiling tools to identify bottlenecks
A: Common causes:
- Memory leaks in custom code
- Large numbers of objects in memory
- Inefficient string handling
- Accumulating log data
- Player file caching
Use memory profiling tools like valgrind to identify specific issues.
A: Windows compilation options:
- Use WSL (Windows Subsystem for Linux) - Recommended
- Use Cygwin - Traditional approach
- Use MinGW - Minimal GNU for Windows
- Use Visual Studio - Requires project setup
See platform-specific README files for detailed instructions.
A: Create a systemd service:
# Create service file
sudo nano /etc/systemd/system/luminari.service
# Add service configuration
[Unit]
Description=Luminari MUD Server
After=network.target
[Service]
Type=forking
User=mud
WorkingDirectory=/path/to/mud
ExecStart=/path/to/mud/autorun
Restart=always
[Install]
WantedBy=multi-user.target
# Enable and start service
sudo systemctl enable luminari
sudo systemctl start luminariA: This usually indicates DNS resolution issues. The MUD is trying to resolve hostnames for connecting players. This is often harmless but can be fixed by:
- Configuring proper DNS settings
- Disabling hostname resolution in the MUD configuration
- Checking
/etc/resolv.conf
- Administrator's Guide - Complete server administration
- Builder's Guide - World creation and OLC
- Developer's Guide - Code modification and programming
- Platform-specific README files
- Official forums and communities
- MUD development websites
- Code repositories and patches
- Tutorial collections
- Community forums
- Developer mailing lists
- IRC channels
- Discord servers
This FAQ is based on the original tbaMUD FAQ, updated and expanded for Luminari MUD. For the most current information, check the official documentation and community resources.
Last updated: July 2025