GONet

**GONet is the production-ready multiplayer networking solution for Unity with tight integration into the Unity architecture/runtime.** If you want multiplayer, you need GONet.

[Discord](https://discord.gg/NMeheRHQgd) | [Documentation](https://galoreinteractive.com/gonet) | [Tutorial Video](https://www.youtube.com/watch?v=fs1flIi35JM)

---

## NEW in v1.5 (October 2025)

### 🎯 RPC System

Production-grade Remote Procedure Calls with `async/await` support, server-side validation hooks (profanity filtering, authorization), persistent RPCs delivered to late-joiners, and deferred execution for components not ready yet.

```csharp

[ServerRpc]

async Task<RegistrationResult> RegisterPlayer(string playerName) { }

[ClientRpc]

void NotifyAllClients(string message) { }

[TargetRpc(validationMethod: nameof(ValidateChatAsync))]

async Task<RpcDeliveryReport> SendChat(string chatMessage) { }

```

### 🌍 Scene Management

Server-authoritative networked scene loading with Build Settings AND Unity Addressables support. Client scene change requests require server approval. Automatic late-joiner scene synchronization with extensibility hooks for validation.

```csharp

// Server loads scene

GONetMain.SceneManager.LoadSceneFromBuildSettings("BattleArena");

// Client requests scene change

GONetMain.SceneManager.RequestLoadScene("BattleArena");

```

### 📦 Unity Addressables Support

Full integration for scenes AND runtime prefab spawning. No Resources folder restrictions - organize prefabs anywhere. Efficient asset bundles via Addressables groups. Platform-specific asset variants. Zero configuration - auto-detected when package installed.

```csharp

// Addressables scene

GONetMain.SceneManager.LoadSceneFromAddressables("DynamicArena");

// Addressables prefabs (GONet handles loading)

GameObject.Instantiate(weaponPrefab); // Works exactly the same!

```

### ⚡ Adaptive Congestion Management

Automatic network pool scaling from 1,000 to 20,000 packets/tick based on demand. Handles burst spawning (100+ objects/frame) gracefully. Prevents "Ring buffer is full" errors.

### 🔧 Auto-Detection for Development

Zero configuration local testing - just hit Play! First instance starts as SERVER, additional instances connect as CLIENTS automatically. Works in Editor AND builds.

### 🛡️ Velocity-Augmented Sync

Massive bandwidth savings (90%+ reduction) for slow-moving/rotating objects. Eliminates micro-jitter for platforms, turrets, doors. Intelligent switching between velocity and absolute values.

### 🚀 GONetId Batch System

Pre-allocated ID ranges eliminate spawn latency for client-owned objects. Zero spawn delay with 200-1000 IDs pre-allocated per batch. Automatic refill at 50% threshold with rare edge-case "limbo mode" handling.

---

## Core Features

### Auto-Magical Data Sync

**Transform, Animator, Custom Fields** - Add `[GONetAutoMagicalSync]` attribute to any field and it syncs automatically. `GameObject.Instantiate()` works as expected - networked automatically. Value blending (interpolation/extrapolation) handles packet loss gracefully.

### RPC System

Three RPC types: `[ServerRpc]` (Client→Server), `[ClientRpc]` (Server→All clients), `[TargetRpc]` (Targeted delivery). Async/await support, validation hooks, persistent delivery to late-joiners.

### Event Bus System

Publish/Subscribe architecture with transient and persistent events. Custom event classes promote clean, decoupled architecture.

### Network Transport

UDP-only (unreliable+unordered fast, reliable+ordered RUDP). Encryption via customized Bouncy Castle Crypto API. Multi-level API: high-level convenience + low-level control when needed.

### Serialization & Compression

Custom bit-packing tighter than MessagePack. LZ4 compression for bulk data. Configurable quantization trades precision for bandwidth. Custom serializers via `IGONetAutoMagicalSync_CustomSerializer`.

### Platform Support

All managed C#, no native libraries. AOT compilation support (iOS). IL2CPP supported. Windows, Mac, Linux, iOS, Android, consoles (case-by-case). Unity 2022.3.62f3 LTS or later required.

### Late-Joining Client Support

New clients receive full world state on connect. Persistent events delivered automatically. Scene synchronization loads correct scene. GONetId assignments for scene-defined objects.

### Logging

Custom-built GONetLog system (no external dependencies). Multi-threaded, cross-platform. Console output in Editor, file output in builds (`Application.persistentDataPath/logs`). Configurable levels with comprehensive context (thread, timestamp, frame time).

---

## Coming Soon: GONet PRO

**Keep your eyes peeled!** GONet PRO is coming and it's going to blow your minds. We're talking game-changing features for production games at scale. Stay tuned to our Discord for announcements!

---

## Support

**What's Included:**

Comprehensive tutorials, examples, documentation. Active Discord community. Forum and email support. Regular updates and bug fixes. Full source code access.

**We're Here to Help You Succeed:**

Don't hesitate to reach out - we're happy to work with teams of all sizes to help you achieve success with your multiplayer game. Whether you're just getting started or shipping to production, we're here to support you.

**Need More?**

Professional support, custom feature development, architecture reviews, launch support, direct collaboration with the GONet team.

[Contact us](mailto:contactus@galoreinteractive.com) - Let's talk about your game!

---

## System Requirements

**Development:**

Unity 2022.3.62f3 LTS or later, .NET Framework or .NET Standard 2.1, 64-bit CPU with 4 cores (recommended)

**Runtime:**

Baseline Unity player requirements, 64-bit CPU (mobile: ARM64), Network connection (LAN or Internet)

---

## Third-Party Licenses

GONet includes the following open-source libraries (licenses included):

Bouncy Castle Crypto (Apache 2.0), Class Type Reference (MIT), MessagePack (MIT), MemoryPack (MIT), Netcode.IO.NET (MIT), Reliable Netcode (MIT)

See `Third-Party Notices.txt` in package for full details.

---

## Get Started Today

**Ready to build multiplayer?**

1. Import GONet package

2. Add GONet_GlobalContext prefab to your first scene

3. Add GONetParticipant to GameObjects

4. Build executable

5. Hit Play (for local play: first one in becomes server, the rest become clients)

**That's it!** Your game is now networked.

[Join our Discord](https://discord.gg/NMeheRHQgd) | [Read the Docs](https://galoreinteractive.com/gonet) | [Watch Tutorial](https://www.youtube.com/watch?v=fs1flIi35JM)

---

**GONet - Making Unity Multiplayer Simple, Powerful, and Production-Ready**

Release Notes

## What's New in v1.5

TLDR; full-time dev made this happen: RPCs (with in-game chat sample), Scene Management, Improved Physics, Higher Throughput, Excellent Slow Moving Object Precision, Addressables Support, Innumerable Improvements Everywhere

### 🚀 Major New Features

**RPC System** - Async/await support, optional server-side validation hooks, persistent delivery to late-joiners, deferred execution, all the RPC goodies you need ([ServerRpc], [ClientRpc] and the very flexible/capable [TargetRpc])

**Scene Management** - Server-authoritative networked scene loading with late-joiner sync. Supports Build Settings AND Unity Addressables.

```csharp

// Server loads scene

GONetMain.SceneManager.LoadSceneFromBuildSettings("NextLevel");

// Client requests scene change

GONetMain.SceneManager.RequestLoadScene("NextLevel");

```

**Unity Addressables Support** - Full integration for scenes AND runtime prefab spawning. No Resources folder restrictions. Zero configuration (auto-detected when package installed).

**Adaptive Congestion Management** - Auto-scaling packet pools (1,000 to 20,000 packets/tick). Handles burst spawning gracefully. Prevents "Ring buffer is full" errors.

**Auto-Detection for Development** - Zero configuration local testing! First instance starts as SERVER, additional instances connect as CLIENTS automatically.

**Velocity-Augmented Sync** - Massive bandwidth savings (90%+ reduction) for slow-moving/rotating objects. Eliminates micro-jitter for platforms, turrets, doors.

**GONetId Batch System** - Eliminates spawn latency with pre-allocated ID ranges (200-1000 IDs per batch). Zero server round-trip for client spawning.

**Sync Bundle Deferral System** - Handles race conditions where sync bundles arrive before GONetParticipant ready. Default DROP-FIRST (industry standard). Optional queue-and-retry for turn-based games.

### Other Features

- **GONetId Reuse Protection:** Configurable delay before ID reuse (default: 5 seconds)

- **Message Flow Logging:** Separate log file for comprehensive debugging

- **UI Components:** GONetStatusUI, Scene Selection UI, Exit Button UI

- **Physics Sync Improvements:** Sync after all FixedUpdate and physics processing

---

## Breaking Changes

**None!** GONet v1.5 maintains full backward compatibility with v1.4.1. All existing code continues to work without modification.

---

## Migration Guide (v1.4.1 → v1.5)

### Quick Migration (Zero Code Changes)

1. **Update Unity:** Upgrade to Unity 2022.3.62f3 LTS or later

2. **Import GONet v1.5:** Delete `Assets/GONet/` folder, import new package

3. **Recompile:** Unity auto-compiles, code generation runs automatically

4. **Test:** Play scene - first instance becomes server automatically

### Optional Configuration

Review new settings in GONetGlobal Inspector:

- `client_GONetIdBatchSize` (default: 200, range: 100-1000)

- `enableAdaptivePoolScaling` (default: true)

- `deferSyncBundlesWaitingForGONetReady` (default: false, enable for turn-based)

- `enableAutoRoleDetection` (default: true, disable for manual startup)

---

## Bug Fixes

**Critical Fixes:**

- Late-Joiner GONetId Sync - Scene-defined objects now receive GONetIds proactively

- Spawn Data Provider Race Condition - IGONetSpawnDataProvider guaranteed to run before OnGONetReady

- Duplicate GONetGlobal Handling - Improved singleton pattern (DestroyImmediate)

- Time Sync Improvements - Separate pre/post-load aggressive sync

- Deferred RPC Execution - RPCs queued when components not ready

**Robustness Improvements:**

- Addressables loading stability (handle cleanup, exceptions)

- Scene unload cleanup (GONetId tracking, buffered assignments)

- Pool safety (byte arrays always returned in all code paths)

- Physics sync timing (captures final state after all processing)

---

## Performance Optimizations

- Reduced Allocations - Object pooling for network messages and byte arrays

- Code Generation - Pure C# generators (debuggable, faster generation)

- Aggressive Inlining - Hot paths optimized with `[MethodImpl(AggressiveInlining)]`

- Span<T> and Memory<T> - Zero-copy operations in serialization

---

## Testing

**Scenarios:** 2-8 player co-op, 50-100 player battle royale, rapid spawning (100+ objects/sec), late-joiner synchronization, high latency (200ms+ RTT), packet loss (10%+)

**Platforms:** Windows, Mac, Linux, iOS, Android

**Unity Versions:** 2022.3.62f3 LTS (minimum), 2022.3.50f1 LTS, 2023.2 LTS, Unity 6

---

## Installation

GONet v1.5 compiles cleanly after import. If errors occur:

1. Verify "Allow unsafe Code" enabled (Edit → Project Settings → Player)

2. Verify API Compatibility Level is .NET Framework or .NET Standard 2.1

3. Check Console for specific error messages

**NewtonSoft JSON:** May be required. Install via Package Manager: `com.unity.nuget.newtonsoft-json`

---

## Support

**Get Help:**

- **Discord:** https://discord.gg/NMeheRHQgd (fastest response)

- **Email:** contactus@galoreinteractive.com

- **Website:** https://galoreinteractive.com/gonet

**Resources:**

- Setup Guide (included in package)

- API Documentation (website)

- Tutorial Video: https://www.youtube.com/watch?v=fs1flIi35JM

---

Thank you for using GONet! Please reach out via Discord or email if you encounter any issues. We're committed to ensuring GONet works seamlessly for your multiplayer games.

# GONet v1.5b5 Patch Release Notes

- Improvements:

--CPU utilization drastically reduced when no GONet work to do

--socket receive now fully async (vs polling)