GONet v1.5b5

GONet v1.5b5 Patch Release Notes

• Improvements:
  --CPU utilization drastically reduced when no GONet work to do
  --socket receive now fully async (vs polling)

GONet v1.5b

GONet v1.5 Release Notes

Release Date: October 2025
Previous Version: v1.4.1 (commit a128fcf)
Unity Version: 2022.3.62f3 LTS or later (minimum required version)

---

Overview

GONet v1.5 represents a major step forward in production readiness and developer experience. This release focuses on eliminating common pain points, improving performance at scale, and adding enterprise-grade features that shipped games require.

Key Themes

• 🚀 Zero-Latency Client Spawning - GONetId Batch System eliminates server round-trip
• 🎯 Modern RPC System - Async/await, validation, persistent delivery
• 🌍 Networked Scene Management - Server-authoritative with late-joiner sync
• 📦 Unity Addressables Support - Scenes AND runtime prefab spawning
• ⚡ Adaptive Congestion Management - Auto-scaling for varying load
• 🛡️ Race Condition Hardening - OnGONetReady deferral system
• 🔧 Developer Experience - Auto-detection, better logging, UI improvements

---

Major New Features

1. GONetId Batch System

Problem Solved: Client-spawned objects previously required server round-trip to assign GONetId, causing visible spawn delay (50-150ms depending on latency).

Solution: Pre-allocated GONetId batches eliminate spawn latency entirely.

How It Works:

• Client requests batch of 200-1000 IDs from server at connection time
• Server allocates raw ID range and sends to client
• Client spawns objects instantly using batch IDs, server assumes authority
• When 50% consumed, client requests next batch in background
• Rare edge case: "Limbo mode" handles batch exhaustion gracefully

Configuration:

// GONetGlobal component - Inspector
client_GONetIdBatchSize = 200; // Default: 200 IDs per batch (range: 100-1000)

// API - Check if object is in limbo
if (participant.client_isInLimbo) {
    // Waiting for batch to arrive
}

Limbo Mode Options:

• ReturnFailure - Spawn fails, returns null (safe default)
• InstantiateInLimbo - Create "ghost" object until batch arrives (seamless UX)
• BlockUntilBatchArrives - Wait synchronously (NOT RECOMMENDED - frame stutter)

Benefits:

• Zero perceived spawn delay for players
• Instant projectile/effect spawning
• Scales to 100+ spawns/sec per client
• Graceful degradation if batch exhausted

Files:

• GONet.cs - Batch allocation logic
• GONetParticipant.cs - Limbo state tracking
• GONetGlobal.cs - Configuration options

---

2. Enhanced RPC System

Problem Solved: Previous RPC system lacked validation hooks, async support, and late-joiner delivery.

Solution: Production-grade RPC system with modern C# features.

New Attributes:

[ServerRpc]  // Client → Server (optionally relay to other clients)
async Task<TResponse> RequestAction(int param) { }

[ClientRpc]  // Server → All clients
void NotifyAllClients(string message) { }

[TargetRpc]  // Server → Specific client(s)
void SendToPlayer(ushort targetId, string data) { }

New Features:

Async/Await Support:

var response = await CallRpcAsync<ChatValidationResult>(
    nameof(SendChatMessage),
    message
);
if (response.Approved) {
    // Message was clean
}

Server-Side Validation:

[ServerRpc(validationMethod: nameof(ValidateChatMessage))]
void SendChatMessage(string message) { }

RpcValidationResult ValidateChatMessage(ref string message) {
    if (ContainsProfanity(message)) {
        var result = RpcValidationResult.CreatePreAllocated(0);
        result.DenyAll("Profanity detected");
        return result;
    }
    // ... filter profanity, modify message ...
    var okResult = RpcValidationResult.CreatePreAllocated(1);
    okResult.AllowAll();
    return okResult;
}

Persistent RPCs:

[ServerRpc(IsPersistent = true)]
void AnnounceMatchStart(string mapName) {
    // Late-joiners receive this RPC automatically
}

Deferred Execution:

• RPCs gracefully handle components not ready (IGONetReady not yet fired)
• Queued and retried automatically when component becomes ready
• Prevents "NullReferenceException" during rapid spawning

Delivery Reports:

• Async RPCs return RpcDeliveryReport
• Success/failure status
• Validation results
• Target delivery confirmation

Files:

• GONetEventBus_Rpc.cs - RPC implementation (~366KB)
• GONetRpcs.cs - RPC attributes
• GONetMain.cs - Async RPC support

---

3. Scene Management System

Problem Solved: No built-in networked scene loading, late-joiners didn't sync scenes.

Solution: Server-authoritative scene management with extensibility hooks.

Core API:

// SERVER: Load scene directly
GONetMain.SceneManager.LoadSceneFromBuildSettings("BattleArena", LoadSceneMode.Single);

// SERVER: Load from Addressables
GONetMain.SceneManager.LoadSceneFromAddressables("DynamicLevel", LoadSceneMode.Additive);

// CLIENT: Request scene change (requires server approval)
GONetMain.SceneManager.RequestLoadScene("BattleArena");

// SERVER: Unload additive scene
GONetMain.SceneManager.UnloadScene("DynamicLevel");

Validation Hooks:

// Server-side validation (deny unauthorized requests)
GONetMain.SceneManager.OnValidateSceneLoad += (sceneName, mode, requestingClient) => {
    // Return false to deny request
    if (sceneName == "SecretLevel" && !IsAdmin(requestingClient)) {
        return false; // Denied
    }
    return true; // Approved
};

// Async approval (show server UI confirmation)
GONetMain.SceneManager.RequiresAsyncApproval = true;
GONetMain.SceneManager.OnValidateSceneLoad += (sceneName, mode, requestingClient) => {
    ShowApprovalUI(sceneName, requestingClient);
    return true; // Will send follow-on response after approval
};

Late-Joiner Synchronization:

• Late-joiners automatically load server's current scene
• Scene-defined object GONetIds assigned proactively
• Custom initialization data sent with scene (IGONetSyncdBehaviourInitializer)
• Buffered assignments if scene not loaded yet (no race conditions)

Features:

• Build Settings AND Unity Addressables support
• Single or Additive loading modes
• Extensibility hooks for validation and processing
• Progress tracking and coroutine helpers
• State queries (IsSceneLoading, GetLoadingScenes, etc.)

Files:

• GONetSceneManager.cs - Scene management implementation (~1,187 lines)
• GONetGlobal.cs - Scene load RPC handlers
• SceneLoadEvent.cs / SceneUnloadEvent.cs - Persistent events

---

4. Unity Addressables Support

Problem Solved: GONet previously only supported Unity Resources for prefab loading, limiting asset management flexibility and requiring all networked prefabs to be in Resources folders.

Solution: Full Unity Addressables integration for both scene loading AND runtime prefab spawning.

What's Supported:

Addressables Scene Loading:

// Load Addressables scene (server)
GONetMain.SceneManager.LoadSceneFromAddressables("DynamicArena", LoadSceneMode.Additive);

// Unload Addressables scene
GONetMain.SceneManager.UnloadAddressablesScene("DynamicArena");

Addressables Prefab Spawning:

// Prefab paths now support addressables:// protocol
// In DesignTimeMetadata.json:
{
  "PrefabLocation": "addressables://Weapons/MagicSword",
  "CodeGenerationId": 42
}

// Spawn works exactly the same (GONet handles Addressables loading internally)
GameObject.Instantiate(magicSwordPrefab);
// OR
GONetMain.Client_InstantiateToBeRemotelyControlledByMe(magicSwordPrefab, pos, rot);

Benefits:

For Scene Management:

• Load scenes dynamically without including in Build Settings
• Organize scene assets with Addressables groups
• Platform-specific scene variants

For Prefab Spawning:

• No more Resources folder restrictions
• Organize prefabs anywhere in project
• Use Addressables groups for efficient asset bundles
• Platform-specific asset variants
• Cleaner project organization

Configuration:

• #if ADDRESSABLES_AVAILABLE automatically detected when Unity Addressables package installed
• No manual configuration needed - works out of the box
• Prefab metadata automatically handles addressables:// vs resources:// paths

Metadata Format:

{
  "UnityGUID": "abc123...",
  "CodeGenerationId": 42,
  "PrefabLocation": "addressables://Characters/Heroes/Wizard",
  "ComponentTypeNames": [...]
}

How It Works:

1. Scenes: GONetSceneManager uses Addressables.LoadSceneAsync() and Addressables.UnloadSceneAsync()
2. Prefabs: GONetSpawnSupport_Runtime detects addressables:// prefix and uses Addressables.LoadAssetAsync<GameObject>()
3. Caching: Addressables scene handles cached internally, prefabs managed by Unity's Addressables system
4. Compatibility: Works alongside Resources-based prefabs (mix and match freely)

Migration Path:

• Existing Resources-based projects: No changes needed (backward compatible)
• New projects: Use Addressables from the start
• Hybrid: Mix Resources and Addressables prefabs as needed

Late-Joiner Support:

• Addressables scenes sync'd to late-joiners automatically
• Prefabs loaded asynchronously before spawn messages processed
• No special handling required from game code

Files:

• GONetSceneManager.cs - Addressables scene loading (#if ADDRESSABLES_AVAILABLE)
• GONetSpawnSupport_Runtime.cs - Addressables prefab loading support
• DesignTimeMetadata.json - Metadata with addressables:// paths

---

5. Adaptive Congestion Management

Problem Solved: Ring buffer exhaustion during rapid spawning caused dropped sync updates.

Solution: Auto-scaling packet pools adapt to network demand.
...

GONet v1.5b3

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]
async Task<ChatResult> SendChatMessage(string message) { }
[ClientRpc]
void NotifyAllClients(string message) { }

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

// 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 and Memory - 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.5b3 Patch Release Notes

Bug Fixes

• WasInstantiated() edge case fix - Resolved timing issue for early instantiations during scene load (ec71fc3)
• Unity 6.2 compatibility - Fixed GONet dirty reasons warning appearing after successful builds (96abfa5)

Refactoring

• Sample UI cleanup - Moved sample UI initialization out of GONet core framework for better separation of concerns (54ede77)

GONet v1.4.1 Patch

GONet 1.4.1 PATCH Release Notes

Major Fix

• Resolved critical compilation errors related to Unity Collections package that many people experienced upon importing GONet
• Fixed namespace conflicts that were preventing compilation in newer Unity versions
• Eliminated dependency on log4net and Common.Logging libraries

New Logging System

• Completely rewritten GONetLog system with no external dependencies
• High-performance multi-threaded logging architecture
• Automatic log file rotation with configurable retention
• Cross-platform compatibility (Mono, .NET Framework, .NET Standard 2.1, IL2CPP)
• Full support for all platforms (Windows, macOS, Linux, iOS, Android, WebGL, etc.)
• Thread-safe implementation with efficient memory usage
• Maintains same API surface as previous system, ensuring backward compatibility

Additional Improvements

• Enhanced error recovery mechanisms for more robust operation
• Improved thread management for better platform compatibility
• Optimized file I/O operations for better performance
• Added platform-specific path handling to ensure logs are stored correctly
• Reduced memory allocations for better runtime performance
• Special handling for WebGL platform limitations

How to Update

1. Update to GONet 1.4.1 through the Unity Package Manager or Asset Store
2. No additional configuration needed - the fix is automatically applied
3. Existing code using GONetLog will continue to work without any changes

Thank you for your patience as we addressed this issue. We're committed to ensuring GONet works seamlessly across all Unity versions and platforms. PLEASE reach out to us on discord or at contactus@galoreinteractive.com any time a GONet issue arises so we can get you the help you need.

GONet v1.4

Preamble

GONet v1.4 brings enhanced networking, smoother gameplay, and a robust developer experience, building on v1.3's multiplatform foundation. This release may be the final free version of GONet. Thank you for your support!

PSA Recommendations before updating GONet

We strongly advise developers to create a backup version just before updating to the new GONet version or any other software package. We offer these suggestions:

Utilize a version control system to commit a project version immediately before the update, allowing for easy rollback if needed.
Duplicate the Unity project folder, providing a replacement option in case of necessity.

Unity version compatibility

-Since v1.3, GONet requires Unity 2022 LTS or newer

New Capabilities

--Dual-Stack IPv4/IPv6 Support
-Supports IPv4 and IPv6, favoring IPv6. Tested on Linux, Windows, and Android; test non-local setups.

--Server Hostname Support
-Allow use hostnames instead of IPs if you want, inspired by Dajimo.

--Design-Time Metadata Overhaul
-Replaces DesignTimeLocations.txt with DesignTimeMetadata.json, reducing save needs and applying metadata at runtime.

--C_hange Detection Warning with Bypass Option_
A new warning system detects local changes to GONet-related files since the last build, preventing potential GONet malfunctions in the editor. This ensures GONet operates as expected by alerting you to discrepancies that could cause runtime issues. Also added a "Proceed Anyway" option, allowing developers to bypass the warning and enter play mode at their own risk if they believe the changes won't impact functionality.

Breaking Changes

--Removal of Disruptor Dependency
-Replaced Disruptor with LockFreeRingBuffer for IL2CPP compatibility. Adapt custom integrations.

--Simplified GONetClient and GONetServer Constructors
-GONetClient no longer accepts an argument; update code to avoid build breaks.
-GONetServer removed an unnecessary argument; adjust accordingly.
-Check your scripts to prevent compilation failures post-update.

Improvements

--Enhanced Value Blending
-Vector3 Fix: Uses latest buffer value, removing smoothing step.
-Quaternion Smoothing: Uses SQUAD with limits, reducing jitter.
-Spawned Objects: Improves GNP instantiation.

--Optimized Event Bus
-Splits processing into non-sync, generic sync, and specific groups.
-Caches handlers and consolidates GNP subscriptions in GONetMain.
-Retains benchmarked bandwidth/CPU gains.

--Robust Metadata System
-Adds checks for scene, GNP, and prefab changes.
-Ignores non-build scenes and clears dirty file on successful builds.

--P2P Stability
-Resolves P2P issues with token checks; test non-P2P setups.

--Editor Enhancements
-Auto-starts clients for remote servers in play mode.
-Fixes GONet Editor Support window errors.
-Auto-disables GNPs without codeGenerationId.

--Logging Optimizations
-Removes spammy logs for better performance.
-Ensures logs are written correctly to disk across all platforms, now located in Application.persistentDataPath/logs. Check this new location if logs are missing.
-Improves log4net rolling behavior.

--Sample Spawner Update
-Requires Left Ctrl/Cmd + Alt+S/C; updated setup guide.

Bug Fixes

-Ensures sync events reach all subscribers.
-Prevents sample spawner errors with missing authority prefabs.
-Fixes metadata lookup and generated code issues.
-Excludes editor-only code and ensures build success.

Installation Notes

--Compilation Errors
Post-import errors may occur. Resolve via:

1. Go to GONet menu.
2. Open GONet Editor Support.
3. Click Refresh GONet Code Generation.
   Skip this step, and your project may fail to build.

--NewtonSoft JSON
May be required. Install via Package Manager with com.unity.nuget.newtonsoft-json git URL, or consider future automation.

Notes for Upgraders

• Review DesignTimeMetadata.json for prefab spawning.
• Check /Assets/GONet/Resources/GONet/SyncSettingsProfiles for overwritten settings; use version control.
• Update for LockFreeRingBuffer and constructor changes.
• Test non-P2P setups and event systems.
  Neglecting these steps could lead to runtime errors or data loss.

Testing

-Tested with 150ms lag, 90% packet loss, CPU at 33%, and cross-platform (IPv4/IPv6). Validated in Dajimo Arena.

v1.1.2 Unity Asset Store Submission

This release is functionally the same as v1.1.1, which was published back in December 2020; however, since GONet was temporarily deprecated, this v1.1.2 is the dusting off of the product and resubmission against Unity 2020.3.45f1 instead of 2018.4 like previously (due to new asset store requirements).

Unfortunately, the approval process to get back into the asset store is taking several weeks and as of 04 APRIL 2023 it is still not approved. Hopefully, that changes soon.

This release is mainly to provide the community the already packaged up binary for easier use in projects.