I would like to announce the launch of a new networking framework called Nodes.
Nodes is a low-level networking framework focused on message routing and network transmission. It’s designed for developers who want full control over their networking.
Nodes is not a turnkey multiplayer solution and does not include pre-built gameplay components (e.g., NetworkedTransform) or pre-made prediction/reconciliation systems. Instead, it provides a flexible foundation that developers can use to implement a custom multiplayer architecture and the gameplay features that best suit their project.
Most available solutions tend to sit at one of two extremes. They are either thin wrappers over system sockets that don’t provide much beyond basic transport, or they come with a large amount of built-in structure that introduces constraints and unnecessary overhead.
Born from my own need for an unopinionated networking solution, Nodes was designed to bridge the gap between these two approaches by providing a robust routing and transport layer without dictating how the rest of the networking stack should be implemented.
The framework is built around composable message pipelines. Routers are organized hierarchically and communicate through protocols that define message exchange. Protocols are composable, forming chains of independent processing stages that each handle messages in sequence. This makes it easy to add, remove, or reorder functionality without affecting the rest of the pipeline.
Platform-specific implementations are defined externally, allowing Nodes to be used outside of Unity projects. The package available through the Asset Store provides Unity-specific integrations for the framework.
Nodes are Routers that handle socket operations, connecting a hierarchy to a network while Dispatchers are Routers that handle sending and receiving payloads, connecting the hierarchy to the rest of the application. Outbound payloads move from Dispatchers to Nodes while inbound payloads move from Nodes to Dispatchers.
The default Node implementation uses UDP. The framework is otherwise transport-agnostic. Alternative transport layers (e.g., TCP) can be introduced by replacing this implementation without affecting the rest of the message pipeline, provided such implementations correctly conform to the framework’s message semantics.
Features:
• Custom protocol support
• Automatic serialization/deserialization for unmanaged payloads
• Zero hot-path allocations for unmanaged payloads in the core framework
• Optional concurrent processing integrated with Unity’s update loop
• Works with both standalone classes and MonoBehaviours
The package includes:
• 21 core framework classes
• 9 concrete implementations/examples
• Example scene demonstrating message flow
• PDF documentation and inline XML documentation
Nodes is compact. I see that as one of its most important features. The framework focuses on providing a flexible foundation for developers to extend, rather than enforcing a specific workflow.
The package includes a minimal demo scene that demonstrates sending and receiving messages. It is intentionally simple to serve as a reference for users with little or no prior experience with the framework. See the documentation and its tutorials for a deeper understanding of the framework.
Nodes licenses are $100.00 USD per-seat. The pricing reflects the engineering effort behind the system rather than its size. Nodes is the result of a significant amount of engineering time spent addressing subtle complexities that are easy to underestimate until you build these systems from scratch.
A large amount of the work behind Nodes is in handling edge cases, allocation pitfalls, transport quirks, and API behavior that is often undocumented or unintuitive. I believe the amount of time saved avoiding the pitfalls described above can easily justify the cost. Realistically, sorting out these kinds of issues manually can consume dozens of hours very quickly.
It is my understanding that parts of Unity’s networking/runtime stack still derive from Mono-era implementations, and once you start operating at a lower level, there are some surprisingly unintuitive behaviors within portions of the underlying System.Net stack.
In practice, there are cases where certain values or structures need to be interacted with in very specific ways before later operations behave correctly, despite there being little indication from the public API that this is necessary. There are also many situations where seemingly harmless operations introduce hidden allocations that only become visible once you start profiling.
Additionally, when working with stack-allocated types, the rules around how they can be used can feel restrictive. The framework accounts for this and is designed to allow you to write code in a natural way, without fighting the constraints imposed by ref structs and stack allocated arrays.
Although Nodes is built for experienced developers, I still endeavor to make it approachable for anyone willing to put in the effort to learn the framework. The documentation includes beginner-friendly explanations of networking fundamentals to help less experienced developers get started.
Compatibility
- Platforms: Windows and Linux
- Framework Target: .NET Standard 2.1
- Scripting Backends: Mono and IL2CPP
Website | Discord | YouTube | Documentation | Asset Store