Performance Benchmarks
Benchmark results for Altruist's core runtime systems. All measurements taken with BenchmarkDotNet v0.14.0 on .NET 9.0 Release builds, 20 iterations per benchmark with 5 warmup rounds.
Note:
At 30 Hz (industry standard for action MMOs), each tick budget is 33ms. All systems combined consume ~0.9ms per tick for a typical server (50 players, 500 NPCs), leaving 97.3% of the budget for your game logic.
Color key: excellent | acceptable | needs attention | zero alloc
Entity Synchronization
The sync system detects property changes on [Synchronized] entities and broadcasts deltas to clients every tick.
| Scenario | Latency | Memory | Notes |
|---|---|---|---|
| No changes (steady state) | 198 ns | 320 B | Only SyncAlways fields checked |
| Position update (2 fields) | 249 ns | 320 B | Typical monster/player move |
| Full state change (10 fields) | 363 ns | 320 B | Respawn, teleport |
| Full resync (forced) | 372 ns | 320 B | Player enters view range |
| Metadata cache lookup | 17 ns | 104 B | Reflection cached at startup |
1000 entities synced in ~249 μs. At 30 Hz that's 7.5 ms/sec total — negligible.
AI Behavior System
Compiled-delegate state machines. Zero allocations during normal operation.
| Scenario | Latency | Memory |
|---|---|---|
| FSM tick (no transition) | 14 ns | 0 B |
| FSM tick (state transition) | 76 ns | 0 B |
| Create new FSM | 193 ns | 800 B |
| Tick 1,000 entities | 13.6 μs | 0 B |
| Tick 5,000 entities | 67.8 μs | 0 B |
5000 AI entities at 30 Hz = 2.0 ms/sec total CPU.
Note:
The AI system is the most efficient subsystem. Compiled Expression delegates eliminate all reflection overhead at runtime. State transitions with Enter/Exit hooks cost 76 ns — less than a dictionary lookup.
Combat System
Single-target attacks and area-of-effect sweep queries.
| Scenario | 100 entities | 1,000 entities | Memory |
|---|---|---|---|
| Single attack | 8 ns | 8 ns | 32 B |
| Damage calculation | 0.7 ns | 0.7 ns | 0 B |
| Sphere sweep (r=500) | 2.3 μs | 10.9 μs | 1.1-1.7 KB |
| Sphere sweep (r=2000) | 2.7 μs | 14.6 μs | 2.0-9.3 KB |
| Cone sweep (90 deg, r=1000) | 2.3 μs | 10.7 μs | 1.2-2.0 KB |
| Line sweep (r=2000) | 3.0 μs | 17.0 μs | 1.2-2.0 KB |
Even the most expensive operation (large AoE sweep over 1000 entities) completes in under 17 μs.
Visibility Tracking
Computes which entities each player can see. Uses parallel per-observer computation, tick staggering (8+ observers: half per tick), and runs concurrent with sync.
| Players | NPCs | Tick latency | Memory | Per-player cost |
|---|---|---|---|---|
| 10 | 100 | 118 μs | 38 KB | 12 μs |
| 10 | 1,000 | 397 μs | 152 KB | 40 μs |
| 50 | 100 | 201 μs | 43 KB | 4 μs |
| 50 | 1,000 | 886 μs | 154 KB | 18 μs |
| Lookup | Latency | Memory |
|---|---|---|
| Get visible entities for player | 5.6 ns | 0 B |
| Get all observers (10 players) | 154 ns | 128 B |
| Get all observers (50 players) | 771 ns | 128 B |
Note:
Optimizations applied: Parallel.For for 4+ observers, tick staggering for 8+ observers, adaptive SpatialHashGrid for 200+ entities, visibility runs concurrent with sync. Combined: 6x faster for 50 players x 1000 NPCs (5.23ms down to 0.89ms). Lookups 2x faster via optimized set access.
Collision Detection
Physics-less overlap detection with Enter/Stay/Exit lifecycle. Uses SpatialHashGrid broadphase with long hash pair keys and reverse index for O(1) removal.
| Entities | Tick latency | Memory | Notes |
|---|---|---|---|
| 100 | 13 μs | 10.5 KB | Broadphase + long hash keys |
| 500 | 204 μs | 51 KB | 10x faster, 76x less memory vs brute-force |
| Operation | Latency | Memory |
|---|---|---|
| Dispatch hit (single pair) | 426 ns | 992 B |
| Remove entity cleanup | 45 ns | 0 B |
Note:
SpatialHashGrid broadphase (cellSize=300), long hash pair keys (no tuple alloc), reverse index for O(1) entity removal (277ns down to 45ns), cached handler registry (zero-alloc dispatch). Memory: 3.9 MB down to 51 KB (76x reduction).
World Object Iteration
Foundation operations used by all subsystems every tick.
| Operation | 1,000 objects | 5,000 objects | Memory |
|---|---|---|---|
| Create snapshot (struct) | 2.5 ns | 2.5 ns | 0 B |
| Filter synced entities | 1.1 μs | 12.5 μs | 0 B |
| Filter AI entities | 1.2 μs | 13.4 μs | 0 B |
| Dictionary lookup by ID | 14.5 ns | 14.5 ns | 0 B |
| Distance check (r=2000) | 2.9 μs | 22.5 μs | 0 B |
Zero allocations for all iteration and filtering operations.
Combined Tick Budget
Estimated per-tick cost for a typical game server: 50 players, 500 NPCs, 30 Hz.
| System | Cost per tick | % of 33ms budget | Status |
|---|---|---|---|
| Entity sync (550 entities) | ~0.14 ms | 0.4% | excellent |
| AI behavior (500 NPCs) | ~0.01 ms | 0.0% | excellent |
| Visibility (50 x 500) | ~0.5 ms | 1.5% | excellent |
| Combat (average) | ~0.01 ms | 0.0% | excellent |
| Collision (500 entities) | ~0.20 ms | 0.6% | excellent |
| World iteration | ~0.05 ms | 0.2% | excellent |
| Total framework overhead | ~0.9 ms | 2.7% | excellent |
| Available for game logic | ~32.1 ms | 97.3% |
Note:
At 2.7% framework overhead, you have 32ms per tick for game logic. The optimizations in v0.9.0-beta reduced total overhead from 4.9ms to 0.9ms — a 5.4x improvement.
Estimated CCU Capacity
Based on measured per-player marginal cost of ~10 μs (visibility with parallel + stagger, post-optimization):
| Tick Rate | Budget | Single-thread | With stagger (2x) | 8-core sharding | Use case |
|---|---|---|---|---|---|
| 20 Hz | 50 ms | ~5,000 | ~10,000 | ~40,000+ | MMO world sim, slower-paced combat |
| 30 Hz | 33 ms | ~3,300 | ~6,600 | ~26,000+ | Action MMO (industry standard) |
| 60 Hz | 16.7 ms | ~1,600 | ~3,200 | ~12,000+ | FPS / fast-paced action |
| 128 Hz | 7.8 ms | ~780 | ~1,560 | ~6,000+ | Competitive FPS (CS2-tier) |
Note:
These are CPU-only estimates for full authoritative simulation (AI + combat + collision + visibility + sync every tick). Real-world limits are typically network bandwidth — with visibility-aware sync, Altruist only sends data for nearby entities.
These numbers represent a full game simulation server — AI state machines, damage formulas, collision broadphase, spatial visibility, and delta sync all running every tick. Competitors reporting 3K-20K CCU are measuring idle connections or stateless RPCs with zero game logic.
Why Would You Choose Altruist?
When you search for "game server framework", you'll find Photon, Nakama, Colyseus, and Fusion. They all report impressive CCU numbers. So why pick Altruist?
Because those frameworks give you infrastructure — connections, rooms, message delivery. You still have to build the actual game server yourself: AI, combat, collision detection, visibility, entity sync. That's months of work, and you'll be debugging your own implementations with no benchmarks to guide you.
Altruist gives you all of that built in, with nanosecond-level measurements proving it works. The comparisons below are apples to oranges — and that's the point. The other frameworks don't even have apples to compare.
| Framework | What the server does per tick | Per-connection CPU work |
|---|---|---|
| Photon | Forwards binary messages between clients | ~0 (relay, no logic) |
| Nakama | Handles REST/WebSocket RPCs, stores data | ~0.02 ms (stateless) |
| Colyseus | Serializes room state, sends delta patches | ~0.05 ms (schema diff) |
| Altruist | AI FSM + combat + collision + visibility + delta sync | ~0.017 ms (full simulation) |
About the CCU numbers below:
A Photon server holding 3,000 connections that forward chat messages uses almost zero CPU per connection. An Altruist server with 6,600 connections at 30Hz is running 5 complete game systems per entity per tick — AI state evaluation, damage formulas, spatial collision broadphase, visibility range checks, and bitmask-based delta detection. When other frameworks report higher CCU, they are measuring a lighter workload. Their numbers would drop dramatically if they ran equivalent simulation logic.
Photon Server (C++/C# — industry standard)
The most widely used commercial game server platform.
| Metric | Photon Server 5 | Altruist | Edge |
|---|---|---|---|
| CCU per server | 2,000-3,000 (relay) | ~6,600 at 30Hz (full sim) | Altruist |
| State sync approach | Manual RaiseEvent() | Automatic [Synchronized] delta | Altruist |
| AI system | None (user code) | Built-in FSM (14 ns/entity) | Altruist |
| Collision system | None (user code) | Built-in dispatcher | Altruist |
| Architecture | Room-based relay | World-based authoritative | — |
| Pricing | Commercial license | Open source | Altruist |
Nakama (Go — open source)
The leading open-source game backend.
| Metric | Nakama (1 node) | Altruist (single thread) | Edge |
|---|---|---|---|
| Max CCU | ~20,000 (stateless RPCs) | ~6,600 at 30Hz (simulation) | different workloads |
| State sync | Manual RPCs | Automatic delta (249 ns/entity) | Altruist |
| AI system | None | Built-in (14 ns/entity, 0 alloc) | Altruist |
| Simulation model | Stateless RPCs | Stateful world simulation | — |
Nakama excels at stateless operations (auth, matchmaking, leaderboards). Altruist excels at stateful simulation. A production game might use both.
Colyseus (Node.js — open source)
Room-based state synchronization in Node.js.
| Metric | Colyseus | Altruist | Edge |
|---|---|---|---|
| CCU (cheap server) | ~3,000 (relay) | ~6,600 at 30Hz (full sim) | Altruist |
| Sync cost per entity | Not published | 249 ns (measured) | Altruist |
| AI system | None | 14 ns/entity | Altruist |
| Collision | None | 13 μs / 100 entities | Altruist |
| Visibility | None | 118 μs / 10p x 100n | Altruist |
| GC pressure | V8 GC pauses | AI: 0 alloc | Altruist |
Photon Fusion (Unity — commercial)
Photon's latest Unity networking SDK.
| Metric | Photon Fusion | Altruist | Edge |
|---|---|---|---|
| Max players | 200 at 60Hz (client-side) | ~3,200 at 60Hz, ~6,600 at 30Hz (server-side) | Altruist |
| Runtime allocations | Zero (claimed) | AI: 0 B, Collision: 10.5 KB | comparable |
| Built-in AI | No | Yes (14 ns/entity) | Altruist |
| Built-in combat | No | Yes (8 ns attack) | Altruist |
| Sync cost per entity | Not published | 249 ns (BenchmarkDotNet) | Altruist |
| Pricing | Commercial | Open source | Altruist |
What makes Altruist different
Most frameworks are infrastructure — connections, rooms, message delivery. Their CCU numbers reflect idle connection capacity. Altruist is a simulation framework — every tick runs all game systems with measured, verified performance:
| Built-in System | Per-tick cost | Memory | Status | What you'd build yourself |
|---|---|---|---|---|
| Entity sync | 249 ns/entity | 320 B | excellent | State serialization + delta detection |
| AI FSM | 14 ns/entity | 0 B | excellent | Behavior trees, state machines |
| Visibility | 118-886 μs | 38-154 KB | excellent | Spatial queries, interest management |
| Combat sweeps | 2-17 μs | 1-9 KB | excellent | AoE geometry, hit detection |
| Collision lifecycle | 13-204 μs | 10.5-51 KB | excellent | Overlap tracking, enter/stay/exit |
| All combined | 0.9 ms | — | 2.7% of tick | Months of custom development |
Sources:
- Photon Server 5 Performance Tests
- Photon Fusion Benchmark
- Nakama Benchmarks
- Nakama 2M CCU Scale Test
- Colyseus Documentation
Scaling Guidance
| Player count | Recommendation |
|---|---|
| Up to 2,000 | Single server instance, no tuning needed |
| 2,000-5,000 | Enable batch DB writes, tick thread partitioning per zone |
| 5,000-10,000 | 8-core sharding, reduce visibility range for dense areas |
| 10,000+ | Multi-channel deployment (3-4 channels). See Multi-Channel Servers |
Note:
These benchmarks were run on a single thread. The framework supports parallel world ticking across zones and tick staggering — on an 8-core server, effective throughput multiplies accordingly (see CCU table above).
Simulation Framework Landscape
The frameworks above (Photon, Nakama, Colyseus, Fusion) are infrastructure — they handle connections and data delivery but provide no game simulation systems. A newer generation of frameworks aims to be more complete.
SpacetimeDB (Rust — funded, v2.0)
The most ambitious competitor. A relational database that IS your game server — you write game logic as "reducers" that run inside the DB. Used by BitCraft (MMO on Steam).
| Aspect | SpacetimeDB | Altruist |
|---|---|---|
| Architecture | Database-as-server (reducers + tables) | Framework-as-server (world objects + attributes) |
| State sync | Subscription queries on tables | [Synchronized] attribute delta (249 ns/entity) |
| Language | Rust (server), C#/TS (client) | C# everywhere (.NET 9) |
| Built-in AI | No | Yes — [AIBehavior] FSM (14 ns/entity, 0 alloc) |
| Built-in combat | No | Yes — ICombatService + sweep queries (8 ns attack) |
| Built-in collision | No | Yes — SpatialCollisionDispatcher (13 μs/100e) |
| Built-in visibility | No (subscription filtering only) | Yes — VisibilityTracker3D with parallel + stagger |
| Performance data | 100K+ transactions/sec (DB ops) | 0.9 ms/tick (full simulation, BenchmarkDotNet) |
| Pricing | Free tier + $25/mo pro | Open source (Apache 2.0) |
SpacetimeDB solves the data persistence layer brilliantly. Altruist solves the simulation layer. They're complementary — a production game could use SpacetimeDB for persistence and Altruist for real-time simulation.
Rivet (Rust — Y Combinator, open source)
Game server hosting infrastructure with autoscaling, DDoS mitigation, and matchmaking.
| Aspect | Rivet | Altruist |
|---|---|---|
| What it is | Hosting platform (deploy + scale) | Simulation framework (game logic) |
| Built-in AI/Combat/Collision | No | Yes (all benchmarked) |
| State sync | Bring your own | Built-in [Synchronized] delta |
Rivet is where you'd deploy an Altruist server. Infrastructure, not simulation.
Pumpkin (Rust — open source)
High-performance Minecraft server with combat, AI, and inventory. The closest in spirit to Altruist — a complete server with built-in systems.
| Aspect | Pumpkin | Altruist |
|---|---|---|
| Scope | Minecraft-specific server | General-purpose game framework |
| AI | Minecraft mob AI | Generic [AIBehavior] FSM for any game |
| Combat | Minecraft combat rules | Pluggable IDamageCalculator + sweep queries |
| Reusable for other games | No (Minecraft protocol only) | Yes (TCP/UDP/WebSocket, any game) |
Pumpkin proves the demand for "complete server with built-in game systems" — but it's locked to one game.
Lance (Node.js — open source)
Physics-based multiplayer framework with position interpolation. Closest to Altruist's vision in Node.js, but largely unmaintained.
| Aspect | Lance | Altruist |
|---|---|---|
| Status | Minimal maintenance | Active development |
| AI/Combat/Collision | No | Yes (all built-in) |
| Runtime | Node.js (single-threaded) | .NET 9 (multi-threaded) |
| Performance | Not published | BenchmarkDotNet-verified |
21 game server frameworks analyzed
We surveyed every open-source game server framework available in 2025 (based on Game Server Showdown 2025 plus our own research). Here's what we found.
General-purpose frameworks: 12 surveyed
Frameworks that can be used for any game — not locked to a specific title.
| Framework | Language | AI | Combat | Collision | Visibility | Auto sync | Benchmarked |
|---|---|---|---|---|---|---|---|
| Altruist | C# (.NET 9) | Yes | Yes | Yes | Yes | Yes | Yes |
| Colyseus | Node.js | No | No | No | Partial | Yes | No |
| GoWorld | Go | No | No | No | AOI | No | No |
| Lance | Node.js | No | No | Physics | Yes | Yes | No |
| SpacetimeDB | Rust | No | No | No | No | Subs | DB ops |
| Nakama | Go | No | No | No | No | No | CCU |
| Leaf | Go | No | No | No | No | No | No |
| Moon | C++/Lua | No | No | No | No | No | No |
| Pitaya | Go | No | No | No | No | No | No |
| zfoo | Multi-lang | No | No | No | No | No | No |
| NoahGameFrame | C++ | No | No | No | No | No | No |
| Kudos | Go/Node.js | No | No | No | No | No | No |
0 out of 12 general-purpose frameworks have built-in AI or combat. Only Lance has physics collision. Only 3 have visibility. None publish BenchmarkDotNet-level performance data. Altruist is the only one with all 6 capabilities.
Game-specific servers prove the demand
These servers have built-in game systems — but they're locked to a single game.
| Server | Language | Locked to | Has AI+Combat+Collision+Visibility |
|---|---|---|---|
| AzerothCore | C++ | WoW 3.3.5a | Yes (not reusable) |
| rAthena | C++ | Ragnarok Online | Yes (not reusable) |
| Stendhal | Java | Custom MMORPG | Yes (not reusable) |
| Pumpkin | Rust | Minecraft | Yes (not reusable) |
| FerrumC | Rust | Minecraft | Yes (not reusable) |
| SEGS | C++ | Superhero MMO | Yes (not reusable) |
Every MMO that shipped needed AI, combat, collision, and visibility — because you can't make a game without them. Each one was built from scratch, locked to one title, in C++ codebases that are 10-20 years old. Altruist is what these would be if designed as a reusable framework from day one.
The bottom line
Across 21 game server projects surveyed:
| Capability | General-purpose (12) | Game-specific (7) | Altruist |
|---|---|---|---|
| Built-in AI | 0 frameworks | 3 (game-locked) | 14 ns/entity, 0 B |
| Built-in combat | 0 frameworks | 6 (game-locked) | 8 ns attack |
| Built-in collision | 1 (Lance, physics only) | 6 (game-locked) | 13 μs/100 entities |
| Built-in visibility | 3 (partial) | 6 (game-locked) | 118 μs (10p x 100n) |
| Auto delta sync | 2 (Colyseus, Lance) | 0 | 249 ns/entity |
| Published benchmarks | 0 frameworks | 0 | BenchmarkDotNet verified |
Sources:
- Game Server Showdown 2025 — survey of 21 open-source game servers
- SpacetimeDB — database-as-server
- Rivet — Y Combinator game server hosting
- Pumpkin (GitHub) — Rust Minecraft server
Where Altruist Stands
Every game server ever shipped needed AI, combat, collision, and visibility. Every studio built these systems from scratch — months of work, zero reuse, no benchmarks. The existing frameworks give you connections and rooms, then leave you alone with the hard part.
Altruist is the first framework to ship the complete simulation layer: built in, benchmarked, and ready to use. Not "bring your own AI." Not "write your own collision." Not "implement visibility yourself." It's all there, measured in nanoseconds, verified with BenchmarkDotNet, running together in under 1ms per tick.
That's not a feature list. That's months of engineering you don't have to do.