Skip to content

Lattice Networking Suite

An engine-agnostic multiplayer networking suite built around a single high-performance C++20 core with a stable C ABI: client-side prediction, server reconciliation/rollback, snapshot interpolation, and lag compensation over a custom UDP transport with its own relay. The same shared simulation code compiles into both the dedicated server and the client — so any client can become a P2P host with byte-for-byte identical logic. Write once, target both.

Get started Migrating from Fusion API reference Architecture

What is Lattice?

One implementation of transport, replication, prediction/rollback, and simulation, exposed through a flat extern "C" surface that every engine binding (Unity / Unreal / Godot / web) and the managed WASM host calls. Around it sit a small set of .NET control-plane services for authentication, matchmaking/fleet orchestration, social, the developer console, and analytics.

  • Start here

    Register a game, integrate the SDK, then branch: self-hosted / P2P (native) or managed WASM hosting. Both share one source.

    Getting started

  • Migrating from Fusion

    Porting a Unity game off Photon Fusion 2.1? The full journey — Assess → Convert → Port → Check parity — with a codemod, the KCC addon, and a feature parity cookbook.

    Migrating from Fusion

  • Guides & tools

    Task-oriented guides and the tooling around the core: the Fusion migration journey and the lattice-gamedev Claude Code skill that teaches an AI assistant the real API.

    Guides & tools

  • API reference

    The full, current C ABI (268 entry points) grouped by area — including anti-cheat, async jobs, mediated web fetch, the embedded store, and custom events.

    API reference

  • Control plane

    The HTTP + WebSocket APIs for auth, director (matchmaking/fleet), social, console, and analytics — plus the developer portal.

    Control plane

  • Architecture (design docs)

    The ten design documents — from vision and high-level design through the netcode low-level design and the WASM hosting model.

    Architecture

Coming from Photon Fusion?

There's a dedicated journey for porting a Unity game off Fusion 2.1 — the fusion2lattice codemod, the CharacterMotor/KCC addon, a deep KCC + physics port, and a feature-by-feature parity cookbook, all tied together as Assess → Convert → Port → Check parity. Start the migration journey →

The three locked decisions

  1. C++20 core with a stable C ABI + idiomatic per-engine bindings. One implementation of transport, replication, prediction/rollback, and simulation; thin wrappers expose it natively to each engine.
  2. Both authority models are first-class. Server/host-authoritative (prediction + reconciliation/rollback) and shared/distributed authority (per-object ownership, authority transfer, eventual consistency) are supported by the same engine and data model.
  3. Custom UDP transport + our own relay, with an optional QUIC/WebTransport backend for web. Lattice owns its reliability/ordering channels, congestion control, fragmentation, and encryption, plus STUN-style discovery, UDP hole punching, and a TURN-like relay for P2P fallback.

How it fits together

flowchart TB
  subgraph dev["Author once"]
    SIM["game_sim.cpp — your deterministic sim<br/>(networked types, RPCs, tick logic)"]
  end
  SIM -->|native + liblattice| SELF["Self-hosted / P2P<br/>(trusted, your fleet)"]
  SIM -->|wasm32, sandboxed| MAN["Managed WASM hosting<br/>(untrusted, our fleet)"]
  subgraph core["liblattice — the C++20 core (C ABI)"]
    T[transport + reliability]
    R[replication + prediction/rollback]
    A[anti-cheat, jobs, fetch, store, events]
  end
  SELF --> core
  MAN --> core
  subgraph cp["Control plane (.NET)"]
    AU[auth] --- DI[director] --- SO[social] --- CO[console] --- AN[analytics] --- PO[portal]
  end
  CLIENT["Engine client<br/>(Unity / Unreal / Godot / web)"] -->|"C ABI session"| core
  CLIENT -->|"login / matchmake / social"| cp

All product and component names ("Lattice", lattice-core, etc.) are working codenames and may be renamed before release without changing any of the architecture described here.