Multiplayer & game networking

One process owns the state and steps it at a fixed tick; clients send inputs and show returned snapshots, so a lying client only affects its own inputs.

Every peer runs the same deterministic simulation and exchanges only inputs; bandwidth ignores unit count, at the cost of input delay.

Bit-identical simulation math across CPUs, compilers and builds: integer fixed-point formats, the float traps (FMA, x87, fast-math, libm), deterministic trig, sqrt and RNG.

The client applies its own inputs immediately, then on each server state rewinds to it and replays unacknowledged inputs (reconciliation).

Render remote entities a fixed delay in the past, blending the two buffered snapshots around that time: ~2 snapshot intervals of latency buy smooth motion.

The server rewinds other players' hitboxes to the moment the shooter saw them, so hits land where the shooter aimed despite latency and interpolation delay.

Run the game immediately on predicted remote inputs; when real inputs arrive and differ, restore a saved state and re-simulate to the present (GGPO).

Encode each client's snapshot as the difference from the last snapshot that client acknowledged, so unchanged entities and fields cost zero to a few bits.

Store floats as small fixed-point integers sized to the precision needed (bounded positions, smallest-three quaternions), cutting size 2-4x before any delta coding.

Send each client only the entities relevant to it (spatial area of interest, visibility, team), ordered by priority accumulators to fit a per-packet byte budget.

A bit writer and reader over a byte buffer that stores each field in exactly the bits its range needs: booleans in 1 bit, bounded integers in ceil(log2(span+1)) bits.

Transport over UDP: each packet carries a sequence number, an ack and a 32-bit ack history; only chosen messages are made reliable.

One number per competitor, moved by K × (actual − expected score) after each pairwise result; expected score is logistic in the rating difference.

Rating plus rating deviation (RD) and volatility per player, so new or inactive players move fast and established ones move slowly.

Pair waiting participants into fair matches by rating and latency, widening tolerances the longer each ticket waits, so queues stay short at the edges of the skill curve.

Each round pairs competitors with equal scores, never twice and with balanced sides; a bye covers odd counts, and about log2(N) rounds expose a winner.