Powerful Features for Modern Servers

RustUO combines proven reliability with the performance and safety of Rust, delivering next-generation server emulation capabilities.

Performance That Scales

Built for performance from the ground up with Rust's zero-cost abstractions.

10,000+

Idle Connections

Local target (path to 100k)

5,000 RPS

Burst target (local PG+Redis)

< 2ms

Ping RTT p95

Loopback at 1k pps

30–50k/sec

Persist Updates

RocksDB coalesced writes

Technical Excellence

Every component designed for reliability, performance, and maintainability.

📡

Tokio Networking + Packet FSM

Multi-threaded Tokio runtime with a per-connection finite state machine (FSM) and zero-copy parsing for O(1) dispatch.

Zero-copy decode with Bytes/BytesMut
Static dispatch table (fn pointers)
Vectored writes (writev) for coalescing
Backpressure via bounded writer queue

🌍

Single Coherent World (ECS/Actor)

An ECS/actor hybrid world core with sector-based interest management for movement and chat at scale.

Actor world-task processes event queue
Sector grid interest broadcasting
Movement ack/reject semantics
Visibility on sector enter/exit

💾

Real-Time Persistence (RocksDB)

Dirty-object coalescing and WAL-backed write batches for continuous saving with crash-safe recovery.

WriteBatch + WAL with fsync bound
30–50k updates/sec on NVMe (target)
Checkpoint/epoch metadata
Kill-9 recovery via WAL replay

🔐

Accounts & Sessions

PostgreSQL for accounts, Redis for session tokens and IP rate limiting for robust login flows.

Argon2 password verification pool
Opaque SID tokens with TTL
Audit logging and lockouts
5k login RPS burst target

📈

Observability & CI

Metrics, tracing, and CI across Windows, macOS, and Linux using GitHub Actions multi-OS matrix.

Prometheus metrics export
Tracing spans per connection
Flamegraphs & Criterion benches
GitHub Actions with Postgres/Redis

🧪

Testing Strategy

Unit, property, fuzzing, integration, and load/soak testing to validate correctness and performance.

Packet codec/property tests
FSM transition and fuzz tests
End-to-end movement/chat/commands
Loadgen: 100k idle, 50k pps goals

Modern Scripting Experience

Write server logic in Rust with a familiar API that's both powerful and safe.

Custom NPC Implementation

use rustuo::prelude::*;

#[derive(Mobile)]
pub struct CustomNPC {
    #[mobile(base)]
    base: Mobile,
    
    #[mobile(property)]
    special_ability: String,
}

impl CustomNPC {
    pub fn new(location: Point3D, map: Map) -> Self {
        Self {
            base: Mobile::new(location, map),
            special_ability: "Fireball".to_string(),
        }
    }
}

#[async_trait]
impl MobileActions for CustomNPC {
    async fn on_speech(&mut self, speech: &SpeechEvent) -> Result<()> {
        if speech.text.contains("hello") {
            self.say("Greetings, adventurer!").await?;
        }
        Ok(())
    }
}

✅

Memory Safe

Rust's ownership system prevents common bugs like null pointer dereferences and buffer overflows.

💡

Zero-Cost Abstractions

High-level features compile down to optimal machine code with no runtime overhead.

⚠️

Developer Friendly

Familiar patterns and strong types make building content straightforward and intuitive.

Seamless Migration

Designed to provide a smooth transition path while delivering significant performance and reliability improvements.

✓

World File Compatibility

Import existing world files without modification or data loss.

✓

Script Migration Tools

Automated tools to convert C# scripts to equivalent Rust implementations.

✓

Configuration Compatibility

Familiar configuration options and administrative interfaces.

Migration Checklist

View Migration Guide →