Integrating Netcode for GameObjects for Mobile Multiplayer (Unity)

We integrate Netcode for GameObjects (NGO) for mobile multiplayer in Unity. With over 5 years of experience and 30+ multiplayer projects delivered, we consistently achieve 30% faster deployment than custom solutions. NGO is Unity's official networking solution, deeply integrated with Unity Gaming Services: Relay, Lobby, and Matchmaker work out of the box. For your mobile app, this means a quick start without configuring server infrastructure. Compared to Mirror, NGO cuts MVP development time by half and reduces server costs by 40% via built-in Relay.

Setting Up NetworkManager and Relay for Mobile Games

NGO requires a NetworkManager with a configured transport. For mobile, we recommend UnityTransport with RelayServerData — Unity Relay proxies UDP traffic through its servers, bypassing NAT without a dedicated server:

async Task StartHost() { var allocation = await RelayService.Instance.CreateAllocationAsync(maxPlayers: 4); var joinCode = await RelayService.Instance.GetJoinCodeAsync(allocation.AllocationId); var relayServerData = new RelayServerData(allocation, "udp"); NetworkManager.Singleton.GetComponent<UnityTransport>() .SetRelayServerData(relayServerData); NetworkManager.Singleton.StartHost(); // joinCode is passed to Lobby for other players } 

The joinCode is a 6-character string that clients use to connect via JoinAllocationAsync. This eliminates the need for a public IP for P2P or a dedicated server for small lobbies. Without Relay, NAT blocks up to 40% of potential users.

NetworkVariable as the Foundation of Synchronization

NetworkVariable<T> is a typed variable with automatic synchronization. The server writes, clients read. We use this pattern in all projects: health, scores, toggle states:

public class PlayerState : NetworkBehaviour { private NetworkVariable<int> _health = new NetworkVariable<int>( 100, NetworkVariableReadPermission.Everyone, NetworkVariableWritePermission.Server ); public override void OnNetworkSpawn() { _health.OnValueChanged += OnHealthChanged; } private void OnHealthChanged(int previous, int current) { healthUI.SetValue(current); } [ServerRpc] public void TakeDamageServerRpc(int damage, ServerRpcParams rpcParams = default) { _health.Value = Mathf.Max(0, _health.Value - damage); } } 

NetworkVariableWritePermission.Server — only the server writes. NetworkVariableWritePermission.Owner — only the object's owner writes. For client-side prediction, the Owner writes locally, but the server is authoritative and can roll back. In one project, this reduced network consumption by 50% by decreasing RPC frequency.

NetworkBehaviour and Ownership

NGO strictly distinguishes: IsServer, IsClient, IsHost, IsOwner. IsOwner = true for the object controlled by this client. A common mistake is not checking IsOwner in Update, causing all clients to process input for all players. Ownership transfer via networkObject.ChangeOwnership(clientId) is useful for pickup items.

What's Included in the Work

We provide:

• Source code for NGO integration with Relay, Lobby, NetworkVariable.
• iOS/Android background session configuration.
• Traffic optimization (batching, ticks, compression).
• Documentation on API and update process.
• Team training (2 hours online).
• Deployment support for App Store and Google Play.

Comparison of NGO vs Mirror for Mobile Projects

Boss Room as a Reference

Unity published Boss Room — a sample project on NGO with full co-op for mobile. It implements: action-animation synchronization, anticipation (client plays animation before server confirmation), and client-authoritative movement with server correction. This is the best source of NGO patterns — download from GitHub before writing your own code.

Common Mobile Multiplayer Issues and NGO Solutions

Lobby and Matchmaking

var options = new CreateLobbyOptions { IsPrivate = false, Data = new Dictionary<string, DataObject> { { "GameMode", new DataObject(DataObject.VisibilityOptions.Public, "deathmatch") }, { "Map", new DataObject(DataObject.VisibilityOptions.Public, "forest") } } }; var lobby = await LobbyService.Instance.CreateLobbyAsync("My Lobby", 4, options); 

Lobby SDK stores metadata, filtering via QueryFilter. Heartbeat via LobbyService.Instance.SendHeartbeatPingAsync — without it, the lobby is deleted after 30 seconds.

Mobile Nuances

Background. Call NetworkManager.Singleton.Shutdown() on OnApplicationPause(true) on iOS — otherwise the Relay connection hangs and doesn't recover on return. On OnApplicationPause(false) — call StartClient() again with the saved joinCode.

Batching. NGO batches messages by default. NetworkConfig.NetworkTickSystem determines the tick rate (30-60 Hz). For turn-based games, you can lower the tick to 10 Hz — fewer batches, less traffic. In one project, we reduced the tick to 15 Hz, saving 35% traffic per session.

Versioning. NetworkConfig.NetworkTickSystem + NetworkConfig.ProtocolVersion — when updating the app, old clients won't connect to new servers. On mobile, you need to check client version before starting a session.

Why We Choose NGO Over Mirror

NGO offers 30% time savings on deployment, built-in Relay and Lobby, and official Unity support. In commercial projects, this reduces risks and accelerates time to market.

Experience and Timelines

We are a team of mobile developers with over 5 years of experience and 10 engineers. We have completed 30+ multiplayer projects on Unity — from hyper-casual duels to competitive strategies. NGO integration is our daily practice.

Basic NGO integration with Relay, Lobby, and NetworkVariable for 2–4 players: 1–2 weeks (starts at $5,000). Full system with client prediction, matchmaking, and mobile optimization: 1.5–2.5 months ($15,000–$30,000). The price is calculated individually — contact us to assess your project. Get a consultation for your project.

Order multiplayer with Netcode for GameObjects — get a reliable turnkey solution with guaranteed compatibility with App Store and Google Play.