A Developer’s Guide to Persistent Game Server Hosting

Modern multiplayer has changed considerably even in just the last few years. Gamers mainly focus on one or two titles that absorb the majority of their playtime, and these games are often large, community-driven living worlds. In turn, game server hosting has evolved beyond simple session management.

The rise of these persistent worlds, where players build bases, terraform landscapes, manage digital companions, and stack up loot, has shifted the engineering challenge from merely connecting players to now preserving their impact across time.

For studios that are developing such a game, especially as they near post-production or launch, some fundamental infrastructure hurdles need to be resolved in their chosen game server hosting model. For instance, how do you manage the state of thousands of dynamic, ever-changing worlds without building a bespoke orchestration layer from scratch? The “build” path forces you and your team to become distributed system architects, which diverts resources and engineering hours away from your actual game development.

GameFabric solves this by reimagining long-lived game server hosting through our feature add-on, Local Persistence. We provide an integrated, developer-first model that handles world state management as a platform feature. This allows your studio to “buy” the complex orchestration of persistent world files so you can focus on your build efforts for your actual game.

Many cloud gaming services are built on the concept of stateless, ephemeral containers. This is perfect for a 15-minute deathmatch (see Armadas), but it's adverse for a persistent game world.

Our model begins with Vessels: long-lived, uniquely identifiable server instances. A Vessel retains its specific configuration, name, and ID across game server updates and restarts. This allows your players to reliably reconnect to their specific world instance.

To manage these at scale, we use Formations to group Vessels based on shared resource profiles (CPU, RAM) and game versions. This guarantees consistency whether you’re deploying ten servers for a closed beta or ten thousand for a global live game release.

A notable pain point in persistent game server hosting is managing the actual world data. Often, standard cloud architecture forces you to rewrite your server’s I/O logic to talk to external object storage APIs like S3 just to save a map file.

GameFabric’s Local Persistence removes this pain point by providing local disk behavior for your instances. Your game server simply writes its save files to what it perceives as a local disk. You don’t need to implement an S3 connector.

Behind the scenes, GameFabric is transparently managing this data. When a Vessel shuts down, the data from this virtual disk is automatically uploaded to reliable, redundant cloud storage. When that Vessel spins up again (even if it’s on a different physical machine in a different region), GameFabric restores the disk with the last saved state. Effectively, this gives you the simplicity of a dedicated game server with the elasticity of the cloud.

This solution is part of GameFabric’s modus operandi of hybrid cloud orchestration. Your persistent world data follows the Vessel seamlessly, whether it’s running on our high-performance bare metal compute for baseline load or bursting into a cloud service during a peak event. 

It’s important to note, however, that Local Persistence is designed for the world state managed by the game server itself (e.g., the location of a player base). Service-specific data, typically handled by a central backend, such as player inventories, player progression, and account information, is handled by your separate backend database systems.

Once you have Local Persistence, persisting data on shutdown becomes table stakes. The next challenge for liveops is capturing the state of a running, dynamic world without corruption. Simply copying files while the server is writing to them is, frankly, a recipe for disaster.

This is where GameFabric brings in its Cooperative Snapshot Persistence add-on to solve this. It’s a feature that facilitates a handshake between your game server and our orchestrator. Instead of the platform guessing when to save, your game server identifies a safe, stable moment and signals the platform via API. We then capture a snapshot of your world state without interrupting the multiplayer experience. In other words, a snapshot can be taken during runtime without the need for player disconnect.

Your snapshot history remains vital for game server monitoring and recovery. With our capability to restore snapshots, you can promote any historical snapshot to be the active state. This is especially useful when a patch introduces a critical bug, for instance. You’ll be able to seamlessly roll back your fleet to its pre-patch state, saving your launch or live title from potential player fallout.

Building a persistent world shouldn’t require you to engineer a bespoke distributed file system. By choosing a game server hosting solution that handles the heavy lifting of world state management, your studios can offload the complexity of persistence, replication, and recovery.

GameFabric offers the pre-established tools that allow your team to focus on building your game, not your server infrastructure.

About to launch a world that players will never want to leave? Request your personalized GameFabric demo today to make it last.

NOTE: Local Persistence is currently available in its BETA phase.