100 ms ping doesn't mean a 100 ms game response: notes from a small browser MMO
retained text
I'm running a small browser MMO with a Go server using WebSocket and MessagePack. I wrote up how its simulation, network updates, and client rendering fit together, because the ping number only covers part of the wait.
The server updates the world every 50 ms (20 Hz), but regular shared-state snapshots go out every 250 ms (4 Hz). Combat events have a separate 50 ms batching interval. Simulation and sending state are separate schedules: lowering the snapshot rate saves traffic, but also increases the time between authoritative state updates reaching other clients.
A simplified timing example:
0 ms: client sends world:goal, asking to move toward x = 200
50 ms: request arrives, just missing the processing opportunity
100 ms: next simulation tick handles it
250 ms: a scheduled snapshot includes current x = 120
300 ms: the snapshot reaches the client
This assumes 50 ms each way and that the request just missed a tick. The 300 ms is an example of timer alignment, not a measured average. The character is still traveling toward 200 when the snapshot is taken, so its current position is only 120.
The local player doesn't have to wait for that response to see movement. Client-side prediction can show their own input immediately and reconcile later. For remote entities, interpolation connects received positions, usually with a display delay. Brief extrapolation can cover a gap, but needs a cutoff and correction when the server disagrees. These techniques improve presentation without reducing the network delay itself.
The other part is outgoing traffic. The game has been using around 5 TB per month, mostly server-to-player traffic. CPU and RAM aren't the only things I need to consider when choosing hosting.
For a deliberately simple fanout calculation, assume 100 bytes of state per player, sent to everyone in one area four times a second:
10 players × 10 recipients × 100 bytes × 4 = 40,000 bytes/s
100 players × 100 recipients × 100 bytes × 4 = 4,000,000 bytes/s
That's 10× the players and 100× the outgoing bytes under those assumptions. It excludes compression and protocol overhead; splitting players across zones or using interest management changes the result. Serializing once doesn't remove the cost of sending the result to many connections.
One small reduction in my implementation is separating monster display metadata from recurring position/health state. The client doesn't need the monster's name and appearance repeated every time it moves. Metadata is resent when necessary. This isn't delta replication: recurring snapshots still include the zone's monster-state list.
I'm self-taught, so this is an implementation example rather than a recommended setup for every multiplayer game. Some manual movement is calculated on the client and validated by the server; combat outcomes remain server-authoritative.
For developers running similar games, how are you balancing snapshot frequency, interpolation delay, and outbound traffic? I'd also appreciate corrections to the explanation.
I develop MODAK Online; the illustrated version is on my blog: [https://lim.sh/mmorpg-lag-and-server-cost](https://lim.sh/mmorpg-lag-and-server-cost) (English available in the language menu).document fetched 2026-10-31 00:26 · canonical https://reddit.com/r/gamedev/comments/1xjaza6/100_ms_ping_doesnt_mean_a_100_ms_game_response