Mina the Hollower—a stealth-first survival roguelike built atop a custom Bevy ECS architecture—has officially announced its multiplayer beta, dropping into early access this week. The Italian studio behind the game (formerly known for *The Last Faith*) is leveraging a hybrid WebTransport-based P2P backbone with WebAssembly for cross-platform synchronization, a move that directly challenges Unity’s dominance in multiplayer networking stacks. This isn’t just another “add friends” feature: Mina’s design forces players into asymmetric cooperation, where one “Hollower” (the active miner) and up to three “Echoes” (spectators with limited agency) must navigate procedurally generated caves with zero server authority—only client-side validation. The implications for game dev ecosystems? Massive.
The Hollower Protocol: Why Mina’s P2P Stack Matters More Than You Think
Mina’s multiplayer isn’t bolted onto an existing engine. It’s a first-principles rewrite of how survival games handle networking. Traditional client-server models (like *Minecraft*’s) rely on authoritative servers to resolve disputes—expensive, centralized, and prone to lag. Mina’s approach? Conflict-free replicated data types (CRDTs) for inventory, a NaCl-backed key exchange for session keys, and a WASM runtime that compiles the game logic to WebAssembly at runtime. Which means:
- Zero server costs: No AWS bills, no rate-limiting. The game’s “world state” is sharded across players’ machines.
- Cross-platform parity: A Windows Hollower and a Linux Echo can sync seamlessly due to the fact that the networking layer abstracts away OS quirks.
- Anti-cheat by design: Since all players validate the same state locally, exploits like speed hacks or duplicate items are self-healing—no third-party anti-cheat like BattlEye required.
But here’s the catch: CRDTs aren’t free. Mina’s implementation uses a variant of the RGA algorithm (Relaxed Graph Automata) to handle the game’s procedural caves, which are essentially DAGs (directed acyclic graphs) of connected rooms. The tradeoff? Higher memory usage for the “Hollower” role (the active player) because their client must maintain a full graph of possible cave branches, even as Echoes get a pruned view. Benchmarks from the dev team show a 30% increase in RAM usage for the Hollower vs. Solo mode—but latency drops to ~50ms even on 3G connections.
The 30-Second Verdict
Mina’s multiplayer isn’t just a gimmick. It’s a technical manifesto against centralized game servers, and it works—flawlessly—for its niche. But ask yourself: Could this scale to an MMO? Probably not. The CRDT overhead becomes prohibitive at 100+ players. That said, for indie devs, Mina’s stack is a game-changer. No more paying Unity for Photon licenses. No more praying to Valve’s matchmaking gods. Just raw, peer-to-peer survival.
Ecosystem Bridging: The War for Decentralized Gaming
Mina’s arrival isn’t just a footnote in the survival genre. It’s a shot across the bow of two titans: Unity’s Relays and Unreal’s dedicated servers. Both rely on proprietary networking middleware that locks devs into their ecosystems. Mina’s open-sourcing of its HollowerSync library (a Rust crate for CRDT-based multiplayer) could force Unity to either:
- Adopt CRDTs natively (unlikely, given their server-heavy architecture).
- Double down on proprietary solutions (risking developer backlash).
- Acquire the tech (already rumored in some circles).
More importantly, Mina’s model aligns with a growing trend: decentralized gaming. Projects like Immutable’s zk-proofs and Ethereum-based gaming are exploring similar ideas, but Mina’s approach is pragmatic. No blockchain bloat. No smart contract gas fees. Just WebTransport and CRDTs.
— “Mina’s stack proves that decentralized multiplayer doesn’t demand to be slow or insecure. The real question is whether Unity or Epic will let indie devs keep using it—or if they’ll force everyone back into their walled gardens.”
St. John’s quote cuts to the heart of the matter: platform lock-in. Unity and Epic don’t just sell engines—they sell ecosystems. By offering a viable alternative, Mina (and its open-source contributors) could accelerate a shift toward Bevy and Godot as the go-to tools for indie multiplayer devs. The risk for Unity? A brain drain of networking talent to open-source projects.
Under the Hood: Benchmarks, Tradeoffs, and the Rust Backbone
Mina’s multiplayer isn’t just theoretical. The devs have published raw benchmarks showing how their stack holds up against traditional client-server setups. Here’s the breakdown:
| Metric | Mina (P2P + CRDT) | Unity Relays (Client-Server) | Unreal Dedicated (Client-Server) |
|---|---|---|---|
| Latency (3G Connection) | ~50ms |
~120-200ms (server round-trip) |
~80-150ms (with optimizations) |
| Memory Overhead (Hollower Role) | +30% (CRDT graph) |
~5-10% (minimal) |
~15-25% (replication buffers) |
| Cheat Resistance | Self-healing (CRDT consensus) |
Server-authoritative (but exploitable) |
Server-authoritative (with anti-cheat plugins) |
| Cross-Platform Sync | WASM + WebTransport (native) |
Photon middleware (proprietary) |
Unreal’s networking layer (proprietary) |
The numbers tell a clear story: Mina’s approach sacrifices some memory efficiency for radical latency improvements and zero server dependency. But is this sustainable at scale? The devs acknowledge that beyond 10 players, the CRDT graph becomes unwieldy. Their solution? Dynamic sharding—splitting the cave into independent subgraphs that merge only when players interact. It’s a clever workaround, but it’s not a silver bullet.
— “The real innovation here isn’t just the CRDTs. It’s the adaptive sharding. Most games either go full centralized or full decentralized. Mina’s hybrid approach is the future for niche multiplayer titles.”
Vasileva’s point is critical. Mina’s architecture isn’t just about performance—it’s about resilience. In a world where DDoS attacks and serverless costs are rising, decentralized multiplayer could become a necessity for indie devs. The question is whether Unity and Epic will let it happen—or if they’ll bury it under proprietary tech debt.
What This Means for Enterprise IT (Yes, Really)
You might think Mina’s multiplayer is just for gamers, but the tech has enterprise implications. CRDTs and P2P synchronization are already used in:
- Automerge (collaborative editing).
- Yjs (real-time document sync).
- Operational Transformation (Google Docs, Slack).
Mina’s twist? Applying CRDTs to a high-frequency, stateful environment (a game world). The lessons learned here could trickle into:
- Low-latency trading systems (where every millisecond counts).
- Medical imaging collaboration (where P2P avoids HIPAA compliance headaches).
- Disaster response tools (where central servers are the first to fail).
The catch? Enterprise adoption would require formal verification of the CRDT implementation—something Mina’s team hasn’t prioritized yet. For now, this is a gamer’s toolkit. But watch this space.
The Takeaway: A Blueprint for the Next Generation
Mina’s multiplayer isn’t just another “add friends” feature. It’s a proof of concept for how games can break free from the server shackles of Unity, and Unreal. The tech works. The benchmarks are compelling. And the open-source community is already forking the HollowerSync crate to experiment with their own CRDT-based networking.
But here’s the kicker: This won’t replace client-server for MMOs. The overhead is too high. Instead, Mina’s approach is perfect for:
- Indie survival games (like *Mina* itself).
- Asymmetric multiplayer (where not all players need full authority).
- Offline-first experiences (think *Darkest Dungeon* meets *Among Us*).
The real battle isn’t between P2P and client-server. It’s between open ecosystems and walled gardens. Mina has thrown down the gauntlet. Now it’s up to Unity, Epic, and the indie dev community to decide whether they’ll compete or acquire.
One thing’s certain: The next big survival game won’t be built on Unity’s back. It’ll be built on WebTransport, CRDTs, and a whole lot of Rust.
