Skip to content

GONet v1.5b

Choose a tag to compare

View all tags
@shasheppard shasheppard released this 31 Oct 00:38
· 43 commits to master since this release
v1.5b_unityAssetStore
728cb89

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.

How It Works:

  • Pool starts at baseline size (default: 1,000 packets)
  • Scales UP when utilization exceeds 75%
  • Scales DOWN when utilization stays below 25%
  • Respects maxPacketsPerTick as absolute ceiling (default: 20,000)
  • Aggressive warnings when approaching limits

Configuration:

// GONetGlobal component - Inspector
enableAdaptivePoolScaling = true; // Default: true (recommended)
adaptivePoolBaselineSize = 1000; // Starting size (100-10,000)
maxPacketsPerTick = 20000; // Absolute ceiling (100-100,000)
unreliableDropThreshold = 0.90f; // Drop unreliable at 90% utilization (0.5-0.99)
enableCongestionLogging = true; // Detailed logs for debugging

Benefits:

  • Handles burst spawning (100+ objects/frame) gracefully
  • Prevents "Ring buffer is full" errors
  • Conserves memory during low activity
  • Detailed diagnostics when congestion occurs

Tuning Guidance:

  • Small Co-op (2-8 players): baseline=500, max=5000
  • Battle Royale (50-100 players): baseline=1500, max=15000
  • MMO (100+ players): baseline=3000, max=30000

Files:

  • GONet.cs - Adaptive scaling logic
  • GONetGlobal.cs - Configuration options

6. Sync Bundle Deferral System

Problem Solved: Race condition where sync bundles arrive before GONetParticipant completes Awake() initialization, causing NullReferenceException crashes.

Solution: Industry-standard DROP-FIRST approach with optional DEFER configuration.

Default Behavior (Deferral DISABLED):

  • Bundles dropped if participant not ready
  • Authority re-sends state 30-60 times/sec (auto-recovery)
  • Value blending smooths over 1-2 dropped frames
  • Zero performance overhead
  • Matches industry standard approach

Optional Behavior (Deferral ENABLED):

  • Reliable bundles queued and retried once
  • Unreliable bundles still dropped (by design)
  • Max 100 bundles queued per receiver (FIFO drop policy)
  • Max 10 bundles processed per OnGONetReady callback (prevents frame stutter)

Configuration:

// GONetGlobal component - Inspector
deferSyncBundlesWaitingForGONetReady = false; // Default: false (DROP)
maxSyncBundlesWaitingForGONetReady = 100; // Queue size if enabled (10-500)
maxBundlesProcessedPerGONetReadyCallback = 10; // Batch size (1-50)

When to Enable Deferral:

  • Turn-based games (every state change must be received)
  • Zero data loss required (ownership changes, inventory updates)

When to Leave Disabled (Default):

  • Action games with high-frequency updates
  • Transient state (positions, rotations)
  • Performance-critical scenarios

Edge Cases Handled:

  • Queue full → FIFO drop policy (oldest dropped first)
  • Unreliable bundles → ALWAYS dropped (no queueing)
  • Retry still fails → DROP with error log (lifecycle bug detected)
  • Participant destroyed → KeyNotFoundException caught, bundle dropped gracefully
  • Pool safety → Byte arrays always returned in all code paths

Files:

  • GONet.cs - Exception class, queue, deferral/processing methods
  • GONetGlobal.cs - Configuration options
  • GONetSyncBundleDeferralTests.cs - Unit tests

7. Auto-Detection for Development

Problem Solved: Manual server/client startup via keyboard shortcuts was cumbersome during local development.

Solution: Automatic role detection based on port availability.

How It Works:

  • First instance checks if port 40000 is free
  • Port free → Start as SERVER automatically
  • Port occupied → Start as CLIENT (connect to localhost)
  • Works in Editor AND builds
  • Command line args (-server / -client) always override

Configuration:

// GONetGlobal component - Inspector
enableAutoRoleDetection = true; // Default: true (recommended for dev)

Benefits:

  • Zero manual configuration for local testing
  • Just hit Play - first instance becomes server, second becomes client
  • Faster iteration during development
  • Multiple editor/build instances "just work"

Disabling:

  • Uncheck "Enable Auto Role Detection" in GONetGlobal
  • Falls back to manual startup (keyboard shortcuts or command line args)

Files:

  • GONetGlobal.cs - Auto-detection logic (Editor_AttemptStartAsClientIfAppropriate)
  • NetworkUtils.cs - Port availability checking

Significant Improvements

8. Velocity-Augmented Sync

Problem Solved: Slow-moving and slow-rotating objects (platforms, turrets, doors) suffered from micro-jitter and consumed excessive bandwidth with traditional absolute value sync.

Solution: Intelligent velocity-based sync that dynamically switches between velocity deltas and absolute values based on movement speed. Super cool and super efficient!

How It Works:

  • Slow movement detected: Server sends velocity delta (often zero or very small)
  • Client extrapolates smoothly: Perfect smooth movement with zero jitter
  • Aggressive quantization: Slow velocities often compress to 0 bits (massive bandwidth savings!)
  • Periodic anchors: VALUE bundles sent every 1 second to prevent drift
  • Automatic fallback: Large changes (teleport, collision) switch to VALUE bundles instantly

Benefits:

Bandwidth Savings:

  • Slow-moving objects: 90%+ bandwidth reduction (velocity ~0 quantizes to nothing)
  • Typical use cases: Rotating turrets, moving platforms, opening doors
  • Dynamic optimization: Fast-moving objects use VALUE, slow objects use VELOCITY

Visual Quality:

  • Eliminates micro-jitter completely (smooth extrapolation)
  • Perfect for slow rotations (no more "stutter stepping")
  • Graceful degradation on unreliable channels (velocity predictions smooth over packet loss)

Use Cases:

  • Rotating security cameras (smooth, low bandwidth)
  • Elevator platforms (smooth movement, no jitter)
  • Opening/closing doors (smooth animation)
  • Slowly drifting asteroids (minimal network cost)
  • Tank turret rotation (smooth tracking)

Configuration:

// GONetGlobal component - Inspector
velocityAnchorIntervalSeconds = 1.0f; // Periodic anchor (0.5-5.0s)

// Per-profile override available in GONetAutoMagicalSyncSettings_ProfileTemplate:
VelocityAnchorIntervalSeconds = 2.0f; // 0 = use global default

Files:

  • GONet.cs - Velocity sync logic
  • GONetGlobal.cs - Configuration

9. GONetId Reuse Protection

Problem Solved: GONetIds reused too quickly could cause despawn messages for old object to despawn new object with same ID.

Solution: Delay before allowing GONetId reuse, based on network RTT and safety margin.

Configuration:

// GONetGlobal component - Inspector
gonetIdReuseDelaySeconds = 5.0f; // Default: 5 seconds (1-30s range)

Tuning:

  • LAN (low latency): 2-3 seconds
  • Internet (normal): 5 seconds (default)
  • High latency/packet loss: 10-15 seconds

Files:

  • GONet.cs - Reuse delay tracking
  • GONetGlobal.cs - Configuration

10. Reliable Message Queue Expansion

Problem Solved: Reliable message queue exhaustion during sustained high message rate + high packet loss.

Solution: Configurable queue size with expanded default capacity.

Configuration:

// GONetGlobal component - Inspector
maxReliableMessageQueueSize = 2000; // Default: 2000 messages (1000-10000)

When Exhaustion Occurs:

  • [RELIABLE-QUEUE-EXHAUSTION] error logged
  • Message DROPPED (spawn events, RPCs will fail silently)
  • Extremely rare - requires sustained burst + high packet loss + slow ACKs

Tuning:

  • LAN/Low latency: 1000-2000 (default: 2000)
  • Internet/Normal latency: 2000-5000
  • High latency/packet loss: 5000-10000

Files:

  • GONet.cs - Queue management
  • GONetGlobal.cs - Configuration

11. Physics Synchronization Improvements

Problem Solved: Physics sync timing didn't account for all Unity physics processing steps.

Solution: Sync AFTER all FixedUpdate calls AND physics simulation complete.

Implementation:

  • Coroutine uses yield return new WaitForFixedUpdate()
  • Ensures sync happens after collisions/triggers processed
  • Server-only check inside sync method

Unity Execution Order:

  1. FixedUpdate() on all scripts
  2. Internal physics simulation
  3. OnCollisionEnter/Stay/Exit callbacks
  4. OnTriggerEnter/Stay/Exit callbacks
  5. WaitForFixedUpdate resumes ← PHYSICS SYNC HAPPENS HERE

Benefits:

  • Captures FINAL physics state (not intermediate)
  • More accurate Rigidbody sync
  • Prevents "half-simulated" state from propagating

Files:

  • GONetGlobal.cs - PhysicsSync_WaitForFixedUpdate coroutine
  • GONet.cs - PhysicsSync_ProcessASAP implementation

12. UI and Developer Experience Improvements

GONetStatusUI (New Component):

  • Persistent on-screen status display
  • Shows server/client state, connection count, GONetId batch info
  • Auto-created and added to GONetGlobal
  • Minimal performance overhead

Scene Selection UI (Enhanced):

  • Server-side scene selection dropdown
  • Async approval flow with server confirmation dialog
  • Extensibility for custom UI

Exit Button UI (New Component):

  • Graceful disconnect/shutdown
  • Server approval for client exit (optional)
  • Prevents accidental disconnects

Message Flow Logging (New):

  • Separate log file: gonet-MessageFlow-YYYY-MM-DD.log
  • Comprehensive send/receive/process tracking
  • Enable via enableMessageFlowLogging in GONetGlobal
  • Critical for debugging race conditions and timing issues

Files:

  • GONetStatusUI.cs - Status display component
  • SceneSelectionUI.cs - Scene selection dialog
  • ExitButtonUI.cs - Exit confirmation (~632 lines)
  • GONetGlobal.cs - Message flow logging profile

Bug Fixes and Stability

Critical Fixes

Late-Joiner GONetId Synchronization:

  • Scene-defined objects now receive GONetIds proactively from server
  • Buffered assignments if scene not loaded yet (no race conditions)
  • Proactive flow (server OnSceneLoaded) + reactive flow (client SceneLoadCompleteEvent)
  • Deduplication prevents duplicate sends to early-joiners

Spawn Data Provider Race Condition:

  • IGONetSpawnDataProvider now guaranteed to run before OnGONetReady
  • Serialization happens synchronously during spawn message handling
  • Cache prevents re-randomization for late-joiners (server sends same data to all clients)

Duplicate GONetGlobal Handling:

  • Improved singleton pattern (DestroyImmediate instead of Destroy)
  • Prevents any processing on duplicate instances
  • Scene unloading correctly clears subscriptions

Time Sync Improvements:

  • Separate pre-load and post-load aggressive sync requests
  • Prevents double-reset during late-joiner initialization (was causing broken time sync)
  • Correct handling for clients not yet initialized

Deferred RPC Execution:

  • RPCs queued when components not ready (OnGONetReady not fired yet)
  • Processed automatically when component becomes ready
  • Prevents "component not found" errors during rapid spawning

Robustness Improvements

Addressables Loading Stability:

  • Handle invalid handles gracefully
  • Proper cleanup on exception
  • Scene instance tracking for unload
  • Release all handles on shutdown

Scene Unload Cleanup:

  • Clear proactive GONetId tracking when scene unloads
  • Supports scene reload (clients receive GONetIds again)
  • Buffered assignments cleared when applied

Pool Safety:

  • Byte arrays always returned to pool in all code paths
  • Catch handlers ensure cleanup even on exceptions
  • Prevents memory leaks during error conditions

Performance Optimizations

Reduced Allocations:

  • Object pooling for network messages (NetworkData)
  • Byte array pooling for serialization buffers
  • String builder reuse in hot paths
  • Reduced GC pressure during gameplay

Code Generation Improvements:

  • Pure C# code generators (no T4 templates)
  • Debuggable generated code (committed to source control)
  • Faster generation times
  • Better error reporting

Aggressive Inlining:

  • [MethodImpl(MethodImplOptions.AggressiveInlining)] on hot paths
  • Bit manipulation operations inlined
  • Serialization/deserialization hot paths optimized

Span and Memory Usage:

  • Modern C# memory APIs for zero-copy operations
  • stackalloc for small temporary buffers
  • Reduced heap allocations in serialization

API Changes and Deprecations

New Public APIs

GONetMain:

// Scene manager access
public static GONetSceneManager SceneManager { get; }

// Thread-safe utilities
public static class GONetThreading {
    public static void RunOnMainThread(Action action);
}

// Async RPC support
public async Task<TResponse> CallRpcAsync<TResponse>(string rpcMethodName, params object[] args);

GONetSceneManager:

// Scene loading
public void LoadSceneFromBuildSettings(string sceneName, LoadSceneMode mode);
public void LoadSceneFromAddressables(string sceneName, LoadSceneMode mode);

// Client requests
public void RequestLoadScene(string sceneName);
public void RequestLoadAddressablesScene(string sceneName);

// Validation hooks
public event SceneLoadValidationDelegate OnValidateSceneLoad;
public bool RequiresAsyncApproval { get; set; }

// State queries
public bool IsSceneLoaded(string sceneName);
public bool IsAnySceneLoading { get; }
public IEnumerable<string> GetLoadingScenes();

GONetParticipant:

// Limbo state (batch system)
public bool client_isInLimbo { get; }
public GONetParticipant_LimboMode client_limboMode { get; }

New RPC Attributes:

[ServerRpc(validationMethod: "MethodName", IsPersistent = false)]
[ClientRpc(IsPersistent = false)]
[TargetRpc(validationMethod: "MethodName")]

Deprecated APIs

GONetSpawnSupport_Runtime (Legacy):

  • Old spawn APIs still work but delegate to new batch system internally
  • Client_InstantiateToBeRemotelyControlledByMe() → Delegates to Client_TryInstantiateToBeRemotelyControlledByMe()
  • No breaking changes, but new code should use Client_TryInstantiateToBeRemotelyControlledByMe() for explicit limbo mode control

Legacy Code Generation:

  • Old .tt T4 template files exist but are NOT USED
  • Pure C# code generators replaced T4 templates
  • Backward compatibility maintained, but T4 files will be removed in future release

Migration Guide (v1.4.1 → v1.5)

Automatic Migration (No Code Changes Required)

Most games will migrate automatically with zero code changes:

  1. Update Unity version (required):

    • Upgrade to Unity 2022.3.62f3 LTS or later (new minimum requirement)

  2. Import GONet v1.5 package:

    • Delete Assets/GONet/ folder (if upgrading in-place)
    • Import new v1.5 package
    • Resolve any API obsoletion warnings (see below)

  3. Recompile:

    • Unity auto-compiles after import
    • Code generation runs automatically

  4. Test:

    • Play scene - first instance becomes server automatically (new auto-detection)
    • Run second instance - connects as client automatically
    • Verify no Console errors

Optional Configuration

GONetGlobal Settings:

  • Review new configuration options in GONetGlobal Inspector
  • Adjust client_GONetIdBatchSize if spawning 100+ objects/sec per client
  • Enable deferSyncBundlesWaitingForGONetReady if turn-based game
  • Tune maxPacketsPerTick and adaptivePoolBaselineSize for your scale

Auto-Detection:

  • If you prefer manual server/client startup, disable enableAutoRoleDetection

Scene Management:

  • If using custom scene loading, migrate to GONetMain.SceneManager API
  • Add validation hooks if restricting client scene change requests

API Obsoletion Warnings

GONetSpawnSupport_Runtime:

// OLD (still works, but warns):
GONetParticipant obj = GONetMain.Client_InstantiateToBeRemotelyControlledByMe(prefab, pos, rot);

// NEW (recommended):
if (GONetMain.Client_TryInstantiateToBeRemotelyControlledByMe(
    prefab, pos, rot, out GONetParticipant obj,
    GONetParticipant_LimboMode.InstantiateInLimbo))
{
    // Success (may be in limbo temporarily)
}

Known Issues and Workarounds

None at this time. If you encounter issues during migration:

  1. Check Console for errors/warnings
  2. Verify GONetGlobal configuration
  3. Review logs in logs/gonet.log (builds) or Unity Console (editor)
  4. Reach out via Discord or email for support

Testing and Quality Assurance

Tested Scenarios:

  • 2-8 player co-op (stable, < 1% packet loss)
  • 50-100 player battle royale (adaptive scaling tested)
  • Rapid spawning (100+ objects/sec per client, batch system validated)
  • Late-joiner synchronization (scene loads, GONetId assignments, persistent RPCs)
  • Scene transitions (Build Settings and Addressables)
  • Physics synchronization (Rigidbody authority transition)
  • RPC validation (profanity filtering, authorization)
  • High latency (200ms+ RTT, velocity sync validated)
  • Packet loss (10%+ loss, reliable message queue tested)

Platforms Tested:

  • Windows 10/11 (Editor and builds)
  • Mac (Editor and builds)
  • Linux (builds)
  • iOS (builds via TestFlight)
  • Android (builds)

Unity Versions Tested:

  • Unity 2022.3.62f3 LTS (minimum required)
  • Unity 2022.3.50f1 LTS
  • Unity 2023.2 LTS
  • Unity 6 (forward compatibility)

Documentation and Examples

Updated Documentation:

  • Setup Guide (comprehensive, covers new features)
  • API Reference (all new APIs documented)
  • Scene Management Guide (new)
  • RPC System Guide (updated with async/await and validation)
  • GONetId Batch System Guide (new)

New Example Scenes:

  • GONetSampleScene.unity - Updated with scene selection UI and exit button
  • Scene-defined object initialization examples
  • RPC validation examples (chat system with profanity filtering)

Code Comments:

  • 500+ new comments explaining architecture decisions
  • CLAUDE.md updated with v1.5 features and lessons learned
  • Inline documentation for complex systems (batch, deferral, velocity sync)

Acknowledgments

Special Thanks:

  • Community feedback on Discord (feature requests and bug reports)
  • Early adopters testing pre-release builds
  • Unity for 2022.3 LTS stability and performance improvements

Support and Resources

Get Help:

Resources:

Upgrade to PRO:

  • Contact us to discuss PRO/Premium tier features
  • Record+Replay, LOD, P2P, priority support

What's Next? (v1.6 Roadmap Preview)

Under Consideration:

  • WebGL support (UDP via WebRTC data channels)
  • Interest management (spatial culling for large worlds)
  • Bandwidth profiler (identify heavy sync contributors)
  • Network emulation tools (simulate latency/loss in Editor)
  • Voice chat integration (Vivox, Dissonance)

Feedback Welcome:

  • Let us know what features you need most
  • Join roadmap discussions on Discord
  • Vote on feature priorities

Conclusion

GONet v1.5 represents months of development focused on production readiness, developer experience, and performance at scale. Whether you're building a 2-player co-op game or a 100-player battle royale, GONet v1.5 provides the tools and reliability you need to ship.

Ready to update? Import v1.5 today and experience the difference!

GONet Team
Galore Interactive LLC
October 2025

Full Changelog

Added

  • GONetId Batch System (pre-allocated ID ranges for client spawning)
  • Enhanced RPC system (async/await, validation, persistent delivery)
  • Scene Management system (server-authoritative, Addressables support)
  • Adaptive Congestion Management (auto-scaling packet pools)
  • Sync Bundle Deferral System (OnGONetReady race condition handling)
  • Auto-Detection for Development (automatic server/client role)
  • Velocity-Augmented Sync (eliminates micro-jitter)
  • GONetId Reuse Protection (delay before reuse)
  • Reliable Message Queue Expansion (configurable capacity)
  • GONetStatusUI component (persistent status display)
  • Scene Selection UI (server-side scene picker)
  • Exit Button UI (graceful disconnect with approval)
  • Message Flow Logging (comprehensive debugging)
  • GONetThreading utilities (main-thread marshalling)
  • Physics sync timing improvements (WaitForFixedUpdate)

Changed

  • Upgraded to Unity 2022.3.62f3 LTS (new minimum required version)
  • Legacy spawn APIs delegate to batch system internally
  • Improved singleton pattern for GONetGlobal (DestroyImmediate)
  • Time sync improvements (separate pre/post-load requests)
  • Deferred RPC execution (queue when components not ready)

Fixed

  • Late-joiner GONetId synchronization race conditions
  • Spawn data provider race condition (IGONetSpawnDataProvider)
  • Duplicate GONetGlobal handling (scene unloading)
  • Addressables loading stability (handle cleanup, exceptions)
  • Scene unload cleanup (GONetId tracking, buffered assignments)
  • Pool safety (byte arrays always returned)
  • Physics sync timing (captures final state after all processing)

Deprecated

  • Legacy T4 template code generators (replaced with pure C# generators)
  • Old spawn APIs (still work, but new API recommended)

Removed

  • None (backward compatibility maintained)

End of Release Notes

Assets 3
Loading