Most people, when talking about Server Meshing, usually think about the very final step of this technology where we "mesh servers together." The truth is that, before this final step, a very long chain of pre-requirements and fundamental technology changes need to be made to our game engine. With that in mind, I will try to answer this question in context of the full picture.

The short answer is the state is actually very advanced.

Now the long version. The road to Server Meshing started back in 2017/2018:

Object Container Streaming
For Server Meshing to work, we first required technology that allowed us to dynamically bind/unbind entities via the streaming system, as this isn't something the engine supported when we started. So when we released 'Client Side Object Container Streaming' (OCS) in 2018, we also released the very first step towards server meshing!

Once this initial stepping stone was out the door, the technology that allows us to dynamically bind/unbind entities on the client had to be enabled on the server as well (as ultimately server nodes in the mesh will need to stream entities in/out dynamically). This technology is called 'Server Side Object Container Streaming' (S-OCS), and the first version of S-OCS was released at the end of 2019. This was the next big step towards Server Meshing.

Entity Authority & Authority Transfer
While we had the technology that allowed us to dynamically stream entities on the server, there is still only one single server that 'owns' all simulated entities. In a mesh where multiple server nodes share the simulation, we needed the concept of 'entity authority.' This means that any given entity is no longer owned by a single dedicated game server, but instead there are multiple server nodes in the mesh. So, one server node that controls the entity, and multiple other server nodes that have a client view of this entity. This authority also needs the ability to transfer between server nodes. A good amount of development time was dedicated to the concept of 'entity authority' and 'authority transfer' in the first half of 2020. This was the first time the entire company had to work on Server Meshing, as a lot of game-code had to be changed to work with the new entity-authority concept. By the end of 2020 most (game) code was modified to support the concept, so another large step was taken, yet there is no actual mesh in sight.

Replication Layer & Persistent Streaming
The next step was to move entity replication into a central place where we can control the streaming and network-bind logic. This then allows us to replicate the network state to multiple server nodes. In order to achieve this, we had to move the streaming and replication logic out of the dedicated server into the "Replication" layer, which now hosts the network replication and entity-streaming code.

At the same time we also implemented Persistent Streaming, which allows the Replication layer to persist entity state into a graph database that stores the state of every single network replicated entity. 2021 was dedicated to work on the Replication layer and the EntityGraph, which allows us to control entity streaming and replication from a separate process (separated from the traditional dedicated game server). This work is almost complete and is in its final stage.

Static & Dynamic Server Meshes
However, this still isn't a "mesh." The work on the actual mesh has started and will take us well into next year to complete, and all the pre-requirements that I outlined above were necessary to even get to this point. The first version of this technology will be a static server mesh, and is the next big stepping stone. However, it will also not be the last! With the static mesh, we will have the first version of a true mesh but, as the name 'static' indicates, the ability to scale this mesh is very limited.

Before we can truly call this feature complete, we will need to take on another big step, which we call "dynamic mesh." This step will allow us to dynamically mesh server nodes together and then scale the mesh dynamically based on demand. A lot of the work on this part happens in parallel. For example, the Fleet Manager that controls the dynamic demand of the mesh is already in development, as well as the matchmaking requirements that come with the new inclusion of "shards."

In the meantime, a lot of game-code teams also have to work on adapting existing game code to fully work with a server mesh (and more importantly find all the edge cases that will only surface once we have a true mesh). While the entity authority work was completed in 2020, entity authority is currently only transferred between the client and one single server, so some code may need additional adjustments.