Building Vampire Survivors Online Multiplayer Co-Op
Vampire Survivors is a genre-defining roguelite that took the gaming world by storm. Designed by Luca Galante and his studio Poncle, it became an instant indie hit, even winning the BAFTA for Best Game in 2023, beating out titles like Elden Ring and God of War: Ragnarök. Its unique take on the “reverse bullet hell” format (also known as a bullet heaven or auto-shooter) sparked an entire subgenre of imitators. And when the coherence team was approached to help bring online co-op to Vampire Survivors, we were instantly excited.
Poncle had already implemented a four-player local co-op mode, which gave us a strong starting point: multiplayer design elements like shared screens, multiple player inputs, and the removal of single-player architecture bottlenecks (e.g., global state and singletons) were already in place. But one big question remained:
Can a game like Vampire Survivors, with hundreds of enemies, dozens of weapons, and chaotic on-screen effects, be networked in a way that’s fun and cost-effective?
The short answer: Yes. Using coherence tech and our experienced co-development team, we made it happen. Here’s how we tackled the biggest technical challenges and brought online co-op to life. (If you’d like to discuss a project with our team, just get in touch! It’s a fairly straightforward process to determine if there is a fit between coherence and your game)
Challenge 1: From Phaser to Unity (but still kind of Phaser)
Vampire Survivors was originally a Phaser-based web game. Although the project has since moved to Unity, much of the underlying game logic is still rooted in Phaser’s architecture.
One major example: enemies. They’re still treated as Phaser dynamic physics bodies and their interactions rely on those physics systems. Enemies push each other around when they collide, often forcing slower ones into the player’s path. This gameplay mechanic is key to the game’s difficulty and pacing. The reliance on local physics interactions makes it especially tricky to network. A traditional multiplayer approach (synchronizing all enemy positions and collisions) would be hard to maintain and likely wouldn’t scale.
Challenge 2: Chaos at Scale
In a typical online multiplayer game, you might designate every visible object (enemies, pickups, effects) as a networked entity. But in Vampire Survivors, with hundreds of enemies, dozens of projectile effects, and constant object spawns, that model just isn’t feasible. The game’s simulation is incredibly active:
- Enemies are constantly spawning, taking damage, dying, and dropping XP gems.
- Six player weapons fire unique projectiles, constantly.
- Gems and drops are physical objects, moving around and being collected.
Add Phaser physics to the mix and you've got a very complex state to synchronize.
Our Networking Approach
Given the non-competitive, cooperative nature of Vampire Survivors, we had more flexibility in how we handled synchronization. The core question became:
How much desync between players can coherence handle without compromising the experience?
For this type of gameplay experience, it turns out coherence can tolerate a fairly wide margin of desync between the clients sharing the session. The solution was a combination of heavy client-side prediction, lightweight determinism, and careful use of coherence features to reduce bandwidth and ensure smooth gameplay.
Feature 1: Distributed Simulation with Authority Handoff
Instead of one client or server managing everything, we distribute simulation responsibilities across clients.
- If a stage needs 400 enemies, and there are four players, each client becomes the “owner” of 100 enemies.
- This spreads out the bandwidth load and reduces strain on any one player’s connection.
- Other entities (e.g., pickups, destructibles) are still instantiated by the host.
Feature 2: Smart Client-Side Prediction
The AI in Vampire Survivors is simple, with enemies moving directly toward a target player. That simplicity works in our favor.
- Each client predicts enemy movement locally.
- Networked position samples apply small corrections to the local simulation.
- Enemy targets are synchronized only when they change (e.g., a player dies or disconnects), so there’s minimal network traffic.
This approach also lets Phaser physics handle local enemy collision naturally, preserving core gameplay without requiring constant network updates.
Feature 3: Adaptive Simulation Frequency
With accurate client prediction in place, we can reduce how often we send updates over the network.
- Enemy positions are synced at 1Hz (once per second).
- Locally, simulations run at 60Hz, so everything still feels responsive.
- Bandwidth is significantly reduced without sacrificing gameplay quality.
Challenge 3: No Dedicated Servers
Poncle had some clear hosting requirements:
- No authoritative servers
- Support for seamless crossplay (Steam, Epic, Xbox, PlayStation, Switch)
- Default to client-hosting when possible to reduce costs
- The multiplayer experience should be exactly the same on every platform, with no differences in how to host or join games.
Solution: Flexible Hosting with Coherence Cloud Hosting + P2P
We used coherence lobbies to manage player groups via invite codes. Once players are in the same lobby:
- If all players are on the same platform, we default to that platform’s native P2P service.
- If platforms differ, we fall back to coherence Cloud Hosting, which also acts as a backup if P2P fails.
This approach ensures seamless multiplayer without extra engineering for each platform with no user-facing toggles or configuration required.
Bonus Challenge: UI Transitions in Multiplayer
In Vampire Survivors, key moments (like level-ups, treasures, merchants) pause gameplay to show a choice-based UI. In local play, this is easy: just pause and resume the simulation. In online multiplayer, UI transitions must be kept in perfect sync. If transitions arrive out of order (which can happen due to dropped packets), players could see different UIs at different times.
Solution: we use coherence’s ordered commands to ensure UI events triggered by the host arrive and play back in the correct order on every client, even when multiple transitions happen close together.
Bonus Challenge: Integrating Coherence Without Breaking the Game
Vampire Survivors already had a rich, well-defined single-player architecture. Rewriting everything to support multiplayer would have been a massive lift. Fortunately, coherence is designed to slot into existing codebases. This allowed us to integrate multiplayer without major changes to Poncle’s development workflow. Adding new features remains fast and lightweight.
Challenges We Didn’t Have to Solve
It’s worth pointing out a few things that made this project easier:
- No competitive gameplay: Since there’s no real incentive to cheat, we could lean on P2P and client-side simulation without worrying about server-side validation.
- Local co-op already existed: Many core multiplayer design problems (e.g., multiple players sharing one screen, game state separation) had already been solved in the existing local mode.
Final Thoughts
Converting Vampire Survivors into a fully networked multiplayer game was no small feat—but it was exactly the kind of project coherence was built for. By combining our network engine, Unity tools, and experienced dev team, we helped bring one of the world’s most beloved indie games online—without compromising performance, gameplay, or development speed.
Written By