Why network motion stutters.
A remote player arrives as a stream of snapshots. A small buffer can turn those steps into motion—but smoothness has a cost.
Same movement. Three views.
Compare the server’s movement with a remote client that snaps to updates and one that interpolates between them.
The faint marker shows the server’s current position.
A 100 ms buffer spans one snapshot interval. The interpolated view is smooth, but follows the server by 200 ms.
Snapshots every 100 ms · target view delay 200 ms
A browser illustration of remote-player snapshot interpolation. Constant latency, no packet loss or jitter; no prediction. These are model settings, not measurements from a Unity game.
Try the tradeoff.
- Set the buffer to zero. The client holds its last received position until another snapshot arrives. A fast display cannot fill those gaps by itself.
- Bring the buffer to 100 ms at 10 snapshots per second. In this fixed-latency model, the client has two samples around its render time and can blend between them.
- Raise latency to 250 ms. The interpolated motion stays smooth, but falls further behind the server. Smooth movement does not mean a responsive connection.
- Lower the snapshot rate to 5 per second. Updates are now 200 ms apart. A 100 ms buffer runs out of future samples; increase it to 200 ms and compare the added delay.
What the client is doing.
Rendering the newest received snapshot exposes the network’s update cadence. Buffered interpolation renders a little further in the past, where two received snapshots can bracket the desired time. It blends their positions instead of guessing the next one.
renderTime = now - oneWayLatency - buffer
position = lerp(older.position, newer.position, alpha)Here, alpha is the fraction of time between those two snapshots. If the newer sample has not arrived, this example holds the last available position. In a real implementation, clock synchronization and the connection’s changing conditions also matter.
What to check in a Unity project.
Inspect snapshot cadence, arrival jitter, buffer underruns and the render timeline separately. Then test with realistic delay and packet loss. A larger buffer can hide gaps while adding visual delay; it is a tradeoff to measure, not a universal setting.
This technique explains remote-player presentation. It does not replace local-player prediction, reconciliation or lag compensation, and it is not a description of Photon Quantum’s deterministic simulation.
Go deeper.
Glenn Fiedler · Snapshot interpolation Unity Netcode 2.2 · Client-side interpolation Explore Unity Best PracticesBy Jack Mariani. Need help with a connected game? Explore Unity multiplayer development.