Devlog: A World Without Borders

Technical Post

Atherion is an open-world game, and our goal is to support hundreds of thousands of players simultaneously. To achieve that, a technique called Server Meshing must be implemented — connecting multiple servers together so they function as one seamless world.

We started building our own custom netcode from scratch on top of Unity’s NetCode for Entities, and we call it Atherion ServerMesh. Today we are sharing our first proof of concept (PoC) — a very early experiment that demonstrates transferring a single entity between two servers seamlessly, with no loading screens or interruption.

We want to be clear: this is not a finished technology. It is the first step on a long road. Seamless real-time transfer between multiple game servers is one of the hardest technical challenges in the games industry, and available resources on the topic are extremely scarce. Very few studios have attempted anything like this, and there is no off-the-shelf solution you can buy or download.

The Problem We’re Trying to Solve

Every large-scale online world faces the same fundamental constraint: no single server can simulate an entire continent. The world must be divided into regions, each managed by a different machine. And when you cross from one region to the next, something has to give.

In most games, this means a loading screen. A brief freeze. A teleport. A flicker of rubber-banding. Our goal is for Atherion to be different — to cross a server boundary the way you cross a river, by walking, without noticing.

What the PoC Demonstrates: Buffer Zones

The concept this proof of concept tests is deceptively simple: instead of a hard line between two servers, we create a buffer zone — a region of overlap where both servers are actively running your entity simultaneously.

Think of it as a border province claimed by two kingdoms. Both kingdoms have scouts patrolling the area, both maintain watchtowers, both track every soul that moves through. The province doesn’t belong to one kingdom or the other — it belongs to both, until the moment you cross the river at its heart.

Here is what actually happens when your character approaches a zone boundary:

Entering the Buffer

Your character is 300 meters from the border. Server A, which currently owns you, sends a message to Server B: “Prepare a shadow of this entity.” Server B creates a copy — a mirror that receives position updates 60 times per second. Both servers now simulate your character. Server A commands; Server B follows.

From your perspective, nothing changes. The world streams around you. You keep walking.

The Authority Flip

You cross the boundary. In a single message — faster than a single frame of animation — authority flips. Server B now commands your entity. Server A becomes the follower, maintaining a shadow in case you turn back.

No reconnection. No stutter. No lost inputs. Your character’s movement is continuous, as though the boundary never existed.

Cleanup

You move deeper into the new zone, 300 meters past the border. Server A quietly destroys its shadow copy. The handoff is complete. The process stands ready to repeat whenever you approach another boundary — or turn around and walk back.

What Survives the Crossing

A seamless transition means nothing if your character arrives on the other side diminished. When authority transfers in Atherion ServerMesh, everything transfers — health, movement speed, active targets, custom data, ongoing effects. The generic serialization framework preserves any game data structure across servers.

In this PoC, when the entity crosses from one server to the other, its data transfers with it — health, movement speed, active targets. We built a generic serialization framework that allows any custom data structure to be carried across servers.

In the future, this means your character and all its data will travel with you. The server changes, you do not. But we are not there yet — this PoC proves the mechanism works.

Sixty Updates Per Second

While your character moves through a buffer zone, both servers exchange position corrections at 60Hz — sixty updates per second. This is not the standard network tick rate. This is a dedicated high-frequency stream that ensures your movement appears perfectly smooth to every player on both servers.

To keep bandwidth under control, we use delta compression: only the coordinates that actually changed are transmitted. A full position update costs 61 bytes. A delta update costs roughly 15. That is a 75% reduction in bandwidth with zero loss of visual smoothness.

The result: enemies tracking you from across a zone boundary see your position update every 16 milliseconds. There is no jitter, no interpolation gap, no “phantom step” where you appear to teleport forward.

The Client World Pool

On the client side, a traditional approach would require your game to maintain a separate connection to every server you might enter — a costly and fragile strategy. Instead, Atherion uses a client world pool: a set of reusable connections that activate as you approach a new zone and go dormant when you leave.

When you walk toward a boundary, the pool silently warms a connection to the neighboring server. By the time authority flips, your client is already synchronized. When you move away, that connection goes idle but stays alive — ready to reactivate instantly if you return.

The effect is that zone transitions carry no connection latency. You never wait for a handshake. The world is always one step ahead of you.

Demo: Seeing It in Action

In the demo, you will see an entity moving continuously across a zone boundary. Watch for the authority indicator — it shifts from gold (Server A) to blue (Server B) at the exact moment of transfer. The movement never pauses. The HUD overlay shows real-time metrics: buffer state transitioning from Normal to InBuffer to Crossing and back to Normal, the zone minimap tracking entity position, and a live event log capturing every message exchanged between servers.

What you are seeing is two real servers running as separate processes — the first server runs headless in the background, managing the first zone, while the second server runs alongside the game client in the window you are watching. Both communicate over real UDP networking, exactly as they would in a production environment. This is not an internal simulation — it is a real proof of the system working across the network.

---

Under the Hood — For the Technically Curious

For those who want to know how the gears turn, here is a look at the architecture we are building. Some of this is implemented in the current PoC, and some is planned for future stages.

The S2S Binary Protocol

Servers communicate through a compact binary protocol with an 8-byte header: a magic signature, version byte, message type, and 4-byte payload length. Six message types handle the entire lifecycle — CreateBufferEntity, Correction, TransferAuthority, DestroyBufferEntity, DeltaCorrection, and Handshake.

N-Server Grid Topology

The current PoC runs with two servers only, but the architecture is designed to support an N-server grid — sixteen or more in the future. Each server owns one cell in a grid (for example, a 4x4 grid of sixteen 1km zones) and knows the addresses of its neighbors at startup. Authority is deterministic: your position dictates which server owns you, with no central arbiter.

Ghost ID Partitioning

Each server is allocated a range of one million entity IDs, ensuring that no two servers ever produce a collision. When a shadow entity is created on a neighboring server, it receives a globally unique identifier that persists through every stage of the transfer.

Persistence Across Crashes

Beyond seamless transfer, Atherion ServerMesh includes a full persistence layer. Entity state is written to a tiered storage system — routine snapshots to Redis, critical events through a write-ahead log, and durable archival to PostgreSQL. If a server crashes mid-transfer, recovery is automatic. Your character and all its data are restored from the last confirmed state.

---

Where We Are — And Where We’re Headed

We want to be upfront: what you are seeing is a proof of concept — the skeleton of the system. The initial experiments work, and 535 passing tests confirm the foundation is solid. But we are at the beginning of the road.

Turning this system from a lab experiment into a production-ready product will take a long time — potentially years. There are significant challenges ahead:

• Edge Cases — Entities on a junction of four servers, rapid back-and-forth crossings, network degradation, and mass transfers during sieges
• Performance at Scale — Optimization for hundreds of players across dozens of servers
• Production Stability — Production-grade diagnostics and monitoring
• Beyond v1.0 — Dynamic topology, hierarchical server architecture for clusters of a thousand or more servers

This kind of system is extremely rare in the games industry. There is no off-the-shelf solution, no meaningful documentation, and no library to lean on. We are building it from scratch, and this PoC is just the beginning.

The road is long, but the foundation is laid. Every step from here brings us closer to a truly borderless world.