Oxide MUD is a modern, high-performance DIKU-style MUD engine written in Rust. Featuring a concurrent asynchronous network loop, dynamic live scripting, visual terminal-based building tools, and native AI capabilities.
MUD servers are expected to run uninterrupted for months or years. Rust’s strict compile-time checks completely eliminate common crash-inducing bugs, such as segmentation faults, null pointer references, and multi-threaded data races. Your persistent world stays online 24/7/365, giving players and builders a rock-solid, reliable experience.
By compiling directly to optimized machine code with zero-cost abstractions, Oxide MUD utilizes hardware to its absolute limit. Memory leaks are impossible by design, and RAM consumption remains tiny. You can easily host a massive multiplayer world with hundreds of active rooms, NPCs, and players on a basic $5/month VPS without experiencing any network or system lag.
Built using a lockless Entity-Component-System (ECS) data model driven by a multi-threaded asynchronous network loop. Game data (such as character sheets, active spells, and items) is separated from gameplay logic (such as combat rounds or AI loops). This makes adding custom components or systems incredibly easy and highly modular, scaling effortlessly to handle thousands of concurrent game updates.
Enforces a strict driver/mudlib separation. The core engine handles network and database persistence, while quest logic, custom spells, combat behavior, and items are scripted in a safe, sandboxed scripting language. Content designers can edit, debug, and hot-reload scripts directly on a live server instantly—changes go live in real-time with no downtime or recompilation needed.
An optional, terminal-based visual builder utility that allows developers and designers to build and edit text worlds. It displays an interactive map grid, validates references, and parses content files visually. No need to manually write or format raw TOML data; Spade handles the heavy lifting, with planned support for online/remote sync to edit live servers.
Features built-in support for the Model Context Protocol (MCP), an open standard that allows LLM assistants (like Claude) to securely connect to your MUD project. AI agents can read and write game templates directly—automatically generating connected rooms, writing custom script logic, or validating references, speeding up game content creation 10x.
An objective technical comparison of OxideMUD's compiled Entity-Component-System (ECS) and asynchronous execution design against the dynamic virtual machine and object-oriented actor paradigm of LPmuds.
| Dimension | OxideMUD (ECS + Rhai) | LPmud (OOP + LPC) |
|---|---|---|
| Concurrency & Threading | Asynchronous Multithreading: Connection handling, combat ticks, AI state machines, and database queries run concurrently on Tokio-managed OS threads. Data access hazards are eliminated at compile-time. | Serialized Single-Threaded: Execution runs sequentially on a single virtual machine thread to prevent dynamic reference data races. Any slow execution blocks the entire game loop. |
| Memory & Data Locality | Cache-Friendly ECS: Separation of entities (raw IDs) from data components stored in flat, contiguous memory pools. Systems iterate over arrays sequentially for high CPU cache utilization. | Heap Object Indirection: Every room, item, and player is a distinct heap-allocated object. Retrieving variables via dynamic lookup causes pointer chasing and cache thrashing. |
| Execution Safety | Bounded Sandbox: Rhai scripts run with strict inline limits (max 50,000 instructions, 32 recursion levels, bounded memory allocations). Filesystem and network access are blocked. | Unconstrained VM: LPC scripts run natively in the virtual machine bytecode engine. Infinite loops, deep recursion, or high memory usage can freeze execution or crash the driver. |
| Content Architecture | Declarative Templates: Decouples description from behavior. Base stats, descriptions, and exits are defined in declarative TOML files, while code is confined to event hooks. | Monolithic Code: Static fields and game behaviors are mixed directly inside imperative LPC scripts, complicating automated static validation and parameter balancing. |
| Persistence & I/O | Batched Database Writes: Flushes dirty entity changes to a SQLite database in WAL mode using a background thread pool every 5 seconds, shielding the game loop from I/O latency. | File Serialization: Synchronously writes entity variable state to flat files on disk (via save_object) in the main loop thread, risking disk lag pauses. |
| Builder Accessibility | Visual Tools & TOML: Enables non-technical authors to create rooms, items, and NPCs using static TOML files, terminal visual builders (Spade TUI), or AI natural language agents (MCP). | Mandated Coding: Requires all content creators to write C-like LPC scripts to define even basic rooms and items, posing a more technical barrier to entry. |
[immediate_phase] quests_and_factions = "In Progress" └─ Multi-stage quest chains, journal event triggers, and dynamic faction reputation levels.spade_online_sync = "In Progress" └─ Connect local Spade TUI world editor directly to a live server to build rooms and items in real-time.spellcasting_system = "Todo" └─ Structured magic loops, mana/resource cost formulas, spell registries, and active effect bindings.
[advanced_capabilities] spade_client_mode = "Todo" └─ A dedicated MUD client mode in Spade with connection profiles, split-screen dash, and script consoles.mxp_protocol_support = "Todo" └─ MUD eXtension Protocol integration for clickable navigation links and graphical HUD health gauges.crafting_and_economy = "Todo" └─ Crate item recipes parsing, crafting rolls system, merchant shop inventories, and currency exchanges.