Reconcile.

This demo drives a C++ World controller compiled to WebAssembly. It ticks a deterministic fixed-point simulation: the client predicts, the server runs authority, and the channel between them loses packets, reorders them, adds jitter. The cyan pawn you see is the client's best guess; the magenta one is where the server says it actually is. The strip under the arena is the acknowledgement history — which guesses the server has confirmed, and when.

It's modeled on how Unreal Engine handles prediction and reconciliation — the prediction-key and server-reconciliation ideas behind FPredictionKey, FScopedPredictionWindow, and Character Movement's save-and-replay — rebuilt from scratch in C++20 for the browser. Every input the client sends carries a prediction key, a little ticket; the server processes it and sends that key's ack back as confirmation the guess for that moment held. Until the ack returns, the client is only predicting — and how it books those acks is the whole game. Get the bookkeeping wrong and it quietly believes things the server never confirmed.

The C++ World maintains two pawn states in the same tick: a client integrating player inputs immediately (prediction), and a server receiving those inputs over a simulated channel (authority). Every tick the gap between them is the visible effect of network latency.

The channel is everything you set with the top sliders. RTT is the round-trip latency the prediction has to cover; Loss drops a share of packets outright; Jitter scatters delivery times; Reorder and Dup let packets arrive out of order or twice; Bandwidth caps bytes per tick to model a congested uplink; Tick sets the simulation rate. Push any of them and you make the prediction harder — the distance between the two pawns is the result.

The ack model decides how the client books those confirmations, and it's the cycle button on the demo. In FastArray mode each prediction key is tracked independently — a key goes authoritative only when its own ack is received, mirroring Unreal's FReplicatedPredictionKeyMap semantics exactly; correct under loss, but its resident state grows with outstanding keys. In HighWater mode the client keeps only the highest confirmed key and assumes everything below it is safe — cheaper, at a flat 2 bytes, but wrong under packet loss: a dropped ack leaves a gap the high-water mark silently bridges, mis-confirming keys that were never acknowledged (turn Loss up here and the timeline bleeds red). In Range mode the ack carries a cumulative front plus a 32-key selective-ack bitfield — the same idea as TCP SACK and QUIC ack-ranges — so out-of-order confirmations are recorded precisely and a dropped ack self-heals on the next one: correct like FastArray, but at a constant ~7 bytes instead of a per-key list. Out-of-order keys light violet, then collapse into the front when the gap fills. The pawn moves identically in all three — only the bookkeeping, and the Ack state cost, changes.

The net mode swaps the reconciliation policy so you can compare approaches: Real (predict + reconcile), NaiveNoReconcile (predict but never correct — the rubber-band effect), and NaiveNoPredict (wait for the server ack — the laggy effect). All three run the same deterministic fixed-point sim; only the policy changes.

The timeline under the arena is the prediction-key history. Five lanes track every input's fate — issued, acked, replayed, mis-confirmed, out-of-order — stacked over a divergence track that plots the client/server gap tick by tick. Drag across it to scrub back through the buffer and watch a past reconcile frame by frame; drag out a wider selection and every metric below recomputes over just that window, so you can read ack rate and peak divergence on one bad burst instead of the whole run.

Input delay is the last lever. Normally the client applies your input on the tick you press it and the server applies it later — exactly the gap the prediction papers over. Raise the delay and the client holds each input a few ticks before applying it, so both sides act on the same tick and lock together: divergence drops toward zero. The cost is felt lag — a faint zero-delay command ghost marks where an instant-response pawn would be, and the distance back to it is what you traded away. Unreal runs at zero delay and predicts the gap; holding inputs to erase it is the rollback-netcode trick instead.