[Dev Log] Breaking the Leash of SaaS: Migrating to FishNet and the Hybrid Host Architecture

Subtitle: Cost, Control, and the Solution Found in Diablo

After making the firm decision to escape the "slavery" of expensive SaaS like Photon Fusion, my search for an alternative led me to FishNet.

FishNet is open-source, with a PRO version available on the Asset Store for those looking to expand commercial capabilities. The primary technical difference between the free and PRO versions lies in the depth of network compensation. While the free version focuses on basic interpolation for character movement, the PRO version supports sophisticated CSP (Client-Side Prediction), Extrapolation, and payload (packet) compression for traffic optimization.

1. Why FishNet: Reclaiming Control Over the "Black Box"

For my development goals, FishNet was a far better fit than Fusion. While the ability to converge Opex (Operating Expenses) toward zero was a significant factor, the most attractive aspect from an architect's perspective was "code-level control." Unlike Fusion, which felt like a black box where internal logic was hard to dissect, FishNet offered a wider scope for direct access and handling of low-level engine logic. Furthermore, the Separation of Concerns (SoC) between client and server code felt much more intuitive compared to the often-entangled structure of Fusion.

Of course, there is a price to pay. FishNet is structurally quite demanding. It has its own strict scene management logic that can easily conflict with Unity's built-in SceneManager, and the lifecycle of NetworkObject creation and destruction is more rigid than Fusion's, requiring a deeper conceptual understanding. Additionally, unlike other frameworks that spoon-feed dedicated server infrastructure as a SaaS, FishNet requires the developer to build the infrastructure for hosting dedicated servers themselves. However, for an architect like me who detests Vendor Lock-in, this was an advantage, not a drawback.

2. The Architecture Pivot: Shallow Coupling

While redesigning the network structure from scratch, I dissected the server architectures of hack-and-slash legends like Diablo 2 and Last Epoch.

These hits may look like fully persistent multiplayer games on the surface, but the actual feel of combat and dungeon crawling is identical to single-player. This is because they employ a "Shallow Coupling" approach—the central Dedicated Server doesn't control every single physical calculation. Instead, it only handles community features like chat, trading, and matchmaking.

I decided to adopt this model. I stripped the role of the central dedicated server down to its bare essentials—community functions and trade data validation—and pivoted the main gameplay to a Host-based architecture where the user opens the session.

Because a host-based architecture operates identically to a single-player game, it allows for lag-free, responsive combat regardless of network ping. Furthermore, by combining features like housing, unique terrain, and production systems based on the host's specific environment, I could provide a much denser and more engaging gameplay experience. Most importantly, this was the only viable survival strategy for a solo developer to avoid the suicidal server maintenance costs (Opex) typical of traditional MMORPGs.

3. A New Shackle: The Dilemma of Security and Performance

However, there is no such thing as a free lunch. Since a host-based configuration essentially makes the client the server (the authority), it becomes extremely vulnerable to data tampering (hacks and cheats).

Since even simple memory manipulation could collapse the game's economy, I had to implement heavy security logic—real-time encryption and integrity validation—for all key data handled by the client.

This created another dilemma:

The Performance Wall: Continuously running encryption/decryption code on Unity's main thread (C#) severely eats into the frame rate.
The Compatibility Wall: One of my core target platforms is the Steam Deck. Due to its Linux (Proton) environment, I cannot use the heavy, Windows kernel-level external anti-cheat programs favored by major corporations.

In the end, I needed a new structural design that didn't rely on external solutions and didn't tank Unity's performance. It was time to strip away the "fake async" (Coroutines) that Unity developers habitually use for security modules and descend into the machine room of the engine.