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:
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)
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.
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:
Add Phaser physics to the mix and you've got a very complex state to synchronize.
Given the non-competitive, cooperative nature of Vampire Survivors, we had more flexibility in how we handled synchronization. The core question became:
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.
Instead of one client or server managing everything, we distribute simulation responsibilities across clients.
The AI in Vampire Survivors is simple, with enemies moving directly toward a target player. That simplicity works in our favor.
This approach also lets Phaser physics handle local enemy collision naturally, preserving core gameplay without requiring constant network updates.
With accurate client prediction in place, we can reduce how often we send updates over the network.
Poncle had some clear hosting requirements:
We used coherence lobbies to manage player groups via invite codes. Once players are in the same lobby:
This approach ensures seamless multiplayer without extra engineering for each platform with no user-facing toggles or configuration required.
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.
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.
It’s worth pointing out a few things that made this project easier:
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
