View on Asset Store (opens in new tab)
Package details
- Latest version
- 1.5b5
- Last updated
- First released
- Unity version
- 2022.3.62 or later
- Package size
- 3.6 MB
- Files
- 1,982
- Favorites
- 68
- Views in the past week
- 21
Price tracking
- Last checked
- Tracked since
- Lowest recorded
- Free on
Keywords
GONet: Dead-Simple GameObject Networking – Auto-Magical Sync, RPCs, Pub-Sub, Scene Mgt, Blazing Perf, Sync Configs and Plugin API, Full Source. Instant Wins, Infinite Tweaks.
Affiliate link · Purchases support this site
Price history
Last 6 months
USDAsset preview
1 / 13
GONet screenshot 1
About this asset
**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:[email protected]) - 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**
From the publisher's Asset Store listing.
Technical details
## NEW in v1.5
**RPC System**
- Async/await support with `CallRpcAsync<T>()`
- [ServerRpc], [ClientRpc], [TargetRpc] attributes
- Server-side validation hooks
- Persistent RPCs delivered to late-joiners
- Deferred execution for components not ready
- Delivery reports and validation results
**Scene Management System**
- Server-authoritative scene loading
- Build Settings and Unity Addressables support
- Client scene change requests with server approval
- Automatic late-joiner scene synchronization
- Extensibility hooks (OnValidateSceneLoad, RequiresAsyncApproval)
- Single and Additive loading modes
**Unity Addressables Support**
- Scene loading from Addressables
- Runtime prefab spawning from Addressables
- No Resources folder restrictions
- Organize prefabs anywhere in project
- Efficient asset bundles via Addressables groups
- Platform-specific asset variants
- Zero configuration (auto-detected)
- Works alongside Resources-based prefabs
**Adaptive Congestion Management**
- Auto-scaling packet pools (1,000 to 20,000 packets/tick)
- Handles burst spawning (100+ objects/frame)
- Prevents "Ring buffer is full" errors
- Configurable drop thresholds for unreliable traffic
- Detailed congestion logging
**Velocity-Augmented Sync**
- 90%+ bandwidth reduction for slow-moving objects
- Eliminates micro-jitter for smooth movement
- Intelligent switching (velocity vs absolute values)
- Aggressive quantization (slow velocities compress to 0 bits)
- Periodic VALUE anchors prevent drift
- Perfect for platforms, turrets, doors, rotating cameras
**Auto-Detection for Development**
- Automatic server/client role detection
- First instance becomes server, rest become clients
- Works in Editor and builds
- Zero manual configuration for local testing
- Command line args override available
**Sync Bundle Deferral System**
- Industry-standard DROP-FIRST approach (default)
- Optional queue-and-retry for turn-based games
- Handles race conditions during rapid spawning
- Configurable queue size and processing batch size
- Authority re-sends state 30-60 times/sec (auto-recovery)
**GONetId Batch System**
- Pre-allocated ID ranges (200-1000 IDs per batch)
- Zero spawn latency for client-owned objects
- Automatic batch refill at 50% threshold
- Configurable limbo mode for edge cases
- Eliminates 50-150ms server round-trip delay
**GONetId Reuse Protection**
- Configurable delay before ID reuse (default: 5 seconds)
- Prevents premature despawn messages
- Tunable for different latency scenarios
**Message Flow Logging**
- Separate log file: `gonet-MessageFlow-YYYY-MM-DD.log`
- Comprehensive send/receive/process tracking
- Critical for debugging race conditions
**UI Components**
- GONetStatusUI (persistent on-screen status display)
- Scene Selection UI (server-side scene picker)
- Exit Button UI (graceful disconnect with approval)
## Core Networking Features
**Auto-Magical Data Sync**
- Transform (position, rotation, scale)
- Animator Controller parameters
- Any MonoBehaviour fields with [GONetAutoMagicalSync]
- Input state (keys, mouse, buttons)
- Design-time code generation (debuggable, no runtime reflection)
- Configurable sync profiles (reliability, frequency, quantization)
**Network Spawning**
- GameObject.Instantiate() networked automatically
- Prefab alternates for non-owners
- Runtime authority transition
- Resources and Addressables loading
- Late-joiner spawning support
- Spawn data provider interface (IGONetSpawnDataProvider)
**Value Blending**
- Default interpolation/extrapolation
- Custom blending via IGONetAutoMagicalSync_CustomValueBlending
- Handles packet loss gracefully
- Smooth non-owner visuals
- Configurable buffer lead time (default: 100ms)
**Event Bus System**
- Publish/Subscribe architecture
- Transient events (current clients only)
- Persistent events (includes late-joiners)
- Custom event classes
- Automatic event delivery from sync changes
- Promotes event-driven architecture
**Serialization & Compression**
- Custom bit-packing (tighter than MessagePack)
- LZ4 compression for bulk data
- Configurable quantization (choose bit count per value)
- Custom serializers via IGONetAutoMagicalSync_CustomSerializer
- Automatic range mapping and compression
**Network Transport**
- UDP-only (no TCP overhead)
- Unreliable + Unordered (fast, low latency)
- Reliable + Ordered (RUDP - guaranteed delivery)
- Configurable channels per data type
- Encryption via Bouncy Castle Crypto API
- Multi-level API (high, mid, low-level)
**Late-Joining Client Support**
- Full world state sync on connect
- Persistent events delivered automatically
- Scene synchronization (loads correct scene)
- GONetId assignments for scene-defined objects
- Buffered assignments if scene not loaded yet
**Physics Support**
- RigidBody synchronization (position, rotation, velocity, angular velocity)
- Kinematic vs dynamic mode sync
- Collision event propagation (optional)
- Authority transition mid-flight
- Sync after all FixedUpdate and physics processing
**Logging System**
- Custom GONetLog (no external dependencies)
- Multi-threaded architecture
- Cross-platform (Mono, .NET Framework, .NET Standard, IL2CPP)
- Console output in Editor
- File output in builds (Application.persistentDataPath/logs)
- Configurable levels (Debug, Info, Warning, Error, Fatal)
- Comprehensive context (thread, timestamp, frame time)
- Automatic log rotation
**Code Generation**
- Pure C# code generators (no T4 templates)
- Design-time generation (committed to source control)
- Runtime debuggable
- Per-prefab sync companion classes
- Automatic regeneration on changes
- Object pooling and bit packing
## Network Topologies
**Dedicated Game Server (Client-Server DGS)**
- Authoritative server prevents cheating
- Scales well for online multiplayer
- Predictable behavior
**Local Area Network (LAN)**
- Low latency, high bandwidth
- Great for Location-Based Entertainment (LBE)
- Couch co-op, arcades, events
## Platform Support
**Wide Compatibility**
- All managed C#, no native libraries
- Ahead of Time (AOT) compilation support (iOS)
- IL2CPP supported
- Windows, Mac, Linux, iOS, Android
- Consoles (case-by-case basis)
**Unity Version**
- Unity 2022.3.62f3 LTS or later (minimum required)
- Forward compatible with Unity 2023.2+ LTS
## Performance & Optimization
**High Performance Design**
- UDP-only for minimal overhead
- Aggressive inlining on hot paths
- Object pooling (NetworkData, byte arrays)
- Span<T> and Memory<T> for zero-copy operations
- Minimal allocations in hot paths
- Multi-threaded where safe
**Bandwidth Optimization**
- Bit-packing and quantization
- LZ4 compression
- Velocity-based sync for slow-moving objects
- Configurable update frequencies
- Delta encoding
**Memory Management**
- Object pooling throughout
- Automatic pool scaling
- Byte array reuse
- Zero allocations in sync loops
- Incremental GC recommended
## Extensibility & Customization
**PluginAPI**
- Custom serializers (IGONetAutoMagicalSync_CustomSerializer)
- Custom value blending (IGONetAutoMagicalSync_CustomValueBlending)
- Spawn data providers (IGONetSpawnDataProvider)
- Scene-defined object initializers (IGONetSyncdBehaviourInitializer)
- Runtime component injection (GONetRuntimeComponentInitializer)
**Validation Hooks**
- RPC validation (server-side)
- Scene load validation (OnValidateSceneLoad)
- Async approval workflows
- Custom filtering and authorization
**Configuration**
- GONetGlobal runtime settings
- Per-value sync profiles
- Quantization settings
- Reliability and frequency per field
- Custom sync profiles via templates
## Documentation & Examples
**Included Documentation**
- Comprehensive setup guide
- API reference documentation
- Sample scene with working examples
- Code comments throughout
- CLAUDE.md with architecture details
**Sample Code**
- GONetSampleScene.unity (complete working example)
- GONetSampleInputSync.cs (input synchronization)
- GONetSampleSpawner.cs (network spawning)
- GONetSampleChatSystem.cs (RPC validation example)
- SceneSelectionUI.cs (scene change requests)
- ExitButtonUI.cs (persistent UI with async approval)
**Community Resources**
- Active Discord community
- Tutorial videos
- Forum support
- Regular updates
## System Requirements
**Development**
- Unity 2022.3.62f3 LTS or later
- .NET Framework or .NET Standard 2.1
- 64-bit CPU with 4 cores recommended
- Windows, Mac, or Linux
- Allow 'unsafe' Code enabled
**Runtime (Playing GONet Games)**
- Baseline Unity player requirements
- 64-bit CPU (mobile: ARM64)
- Network connection (LAN or Internet)
## Third-Party Libraries
- Bouncy Castle Crypto - Apache License 2.0
- Class Type Reference - MIT License
- MessagePack - MIT License
- MemoryPack - MIT License
- Netcode.IO.NET - MIT License
- Reliable Netcode - MIT License
All licenses included in package. See Third-Party Notices.txt for full details.
## Source Code
- Full C# source code included
- Well-commented and debuggable
- Pure C# (no native dependencies)
- Design-time code generation
- Committed generated code for debugging
Compatibility
| Unity version | Built-in | URP | HDRP | Custom |
|---|---|---|---|---|
| 2022.3.62f3 | Compatible | Compatible | Compatible | Compatible |
As listed on the Asset Store.