Engine-agnostic multiplayer netcode — and the platform to run it.

using Lattice;

// A networked player: predicted locally, reconciled against the server.
public class Player : NetworkBehaviour
{
    // Replicated, delta-compressed, quantized on the wire.
    [Networked] public Vector3 Position { get; set; }
    [Networked, OnChanged(nameof(OnHealthChanged))]
    public int Health { get; set; }

    // Runs every fixed tick (60 Hz). Prediction + rollback are automatic.
    public override void OnNetworkTick()
    {
        if (!HasInputAuthority) return;
        Position += ReadInput<MoveInput>().Move * Runner.TickDelta;
    }

    // Server-authoritative RPC, routed over a reliable channel.
    [Rpc(LatticeRpcTarget.Server)]
    public void RpcFire(Vector3 dir) => SpawnProjectile(dir);
}

// The same logic compiles into the dedicated server AND the P2P host.
struct Player {
    Vec3 position;   // replicated & quantized
    int32_t health;  // delta-compressed against last ack
};

// Fixed 60 Hz tick — authoritative on server, predicted on the owning client.
void player_tick(Player* p, const MoveInput* in, float dt) {
    p->position = vec3_add(p->position, vec3_scale(in->move, dt));
}

// Register the type so replication knows its POD layout.
lattice_register_type(runner, "Player", sizeof(Player), &player_tick);