Skip to content
TheChatArchiveThe Chat Archive
o4-mini-2025-04-16· OpenAIHugging Face LMArena Human Preference 140K

I want to build a real-time multiplayer game using WebGL that works in the browser. What…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.0-flash-001’s answer.
  1. User

    I want to build a real-time multiplayer game using WebGL that works in the browser. What should I do for state synchronization over the network?

  2. Assistant

    Here’s a high‐level recipe for real‑time state sync in a browser‑based WebGL multiplayer game:

    1. Pick your network architecture
      • Authoritative server (most common for action games)
      – Clients send “inputs” (e.g. key presses)
      – Server runs the authoritative game loop at a fixed tick rate (e.g. 20–60 Hz)
      – Server broadcasts periodic snapshots (full or delta) of the world state
      • Peer‑to‑peer (WebRTC DataChannels)
      – All peers exchange inputs or snapshots directly
      – Harder to secure and harder to handle NAT/TURN, but lower server cost

    2. Represent and serialize your state
      • Snapshot = list of entity states { id, position, velocity, … }
      • Delta compression: send only what’s changed since last acknowledged tick
      • Binary over JSON: consider Protocol Buffers, msgpack or a custom TypedArray layout for minimal bandwidth

    3. Client‑side prediction + reconciliation

      1. Client buffers local inputs (with a monotonically increasing sequence number).
      2. Immediately apply these inputs to the local simulation so movement “feels” instant.
      3. Server processes the same inputs, sends back authoritative state tagged with that input seq.
      4. Client receives server snapshot, compares server position to its own predicted.
      5. If there’s a discrepancy, “rewind” state to that input seq, reapply all buffered inputs, and smoothly correct.
    4. Interpolation & smoothing
      • Don’t render the last‐received server snapshot directly—buffer it by ~100–200 ms.
      • At render time, linearly interpolate between two buffered snapshots so movement is smooth despite jitter.
      • On rare packet loss or big lag spikes, you can extrapolate a bit but clamp to avoid teleporting.

    5. Tick loop & timing
      • Server: fixed‐timestep loop (e.g. 20 ms) → process physics & AI → broadcast snapshot.
      • Client:
      – Network receive handler → push snapshot into your ring buffer
      – requestAnimationFrame() → read interpolated state from buffer → render

    6. Entity authority & ownership
      • Server “owns” all entities—only its state is final.
      • For faster local response, client “owns” its player input locally (only for prediction).
      • Projectiles, pickups, NPCs: server‐only.

    7. NAT / Firewall (for P2P)
      • Use a STUN/TURN service (e.g. Google STUN, or deploy your own coturn)
      • Libraries like simple‑peer or PeerJS simplify WebRTC negotiation.

    8. Useful libraries & frameworks
      • Socket.IO (WebSockets + fallbacks) for ease of use
      • Colyseus (open‑source authoritative server + JS client)
      • PlayCanvas or Three.js for WebGL + ECS integration
      • Protocol Buffers / flatbuffers for binary packing

    9. Putting it all together: a minimal flow

      Client side (pseudo‐JS): const socket = new WebSocket("wss://yourgame.server"); let inputSeq = 0, pendingInputs = [], stateBuffer = []; let renderDelay = 100; // ms

      // 1. Client sends input function onUserInput(input) { input.seq = inputSeq++; pendingInputs.push(input); socket.send(encode("input", input)); simulateLocal(input); // client prediction }

      // 2. Receive server snapshot socket.onmessage = ({data}) => { let { tick, entities, lastProcessedInput } = decode(data); // Store for interpolation stateBuffer.push({ tick, entities, timestamp: performance.now() }); // Reconciliation reconcile(entities.player, lastProcessedInput); // Drop old buffer entries if (stateBuffer.length > 20) stateBuffer.shift(); };

      // 3. Rendering loop function render() { requestAnimationFrame(render); const now = performance.now() - renderDelay; // Find two snapshots around ‘now’ and interpolate const [a,b] = findSnapshots(stateBuffer, now); const t = (now - a.timestamp)/(b.timestamp - a.timestamp); const interpState = lerpEntityStates(a.entities, b.entities, t); drawScene(interpState); } render();

      Server side (Node.js + ws): const wss = new WebSocket.Server({ port: 8080 }); let tick = 0, clients = []; let worldState = initWorld();

      // 1. Collect inputs wss.on('connection', ws => { ws.on('message', msg => { const { type, input } = decode(msg); if (type === "input") { // enqueue by client ID worldState.enqueueInput(ws.id, input); } }); clients.push(ws); });

      // 2. Fixed‐timestep game loop setInterval(() => { tick++; worldState.applyAllInputs(); worldState.stepPhysics(); // Build delta or full snapshot const snapshot = worldState.serializeDelta(); // Send to everyone for (let ws of clients) { ws.send(encode("snapshot", { tick, entities: snapshot, lastProcessedInput: worldState.lastInputSeq[ws.id] })); } }, 50); // 20 Hz

    That’s the core! Once you wire up:
    • WebGL renderer (Three.js/PlayCanvas) for visuals
    • Fixed‐timestep server loop for authoritative sim
    • Client prediction + server reconciliation
    • Interpolation buffering

    …you’ll have a rock‑solid, low‐latency real‑time multiplayer foundation. 🚀

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.