com.unity.netcode.gameobjects@1.5.1

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).

## [1.5.1] - 2023-06-07

### Added

- Added support for serializing `NativeArray<>` and `NativeList<>` in `FastBufferReader`/`FastBufferWriter`, `BufferSerializer`, `NetworkVariable`, and RPCs. (To use `NativeList<>`, add `UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT` to your Scripting Define Symbols in `Project Settings > Player`) (#2375)
- The location of the automatically-created default network prefab list can now be configured (#2544)
- Added: Message size limits (max single message and max fragmented message) can now be set using NetworkManager.MaximumTransmissionUnitSize and NetworkManager.MaximumFragmentedMessageSize for transports that don't work with the default values (#2530)
- Added `NetworkObject.SpawnWithObservers` property (default is true) that when set to false will spawn a `NetworkObject` with no observers and will not be spawned on any client until `NetworkObject.NetworkShow` is invoked. (#2568)

### Fixed

- Fixed: Fixed a null reference in codegen in some projects (#2581)
- Fixed issue where the `OnClientDisconnected` client identifier was incorrect after a pending client connection was denied. (#2569)
- Fixed warning "Runtime Network Prefabs was not empty at initialization time." being erroneously logged when no runtime network prefabs had been added (#2565)
- Fixed issue where some temporary debug console logging was left in a merged PR. (#2562)
- Fixed the "Generate Default Network Prefabs List" setting not loading correctly and always reverting to being checked. (#2545)
- Fixed issue where users could not use NetworkSceneManager.VerifySceneBeforeLoading to exclude runtime generated scenes from client synchronization. (#2550)
- Fixed missing value on `NetworkListEvent` for `EventType.RemoveAt` events.  (#2542,#2543)
- Fixed issue where parenting a NetworkTransform under a transform with a scale other than Vector3.one would result in incorrect values on non-authoritative instances. (#2538)
- Fixed issue where a server would include scene migrated and then despawned NetworkObjects to a client that was being synchronized. (#2532)
- Fixed the inspector throwing exceptions when attempting to render `NetworkVariable`s of enum types. (#2529)
- Making a `NetworkVariable` with an `INetworkSerializable` type that doesn't meet the `new()` constraint will now create a compile-time error instead of an editor crash (#2528)
- Fixed Multiplayer Tools package installation docs page link on the NetworkManager popup. (#2526)
- Fixed an exception and error logging when two different objects are shown and hidden on the same frame (#2524)
- Fixed a memory leak in `UnityTransport` that occurred if `StartClient` failed. (#2518)
- Fixed issue where a client could throw an exception if abruptly disconnected from a network session with one or more spawned `NetworkObject`(s). (#2510)
- Fixed issue where invalid endpoint addresses were not being detected and returning false from NGO UnityTransport. (#2496)
- Fixed some errors that could occur if a connection is lost and the loss is detected when attempting to write to the socket. (#2495)

## Changed

- Adding network prefabs before NetworkManager initialization is now supported. (#2565)
- Connecting clients being synchronized now switch to the server's active scene before spawning and synchronizing NetworkObjects. (#2532)
- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.4. (#2533)
- Improved performance of NetworkBehaviour initialization by replacing reflection when initializing NetworkVariables with compile-time code generation, which should help reduce hitching during additive scene loads. (#2522)

Runtime/Configuration/NetworkConfig.cs

@@ -156,7 +156,7 @@ namespace Unity.Netcode
         public string ToBase64()
         {
             NetworkConfig config = this;
-            var writer = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp);
+            var writer = new FastBufferWriter(1024, Allocator.Temp);
             using (writer)
             {
                 writer.WriteValueSafe(config.ProtocolVersion);
@@ -228,7 +228,7 @@ namespace Unity.Netcode
                 return m_ConfigHash.Value;
             }
 
-            var writer = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, int.MaxValue);
+            var writer = new FastBufferWriter(1024, Allocator.Temp, int.MaxValue);
             using (writer)
             {
                 writer.WriteValueSafe(ProtocolVersion);

Runtime/Configuration/NetworkPrefab.cs

@@ -12,10 +12,12 @@ namespace Unity.Netcode
         /// No oeverride is present
         /// </summary>
         None,
+
         /// <summary>
         /// Override the prefab when the given SourcePrefabToOverride is requested
         /// </summary>
         Prefab,
+
         /// <summary>
         /// Override the prefab when the given SourceHashToOverride is requested
         /// Used in situations where the server assets do not exist in client builds
@@ -71,19 +73,23 @@ namespace Unity.Netcode
                 switch (Override)
                 {
                     case NetworkPrefabOverride.None:
-                        if (Prefab != null && Prefab.TryGetComponent(out NetworkObject no))
                         {
-                            return no.GlobalObjectIdHash;
-                        }
+                            if (Prefab != null && Prefab.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
 
-                        throw new InvalidOperationException("Prefab field isn't set or isn't a Network Object");
+                            throw new InvalidOperationException($"Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
                     case NetworkPrefabOverride.Prefab:
-                        if (SourcePrefabToOverride != null && SourcePrefabToOverride.TryGetComponent(out no))
                         {
-                            return no.GlobalObjectIdHash;
-                        }
+                            if (SourcePrefabToOverride != null && SourcePrefabToOverride.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
 
-                        throw new InvalidOperationException("Source Prefab field isn't set or isn't a Network Object");
+                            throw new InvalidOperationException($"Source Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
                     case NetworkPrefabOverride.Hash:
                         return SourceHashToOverride;
                     default:
@@ -102,12 +108,14 @@ namespace Unity.Netcode
                         return 0;
                     case NetworkPrefabOverride.Prefab:
                     case NetworkPrefabOverride.Hash:
-                        if (OverridingTargetPrefab != null && OverridingTargetPrefab.TryGetComponent(out NetworkObject no))
                         {
-                            return no.GlobalObjectIdHash;
-                        }
+                            if (OverridingTargetPrefab != null && OverridingTargetPrefab.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
 
-                        throw new InvalidOperationException("Target Prefab field isn't set or isn't a Network Object");
+                            throw new InvalidOperationException($"Target Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
                     default:
                         throw new ArgumentOutOfRangeException();
                 }
@@ -130,9 +138,9 @@ namespace Unity.Netcode
                 {
                     if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                     {
-                        NetworkLog.LogWarning($"{NetworkManager.PrefabDebugHelper(this)} is missing " +
-                                              $"a {nameof(NetworkObject)} component (entry will be ignored).");
+                        NetworkLog.LogWarning($"{NetworkPrefabHandler.PrefabDebugHelper(this)} is missing a {nameof(NetworkObject)} component (entry will be ignored).");
                     }
+
                     return false;
                 }
 
@@ -148,9 +156,9 @@ namespace Unity.Netcode
                         {
                             if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                             {
-                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourceHashToOverride)} is zero " +
-                                    "(entry will be ignored).");
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourceHashToOverride)} is zero (entry will be ignored).");
                             }
+
                             return false;
                         }
 
@@ -178,9 +186,9 @@ namespace Unity.Netcode
                         {
                             if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                             {
-                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} ({SourcePrefabToOverride.name}) " +
-                                    $"is missing a {nameof(NetworkObject)} component (entry will be ignored).");
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} ({SourcePrefabToOverride.name}) is missing a {nameof(NetworkObject)} component (entry will be ignored).");
                             }
+
                             return false;
                         }
 
@@ -195,6 +203,7 @@ namespace Unity.Netcode
                 {
                     NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(OverridingTargetPrefab)} is null!");
                 }
+
                 switch (Override)
                 {
                     case NetworkPrefabOverride.Hash:
@@ -208,8 +217,10 @@ namespace Unity.Netcode
                             break;
                         }
                 }
+
                 return false;
             }
+
             return true;
         }
 

Runtime/Configuration/NetworkPrefabs.cs

@@ -38,10 +38,15 @@ namespace Unity.Netcode
         [NonSerialized]
         private List<NetworkPrefab> m_Prefabs = new List<NetworkPrefab>();
 
+        [NonSerialized]
+        private List<NetworkPrefab> m_RuntimeAddedPrefabs = new List<NetworkPrefab>();
+
         private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
         {
             if (AddPrefabRegistration(networkPrefab))
             {
+                // Don't add this to m_RuntimeAddedPrefabs
+                // This prefab is now in the PrefabList, so if we shutdown and initialize again, we'll pick it up from there.
                 m_Prefabs.Add(networkPrefab);
             }
         }
@@ -67,8 +72,6 @@ namespace Unity.Netcode
                 list.OnAdd -= AddTriggeredByNetworkPrefabList;
                 list.OnRemove -= RemoveTriggeredByNetworkPrefabList;
             }
-
-            NetworkPrefabsLists.Clear();
         }
 
         /// <summary>
@@ -77,13 +80,7 @@ namespace Unity.Netcode
         /// </summary>
         public void Initialize(bool warnInvalid = true)
         {
-            if (NetworkPrefabsLists.Count != 0 && m_Prefabs.Count > 0)
-            {
-                NetworkLog.LogWarning("Runtime Network Prefabs was not empty at initialization time. Network " +
-                    "Prefab registrations made before initialization will be replaced by NetworkPrefabsList.");
-                m_Prefabs.Clear();
-            }
-
+            m_Prefabs.Clear();
             foreach (var list in NetworkPrefabsLists)
             {
                 list.OnAdd += AddTriggeredByNetworkPrefabList;
@@ -93,7 +90,7 @@ namespace Unity.Netcode
             NetworkPrefabOverrideLinks.Clear();
             OverrideToNetworkPrefab.Clear();
 
-            var prefabs = NetworkPrefabsLists.Count != 0 ? new List<NetworkPrefab>() : m_Prefabs;
+            var prefabs = new List<NetworkPrefab>();
 
             if (NetworkPrefabsLists.Count != 0)
             {
@@ -126,6 +123,18 @@ namespace Unity.Netcode
                 }
             }
 
+            foreach (var networkPrefab in m_RuntimeAddedPrefabs)
+            {
+                if (AddPrefabRegistration(networkPrefab))
+                {
+                    m_Prefabs.Add(networkPrefab);
+                }
+                else
+                {
+                    removeList?.Add(networkPrefab);
+                }
+            }
+
             // Clear out anything that is invalid or not used
             if (removeList?.Count > 0)
             {
@@ -152,6 +161,7 @@ namespace Unity.Netcode
             if (AddPrefabRegistration(networkPrefab))
             {
                 m_Prefabs.Add(networkPrefab);
+                m_RuntimeAddedPrefabs.Add(networkPrefab);
                 return true;
             }
 
@@ -175,6 +185,7 @@ namespace Unity.Netcode
             }
 
             m_Prefabs.Remove(prefab);
+            m_RuntimeAddedPrefabs.Remove(prefab);
             OverrideToNetworkPrefab.Remove(prefab.TargetPrefabGlobalObjectIdHash);
             NetworkPrefabOverrideLinks.Remove(prefab.SourcePrefabGlobalObjectIdHash);
         }
@@ -203,6 +214,15 @@ namespace Unity.Netcode
                     return;
                 }
             }
+
+            for (int i = 0; i < m_RuntimeAddedPrefabs.Count; i++)
+            {
+                if (m_RuntimeAddedPrefabs[i].Prefab == prefab)
+                {
+                    Remove(m_RuntimeAddedPrefabs[i]);
+                    return;
+                }
+            }
         }
 
         /// <summary>

Runtime/Connection/NetworkClient.cs

@@ -7,30 +7,74 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkClient
     {
+        /// <summary>
+        /// Returns true if the session instance is considered a server
+        /// </summary>
+        internal bool IsServer { get; set; }
+
+        /// <summary>
+        /// Returns true if the session instance is considered a client
+        /// </summary>
+        internal bool IsClient { get; set; }
+
+        /// <summary>
+        /// Returns true if the session instance is considered a host
+        /// </summary>
+        internal bool IsHost => IsClient && IsServer;
+
+        /// <summary>
+        /// When true, the client is connected, approved, and synchronized with
+        /// the server.
+        /// </summary>
+        internal bool IsConnected { get; set; }
+
+        /// <summary>
+        /// Is true when the client has been approved.
+        /// </summary>
+        internal bool IsApproved { get; set; }
+
         /// <summary>
         /// The ClientId of the NetworkClient
         /// </summary>
+        // TODO-2023-Q2: Determine if we want to make this property a public get and internal/private set
+        // There is no reason for a user to want to set this, but this will fail the package-validation-suite
         public ulong ClientId;
 
         /// <summary>
         /// The PlayerObject of the Client
         /// </summary>
+        // TODO-2023-Q2: Determine if we want to make this property a public get and internal/private set
+        // There is no reason for a user to want to set this, but this will fail the package-validation-suite
         public NetworkObject PlayerObject;
 
         /// <summary>
-        /// The NetworkObject's owned by this Client
+        /// The list of NetworkObject's owned by this client instance
         /// </summary>
-        public List<NetworkObject> OwnedObjects
-        {
-            get
-            {
-                if (PlayerObject != null && PlayerObject.NetworkManager != null && PlayerObject.NetworkManager.IsListening)
-                {
-                    return PlayerObject.NetworkManager.SpawnManager.GetClientOwnedObjects(ClientId);
-                }
+        public List<NetworkObject> OwnedObjects => IsConnected ? SpawnManager.GetClientOwnedObjects(ClientId) : new List<NetworkObject>();
 
-                return new List<NetworkObject>();
+        internal NetworkSpawnManager SpawnManager { get; private set; }
+
+        internal void SetRole(bool isServer, bool isClient, NetworkManager networkManager = null)
+        {
+            IsServer = isServer;
+            IsClient = isClient;
+            if (!IsServer && !isClient)
+            {
+                PlayerObject = null;
+                ClientId = 0;
+                IsConnected = false;
+                IsApproved = false;
             }
+
+            if (networkManager != null)
+            {
+                SpawnManager = networkManager.SpawnManager;
+            }
+        }
+
+        internal void AssignPlayerObject(ref NetworkObject networkObject)
+        {
+            PlayerObject = networkObject;
         }
     }
 }

Runtime/Connection/NetworkConnectionManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d98eff74d73bc2a42bd5624c47ce8fe1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Connection/PendingClient.cs

@@ -1,10 +1,15 @@
+using UnityEngine;
+
 namespace Unity.Netcode
 {
     /// <summary>
+    /// Server-Side Only:
     /// A class representing a client that is currently in the process of connecting
     /// </summary>
     public class PendingClient
     {
+        internal Coroutine ApprovalCoroutine = null;
+
         /// <summary>
         /// The ClientId of the client
         /// </summary>

Runtime/Core/ComponentFactory.cs

@@ -51,7 +51,7 @@ namespace Unity.Netcode
         /// </summary>
         public static void SetDefaults()
         {
-            SetDefault<IDeferredMessageManager>(networkManager => new DeferredMessageManager(networkManager));
+            SetDefault<IDeferredNetworkMessageManager>(networkManager => new DeferredMessageManager(networkManager));
 
             SetDefault<IRealTimeProvider>(networkManager => new RealTimeProvider());
         }

Runtime/Core/NetworkBehaviour.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
 using Unity.Collections;
 using UnityEngine;
 
@@ -65,7 +63,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
+                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -86,7 +84,7 @@ namespace Unity.Netcode
                     SystemOwner = NetworkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
-                    Header = new MessageHeader(),
+                    Header = new NetworkMessageHeader(),
                     SerializedHeaderSize = 0,
                     MessageSize = 0
                 };
@@ -96,7 +94,7 @@ namespace Unity.Netcode
             }
             else
             {
-                rpcWriteSize = NetworkManager.SendMessage(ref serverRpcMessage, networkDelivery, NetworkManager.ServerClientId);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref serverRpcMessage, networkDelivery, NetworkManager.ServerClientId);
             }
 
             bufferWriter.Dispose();
@@ -146,7 +144,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
+                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -176,7 +174,7 @@ namespace Unity.Netcode
                     }
                 }
 
-                rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
             }
             else if (clientRpcParams.Send.TargetClientIdsNativeArray != null)
             {
@@ -195,7 +193,7 @@ namespace Unity.Netcode
                     }
                 }
 
-                rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
             }
             else
             {
@@ -208,7 +206,7 @@ namespace Unity.Netcode
                         shouldSendToHost = true;
                         continue;
                     }
-                    rpcWriteSize = NetworkManager.MessagingSystem.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
+                    rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
                 }
             }
 
@@ -223,7 +221,7 @@ namespace Unity.Netcode
                     SystemOwner = NetworkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
-                    Header = new MessageHeader(),
+                    Header = new NetworkMessageHeader(),
                     SerializedHeaderSize = 0,
                     MessageSize = 0
                 };
@@ -277,6 +275,14 @@ namespace Unity.Netcode
 #endif
         }
 
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal static NativeList<T> __createNativeList<T>() where T : unmanaged
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            return new NativeList<T>(Allocator.Temp);
+        }
+
         internal string GenerateObserverErrorMessage(ClientRpcParams clientRpcParams, ulong targetClientId)
         {
             var containerNameHoldingId = clientRpcParams.Send.TargetClientIds != null ? nameof(ClientRpcParams.Send.TargetClientIds) : nameof(ClientRpcParams.Send.TargetClientIdsNativeArray);
@@ -551,35 +557,25 @@ namespace Unity.Netcode
 
         private readonly List<HashSet<int>> m_DeliveryMappedNetworkVariableIndices = new List<HashSet<int>>();
         private readonly List<NetworkDelivery> m_DeliveryTypesForNetworkVariableGroups = new List<NetworkDelivery>();
+
+        // RuntimeAccessModifiersILPP will make this `protected`
         internal readonly List<NetworkVariableBase> NetworkVariableFields = new List<NetworkVariableBase>();
 
-        private static Dictionary<Type, FieldInfo[]> s_FieldTypes = new Dictionary<Type, FieldInfo[]>();
-
-        private static FieldInfo[] GetFieldInfoForType(Type type)
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal virtual void __initializeVariables()
+#pragma warning restore IDE1006 // restore naming rule violation check
         {
-            if (!s_FieldTypes.ContainsKey(type))
-            {
-                s_FieldTypes.Add(type, GetFieldInfoForTypeRecursive(type));
-            }
-
-            return s_FieldTypes[type];
+            // ILPP generates code for all NetworkBehaviour subtypes to initialize each type's network variables.
         }
 
-        private static FieldInfo[] GetFieldInfoForTypeRecursive(Type type, List<FieldInfo> list = null)
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        // Using this method here because ILPP doesn't seem to let us do visibility modification on properties.
+        internal void __nameNetworkVariable(NetworkVariableBase variable, string varName)
+#pragma warning restore IDE1006 // restore naming rule violation check
         {
-            if (list == null)
-            {
-                list = new List<FieldInfo>();
-            }
-
-            list.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
-
-            if (type.BaseType != null && type.BaseType != typeof(NetworkBehaviour))
-            {
-                return GetFieldInfoForTypeRecursive(type.BaseType, list);
-            }
-
-            return list.OrderBy(x => x.Name, StringComparer.Ordinal).ToArray();
+            variable.Name = varName;
         }
 
         internal void InitializeVariables()
@@ -591,22 +587,7 @@ namespace Unity.Netcode
 
             m_VarInit = true;
 
-            var sortedFields = GetFieldInfoForType(GetType());
-            for (int i = 0; i < sortedFields.Length; i++)
-            {
-                var fieldType = sortedFields[i].FieldType;
-                if (fieldType.IsSubclassOf(typeof(NetworkVariableBase)))
-                {
-                    var instance = (NetworkVariableBase)sortedFields[i].GetValue(this) ?? throw new Exception($"{GetType().FullName}.{sortedFields[i].Name} cannot be null. All {nameof(NetworkVariableBase)} instances must be initialized.");
-                    instance.Initialize(this);
-
-                    var instanceNameProperty = fieldType.GetProperty(nameof(NetworkVariableBase.Name));
-                    var sanitizedVariableName = sortedFields[i].Name.Replace("<", string.Empty).Replace(">k__BackingField", string.Empty);
-                    instanceNameProperty?.SetValue(instance, sanitizedVariableName);
-
-                    NetworkVariableFields.Add(instance);
-                }
-            }
+            __initializeVariables();
 
             {
                 // Create index map for delivery types
@@ -718,7 +699,7 @@ namespace Unity.Netcode
                     // so we don't have to do this serialization work if we're not going to use the result.
                     if (IsServer && targetClientId == NetworkManager.ServerClientId)
                     {
-                        var tmpWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, MessagingSystem.FRAGMENTED_MESSAGE_MAX_SIZE);
+                        var tmpWriter = new FastBufferWriter(NetworkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, NetworkManager.MessageManager.FragmentedMessageMaxSize);
                         using (tmpWriter)
                         {
                             message.Serialize(tmpWriter, message.Version);
@@ -726,7 +707,7 @@ namespace Unity.Netcode
                     }
                     else
                     {
-                        NetworkManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
+                        NetworkManager.ConnectionManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
                     }
                 }
             }

Runtime/Core/NetworkBehaviourUpdater.cs

@@ -8,6 +8,8 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkBehaviourUpdater
     {
+        private NetworkManager m_NetworkManager;
+        private NetworkConnectionManager m_ConnectionManager;
         private HashSet<NetworkObject> m_DirtyNetworkObjects = new HashSet<NetworkObject>();
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
@@ -19,7 +21,7 @@ namespace Unity.Netcode
             m_DirtyNetworkObjects.Add(networkObject);
         }
 
-        internal void NetworkBehaviourUpdate(NetworkManager networkManager)
+        internal void NetworkBehaviourUpdate()
         {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             m_NetworkBehaviourUpdate.Begin();
@@ -30,7 +32,7 @@ namespace Unity.Netcode
                 // trying to process them, even if they were previously marked as dirty.
                 m_DirtyNetworkObjects.RemoveWhere((sobj) => sobj == null);
 
-                if (networkManager.IsServer)
+                if (m_ConnectionManager.LocalClient.IsServer)
                 {
                     foreach (var dirtyObj in m_DirtyNetworkObjects)
                     {
@@ -39,9 +41,9 @@ namespace Unity.Netcode
                             dirtyObj.ChildNetworkBehaviours[k].PreVariableUpdate();
                         }
 
-                        for (int i = 0; i < networkManager.ConnectedClientsList.Count; i++)
+                        for (int i = 0; i < m_ConnectionManager.ConnectedClientsList.Count; i++)
                         {
-                            var client = networkManager.ConnectedClientsList[i];
+                            var client = m_ConnectionManager.ConnectedClientsList[i];
 
                             if (dirtyObj.IsNetworkVisibleTo(client.ClientId))
                             {
@@ -104,5 +106,26 @@ namespace Unity.Netcode
             }
         }
 
+        internal void Initialize(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+            m_ConnectionManager = networkManager.ConnectionManager;
+            m_NetworkManager.NetworkTickSystem.Tick += NetworkBehaviourUpdater_Tick;
+        }
+
+        internal void Shutdown()
+        {
+            m_NetworkManager.NetworkTickSystem.Tick -= NetworkBehaviourUpdater_Tick;
+        }
+
+        // TODO 2023-Q2: Order of operations requires NetworkVariable updates first then showing NetworkObjects
+        private void NetworkBehaviourUpdater_Tick()
+        {
+            // First update NetworkVariables
+            NetworkBehaviourUpdate();
+
+            // Then show any NetworkObjects queued to be made visible/shown
+            m_NetworkManager.SpawnManager.HandleNetworkObjectShow();
+        }
     }
 }

Runtime/Core/NetworkObject.cs

@@ -188,6 +188,12 @@ namespace Unity.Netcode
         /// </remarks>
         public Action OnMigratedToNewScene;
 
+        /// <summary>
+        /// When set to false, the NetworkObject will be spawned with no observers initially (other than the server)
+        /// </summary>
+        [Tooltip("When false, the NetworkObject will spawn with no observers initially. (default is true)")]
+        public bool SpawnWithObservers = true;
+
         /// <summary>
         /// Delegate type for checking visibility
         /// </summary>
@@ -361,8 +367,7 @@ namespace Unity.Netcode
                 }
                 return;
             }
-
-            NetworkManager.MarkObjectForShowingTo(this, clientId);
+            NetworkManager.SpawnManager.MarkObjectForShowingTo(this, clientId);
             Observers.Add(clientId);
         }
 
@@ -452,7 +457,7 @@ namespace Unity.Netcode
                 throw new VisibilityChangeException("Cannot hide an object from the server");
             }
 
-            if (!NetworkManager.RemoveObjectFromShowingTo(this, clientId))
+            if (!NetworkManager.SpawnManager.RemoveObjectFromShowingTo(this, clientId))
             {
                 if (!Observers.Contains(clientId))
                 {
@@ -466,7 +471,7 @@ namespace Unity.Netcode
                     DestroyGameObject = !IsSceneObject.Value
                 };
                 // Send destroy call
-                var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
+                var size = NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
                 NetworkManager.NetworkMetrics.TrackObjectDestroySent(clientId, this, size);
             }
         }
@@ -532,14 +537,30 @@ namespace Unity.Netcode
 
         private void OnDestroy()
         {
-            if (NetworkManager != null && NetworkManager.IsListening && NetworkManager.IsServer == false && IsSpawned &&
-                (IsSceneObject == null || (IsSceneObject.Value != true)))
+            // If no NetworkManager is assigned, then just exit early
+            if (!NetworkManager)
             {
-                throw new NotServerException($"Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
+                return;
             }
 
-            if (NetworkManager != null && NetworkManager.SpawnManager != null &&
-                NetworkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
+            if (NetworkManager.IsListening && !NetworkManager.IsServer && IsSpawned &&
+                (IsSceneObject == null || (IsSceneObject.Value != true)))
+            {
+                // Clients should not despawn NetworkObjects while connected to a session, but we don't want to destroy the current call stack
+                // if this happens. Instead, we should just generate a network log error and exit early (as long as we are not shutting down).
+                if (!NetworkManager.ShutdownInProgress)
+                {
+                    // Since we still have a session connection, log locally and on the server to inform user of this issue.
+                    if (NetworkManager.LogLevel <= LogLevel.Error)
+                    {
+                        NetworkLog.LogErrorServer($"Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
+                    }
+                    return;
+                }
+                // Otherwise, clients can despawn NetworkObjects while shutting down and should not generate any messages when this happens
+            }
+
+            if (NetworkManager.SpawnManager != null && NetworkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
             {
                 if (this == networkObject)
                 {
@@ -898,7 +919,7 @@ namespace Unity.Netcode
                     }
                 }
 
-                NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientIds, idx);
+                NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientIds, idx);
             }
         }
 

Runtime/Logging/NetworkLog.cs

@@ -51,35 +51,58 @@ namespace Unity.Netcode
         /// <param name="message">The message to log</param>
         public static void LogErrorServer(string message) => LogServer(message, LogType.Error);
 
+        internal static NetworkManager NetworkManagerOverride;
+
         private static void LogServer(string message, LogType logType)
         {
+            var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton;
             // Get the sender of the local log
-            ulong localId = NetworkManager.Singleton != null ? NetworkManager.Singleton.LocalClientId : 0;
-
+            ulong localId = networkManager?.LocalClientId ?? 0;
+            bool isServer = networkManager?.IsServer ?? true;
             switch (logType)
             {
                 case LogType.Info:
-                    LogInfoServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogInfoServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogInfo(message);
+                    }
                     break;
                 case LogType.Warning:
-                    LogWarningServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogWarningServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogWarning(message);
+                    }
                     break;
                 case LogType.Error:
-                    LogErrorServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogErrorServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogError(message);
+                    }
                     break;
             }
 
-            if (NetworkManager.Singleton != null && !NetworkManager.Singleton.IsServer && NetworkManager.Singleton.NetworkConfig.EnableNetworkLogs)
+            if (!isServer && networkManager.NetworkConfig.EnableNetworkLogs)
             {
-
                 var networkMessage = new ServerLogMessage
                 {
                     LogType = logType,
                     Message = message
                 };
-                var size = NetworkManager.Singleton.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
+                var size = networkManager.ConnectionManager.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
 
-                NetworkManager.Singleton.NetworkMetrics.TrackServerLogSent(NetworkManager.ServerClientId, (uint)logType, size);
+                networkManager.NetworkMetrics.TrackServerLogSent(NetworkManager.ServerClientId, (uint)logType, size);
             }
         }
 

Runtime/Messaging/CustomMessageManager.cs

@@ -90,7 +90,7 @@ namespace Unity.Netcode
             {
                 SendData = messageBuffer
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientIds);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientIds);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
@@ -123,7 +123,7 @@ namespace Unity.Netcode
             {
                 SendData = messageBuffer
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientId);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientId);
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
             {
@@ -275,7 +275,7 @@ namespace Unity.Netcode
                 Hash = hash,
                 SendData = messageStream,
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientId);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientId);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
@@ -333,7 +333,7 @@ namespace Unity.Netcode
                 Hash = hash,
                 SendData = messageStream
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientIds);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientIds);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)

Runtime/Messaging/DefaultMessageSender.cs

@@ -0,0 +1,26 @@
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// Default NetworkTransport Message Sender
+    /// <see cref="NetworkMessageManager"/>
+    /// </summary>
+    internal class DefaultMessageSender : INetworkMessageSender
+    {
+        private NetworkTransport m_NetworkTransport;
+        private NetworkConnectionManager m_ConnectionManager;
+
+        public DefaultMessageSender(NetworkManager manager)
+        {
+            m_NetworkTransport = manager.NetworkConfig.NetworkTransport;
+            m_ConnectionManager = manager.ConnectionManager;
+        }
+
+        public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
+        {
+            var sendBuffer = batchData.ToTempByteArray();
+
+            m_NetworkTransport.Send(m_ConnectionManager.ClientIdToTransportId(clientId), sendBuffer, delivery);
+        }
+    }
+}

Runtime/Messaging/DefaultMessageSender.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5ea6bdd38832d9947bb21c4b35bf61d0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Messaging/DeferredMessageManager.cs

@@ -3,12 +3,12 @@ using Unity.Collections;
 
 namespace Unity.Netcode
 {
-    internal class DeferredMessageManager : IDeferredMessageManager
+    internal class DeferredMessageManager : IDeferredNetworkMessageManager
     {
         protected struct TriggerData
         {
             public FastBufferReader Reader;
-            public MessageHeader Header;
+            public NetworkMessageHeader Header;
             public ulong SenderId;
             public float Timestamp;
             public int SerializedHeaderSize;
@@ -19,7 +19,7 @@ namespace Unity.Netcode
             public NativeList<TriggerData> TriggerData;
         }
 
-        protected readonly Dictionary<IDeferredMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>> m_Triggers = new Dictionary<IDeferredMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>>();
+        protected readonly Dictionary<IDeferredNetworkMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>> m_Triggers = new Dictionary<IDeferredNetworkMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>>();
 
         private readonly NetworkManager m_NetworkManager;
 
@@ -36,7 +36,7 @@ namespace Unity.Netcode
         /// There is a one second maximum lifetime of triggers to avoid memory leaks. After one second has passed
         /// without the requested object ID being spawned, the triggers for it are automatically deleted.
         /// </summary>
-        public virtual unsafe void DeferMessage(IDeferredMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
+        public virtual unsafe void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
         {
             if (!m_Triggers.TryGetValue(trigger, out var triggers))
             {
@@ -90,7 +90,7 @@ namespace Unity.Netcode
             }
         }
 
-        protected virtual void PurgeTrigger(IDeferredMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
+        protected virtual void PurgeTrigger(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
         {
             if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
             {
@@ -105,7 +105,7 @@ namespace Unity.Netcode
             triggerInfo.TriggerData.Dispose();
         }
 
-        public virtual void ProcessTriggers(IDeferredMessageManager.TriggerType trigger, ulong key)
+        public virtual void ProcessTriggers(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
         {
             if (m_Triggers.TryGetValue(trigger, out var triggers))
             {
@@ -116,7 +116,7 @@ namespace Unity.Netcode
                     foreach (var deferredMessage in triggerInfo.TriggerData)
                     {
                         // Reader will be disposed within HandleMessage
-                        m_NetworkManager.MessagingSystem.HandleMessage(deferredMessage.Header, deferredMessage.Reader, deferredMessage.SenderId, deferredMessage.Timestamp, deferredMessage.SerializedHeaderSize);
+                        m_NetworkManager.ConnectionManager.MessageManager.HandleMessage(deferredMessage.Header, deferredMessage.Reader, deferredMessage.SenderId, deferredMessage.Timestamp, deferredMessage.SerializedHeaderSize);
                     }
 
                     triggerInfo.TriggerData.Dispose();

Runtime/Messaging/DisconnectReasonMessage.cs

@@ -10,11 +10,9 @@ namespace Unity.Netcode
         {
             string reasonSent = Reason ?? string.Empty;
 
-            // Since we don't send a ConnectionApprovedMessage, the version for this message is encded with the message
-            // itself. However, note that we HAVE received a ConnectionRequestMessage, so we DO have a valid targetVersion
-            // on this side of things - we just have to make sure the receiving side knows what version we sent it,
-            // since whoever has the higher version number is responsible for versioning and they may be the one
-            // with the higher version number.
+            // Since we don't send a ConnectionApprovedMessage, the version for this message is encded with the message itself.
+            // However, note that we HAVE received a ConnectionRequestMessage, so we DO have a valid targetVersion on this side of things.
+            // We just have to make sure the receiving side knows what version we sent it, since whoever has the higher version number is responsible for versioning and they may be the one with the higher version number.
             BytePacker.WriteValueBitPacked(writer, Version);
 
             if (writer.TryBeginWrite(FastBufferWriter.GetWriteSize(reasonSent)))
@@ -24,15 +22,14 @@ namespace Unity.Netcode
             else
             {
                 writer.WriteValueSafe(string.Empty);
-                NetworkLog.LogWarning(
-                    "Disconnect reason didn't fit. Disconnected without sending a reason. Consider shortening the reason string.");
+                NetworkLog.LogWarning("Disconnect reason didn't fit. Disconnected without sending a reason. Consider shortening the reason string.");
             }
         }
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
-            // Since we don't get a ConnectionApprovedMessage, the version for this message is encded with the message
-            // itself. This will override what we got from MessagingSystem... which will always be 0 here.
+            // Since we don't get a ConnectionApprovedMessage, the version for this message is encded with the message itself.
+            // This will override what we got from MessageManager... which will always be 0 here.
             ByteUnpacker.ReadValueBitPacked(reader, out receivedMessageVersion);
             reader.ReadValueSafe(out Reason);
             return true;
@@ -40,7 +37,7 @@ namespace Unity.Netcode
 
         public void Handle(ref NetworkContext context)
         {
-            ((NetworkManager)context.SystemOwner).DisconnectReason = Reason;
+            ((NetworkManager)context.SystemOwner).ConnectionManager.DisconnectReason = Reason;
         }
     };
 }

Runtime/Messaging/IDeferredNetworkMessageManager.cs

@@ -1,6 +1,6 @@
 namespace Unity.Netcode
 {
-    internal interface IDeferredMessageManager
+    internal interface IDeferredNetworkMessageManager
     {
         internal enum TriggerType
         {

Runtime/Messaging/ILPPMessageProvider.cs

@@ -2,14 +2,14 @@ using System.Collections.Generic;
 
 namespace Unity.Netcode
 {
-    internal struct ILPPMessageProvider : IMessageProvider
+    internal struct ILPPMessageProvider : INetworkMessageProvider
     {
 #pragma warning disable IDE1006 // disable naming rule violation check
         // This is NOT modified by RuntimeAccessModifiersILPP right now, but is populated by ILPP.
-        internal static readonly List<MessagingSystem.MessageWithHandler> __network_message_types = new List<MessagingSystem.MessageWithHandler>();
+        internal static readonly List<NetworkMessageManager.MessageWithHandler> __network_message_types = new List<NetworkMessageManager.MessageWithHandler>();
 #pragma warning restore IDE1006 // restore naming rule violation check
 
-        public List<MessagingSystem.MessageWithHandler> GetMessages()
+        public List<NetworkMessageManager.MessageWithHandler> GetMessages()
         {
             return __network_message_types;
         }

Runtime/Messaging/IMessageProvider.cs

@@ -1,9 +0,0 @@
-using System.Collections.Generic;
-
-namespace Unity.Netcode
-{
-    internal interface IMessageProvider
-    {
-        List<MessagingSystem.MessageWithHandler> GetMessages();
-    }
-}

Runtime/Messaging/INetworkMessage.cs

@@ -1,4 +1,3 @@
-using Unity.Collections;
 
 namespace Unity.Netcode
 {

Runtime/Messaging/INetworkMessageProvider.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Unity.Netcode
+{
+    internal interface INetworkMessageProvider
+    {
+        List<NetworkMessageManager.MessageWithHandler> GetMessages();
+    }
+}

Runtime/Messaging/INetworkMessageSender.cs

@@ -1,6 +1,6 @@
 namespace Unity.Netcode
 {
-    internal interface IMessageSender
+    internal interface INetworkMessageSender
     {
         void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData);
     }

Runtime/Messaging/Messages/ChangeOwnershipMessage.cs

@@ -24,7 +24,7 @@ namespace Unity.Netcode
             ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId);
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
 

Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -84,18 +84,18 @@ namespace Unity.Netcode
             {
                 var messageVersion = new MessageVersionData();
                 messageVersion.Deserialize(reader);
-                networkManager.MessagingSystem.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
+                networkManager.ConnectionManager.MessageManager.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
                 messageHashesInOrder[i] = messageVersion.Hash;
 
                 // Update the received version since this message will always be passed version 0, due to the map not
                 // being initialized until just now.
-                var messageType = networkManager.MessagingSystem.GetMessageForHash(messageVersion.Hash);
+                var messageType = networkManager.ConnectionManager.MessageManager.GetMessageForHash(messageVersion.Hash);
                 if (messageType == typeof(ConnectionApprovedMessage))
                 {
                     receivedMessageVersion = messageVersion.Version;
                 }
             }
-            networkManager.MessagingSystem.SetServerMessageOrder(messageHashesInOrder);
+            networkManager.ConnectionManager.MessageManager.SetServerMessageOrder(messageHashesInOrder);
             messageHashesInOrder.Dispose();
             // ============================================================
             // END FORBIDDEN SEGMENT
@@ -117,8 +117,11 @@ namespace Unity.Netcode
             networkManager.NetworkTimeSystem.Reset(time.Time, 0.15f); // Start with a constant RTT of 150 until we receive values from the transport.
             networkManager.NetworkTickSystem.Reset(networkManager.NetworkTimeSystem.LocalTime, networkManager.NetworkTimeSystem.ServerTime);
 
-            networkManager.LocalClient = new NetworkClient() { ClientId = networkManager.LocalClientId };
-            networkManager.IsApproved = true;
+            networkManager.ConnectionManager.LocalClient.SetRole(false, true, networkManager);
+            networkManager.ConnectionManager.LocalClient.IsApproved = true;
+            networkManager.ConnectionManager.LocalClient.ClientId = OwnerClientId;
+            // Stop the client-side approval timeout coroutine since we are approved.
+            networkManager.ConnectionManager.StopClientApprovalCoroutine();
 
             // Only if scene management is disabled do we handle NetworkObject synchronization at this point
             if (!networkManager.NetworkConfig.EnableSceneManagement)
@@ -138,7 +141,7 @@ namespace Unity.Netcode
                 // Mark the client being connected
                 networkManager.IsConnectedClient = true;
                 // When scene management is disabled we notify after everything is synchronized
-                networkManager.InvokeOnClientConnectedCallback(context.SenderId);
+                networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
             }
         }
     }

Runtime/Messaging/Messages/ConnectionRequestMessage.cs

@@ -59,11 +59,11 @@ namespace Unity.Netcode
             {
                 var messageVersion = new MessageVersionData();
                 messageVersion.Deserialize(reader);
-                networkManager.MessagingSystem.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
+                networkManager.ConnectionManager.MessageManager.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
 
                 // Update the received version since this message will always be passed version 0, due to the map not
                 // being initialized until just now.
-                var messageType = networkManager.MessagingSystem.GetMessageForHash(messageVersion.Hash);
+                var messageType = networkManager.ConnectionManager.MessageManager.GetMessageForHash(messageVersion.Hash);
                 if (messageType == typeof(ConnectionRequestMessage))
                 {
                     receivedMessageVersion = messageVersion.Version;
@@ -135,7 +135,7 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             var senderId = context.SenderId;
 
-            if (networkManager.PendingClients.TryGetValue(senderId, out PendingClient client))
+            if (networkManager.ConnectionManager.PendingClients.TryGetValue(senderId, out PendingClient client))
             {
                 // Set to pending approval to prevent future connection requests from being approved
                 client.ConnectionState = PendingClient.State.PendingApproval;
@@ -143,17 +143,8 @@ namespace Unity.Netcode
 
             if (networkManager.NetworkConfig.ConnectionApproval)
             {
-                // Note: Delegate creation allocates.
-                // Note: ToArray() also allocates. :(
-                var response = new NetworkManager.ConnectionApprovalResponse();
-                networkManager.ClientsToApprove[senderId] = response;
-
-                networkManager.ConnectionApprovalCallback(
-                    new NetworkManager.ConnectionApprovalRequest
-                    {
-                        Payload = ConnectionData,
-                        ClientNetworkId = senderId
-                    }, response);
+                var messageRequest = this;
+                networkManager.ConnectionManager.ApproveConnection(ref messageRequest, ref context);
             }
             else
             {
@@ -162,7 +153,7 @@ namespace Unity.Netcode
                     Approved = true,
                     CreatePlayerObject = networkManager.NetworkConfig.PlayerPrefab != null
                 };
-                networkManager.HandleConnectionApproval(senderId, response);
+                networkManager.ConnectionManager.HandleConnectionApproval(senderId, response);
             }
         }
     }

Runtime/Messaging/Messages/CreateObjectMessage.cs

@@ -23,7 +23,7 @@ namespace Unity.Netcode
             ObjectInfo.Deserialize(reader);
             if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectInfo))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context);
                 return false;
             }
             m_ReceivedNetworkVariableData = reader;

Runtime/Messaging/Messages/DestroyObjectMessage.cs

@@ -26,7 +26,7 @@ namespace Unity.Netcode
 
             if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
             return true;

Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -67,8 +67,8 @@ namespace Unity.Netcode
                 // The object containing the behaviour we're about to process is about to be shown to this client
                 // As a result, the client will get the fully serialized NetworkVariable and would be confused by
                 // an extraneous delta
-                if (NetworkBehaviour.NetworkManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
-                    NetworkBehaviour.NetworkManager.ObjectsToShowToClient[TargetClientId]
+                if (NetworkBehaviour.NetworkManager.SpawnManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
+                    NetworkBehaviour.NetworkManager.SpawnManager.ObjectsToShowToClient[TargetClientId]
                     .Contains(NetworkBehaviour.NetworkObject))
                 {
                     shouldWrite = false;
@@ -90,7 +90,7 @@ namespace Unity.Netcode
                 {
                     if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
-                        var tempWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, MessagingSystem.FRAGMENTED_MESSAGE_MAX_SIZE);
+                        var tempWriter = new FastBufferWriter(NetworkBehaviour.NetworkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, NetworkBehaviour.NetworkManager.MessageManager.FragmentedMessageMaxSize);
                         NetworkBehaviour.NetworkVariableFields[i].WriteDelta(tempWriter);
                         BytePacker.WriteValueBitPacked(writer, tempWriter.Length);
 
@@ -234,7 +234,7 @@ namespace Unity.Netcode
             }
             else
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context);
             }
         }
     }

Runtime/Messaging/Messages/ParentSyncMessage.cs

@@ -85,7 +85,7 @@ namespace Unity.Netcode
 
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
             return true;

Runtime/Messaging/Messages/RpcMessages.cs

@@ -23,7 +23,7 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(metadata.NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context);
                 return false;
             }
 

Runtime/Messaging/NetworkBatchHeader.cs

@@ -3,7 +3,7 @@ namespace Unity.Netcode
     /// <summary>
     /// Header placed at the start of each message batch
     /// </summary>
-    internal struct BatchHeader : INetworkSerializeByMemcpy
+    internal struct NetworkBatchHeader : INetworkSerializeByMemcpy
     {
         internal const ushort MagicValue = 0x1160;
         /// <summary>

Runtime/Messaging/NetworkContext.cs

@@ -6,7 +6,7 @@ namespace Unity.Netcode
     internal ref struct NetworkContext
     {
         /// <summary>
-        /// An opaque object used to represent the owner of the MessagingSystem that's receiving the message.
+        /// An opaque object used to represent the owner of the NetworkMessageManager that's receiving the message.
         /// Outside of testing environments, the type of this variable will be <see cref="NetworkManager"/>
         /// </summary>
         public object SystemOwner;
@@ -24,7 +24,7 @@ namespace Unity.Netcode
         /// <summary>
         /// The header data that was sent with the message
         /// </summary>
-        public MessageHeader Header;
+        public NetworkMessageHeader Header;
 
         /// <summary>
         /// The actual serialized size of the header when packed into the buffer

Runtime/Messaging/NetworkManagerHooks.cs

@@ -0,0 +1,119 @@
+using System;
+
+namespace Unity.Netcode
+{
+    internal class NetworkManagerHooks : INetworkHooks
+    {
+        private NetworkManager m_NetworkManager;
+
+        internal NetworkManagerHooks(NetworkManager manager)
+        {
+            m_NetworkManager = manager;
+        }
+
+        public void OnBeforeSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery) where T : INetworkMessage
+        {
+        }
+
+        public void OnAfterSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery, int messageSizeBytes) where T : INetworkMessage
+        {
+        }
+
+        public void OnBeforeReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
+        {
+        }
+
+        public void OnAfterReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
+        {
+        }
+
+        public void OnBeforeSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
+        {
+        }
+
+        public void OnAfterSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
+        {
+        }
+
+        public void OnBeforeReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
+        {
+        }
+
+        public void OnAfterReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
+        {
+        }
+
+        public bool OnVerifyCanSend(ulong destinationId, Type messageType, NetworkDelivery delivery)
+        {
+            return !m_NetworkManager.MessageManager.StopProcessing;
+        }
+
+        public bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context)
+        {
+            if (m_NetworkManager.IsServer)
+            {
+                if (messageType == typeof(ConnectionApprovedMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                    }
+
+                    return false;
+                }
+
+                if (m_NetworkManager.ConnectionManager.PendingClients.TryGetValue(senderId, out PendingClient client) && (client.ConnectionState == PendingClient.State.PendingApproval || (client.ConnectionState == PendingClient.State.PendingConnection && messageType != typeof(ConnectionRequestMessage))))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted");
+                    }
+
+                    return false;
+                }
+
+                if (m_NetworkManager.ConnectedClients.TryGetValue(senderId, out NetworkClient connectedClient) && messageType == typeof(ConnectionRequestMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                    }
+
+                    return false;
+                }
+            }
+            else
+            {
+                if (messageType == typeof(ConnectionRequestMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                    }
+
+                    return false;
+                }
+
+                if (m_NetworkManager.IsConnectedClient && messageType == typeof(ConnectionApprovedMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                    }
+
+                    return false;
+                }
+            }
+
+            return !m_NetworkManager.MessageManager.StopProcessing;
+        }
+
+        public void OnBeforeHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
+        {
+        }
+
+        public void OnAfterHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
+        {
+        }
+    }
+}

Runtime/Messaging/NetworkManagerHooks.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c2be7fa492911d549bfca52be96c0906
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Messaging/NetworkMessageHeader.cs

@@ -3,13 +3,11 @@ namespace Unity.Netcode
     /// <summary>
     /// This is the header data that's serialized to the network when sending an <see cref="INetworkMessage"/>
     /// </summary>
-    internal struct MessageHeader : INetworkSerializeByMemcpy
+    internal struct NetworkMessageHeader : INetworkSerializeByMemcpy
     {
         /// <summary>
-        /// The byte representation of the message type. This is automatically assigned to each message
-        /// by the MessagingSystem. This value is deterministic only so long as the list of messages remains
-        /// unchanged - if new messages are added or messages are removed, MessageType assignments may be
-        /// calculated differently.
+        /// The byte representation of the message type. This is automatically assigned to each message by the NetworkMessageManager.
+        /// This value is deterministic only so long as the list of messages remains unchanged - if new messages are added or messages are removed, MessageType assignments may be calculated differently.
         /// </summary>
         public uint MessageType;
 

Runtime/Messaging/NetworkMessageManager.cs

@@ -11,22 +11,34 @@ namespace Unity.Netcode
 {
     internal class HandlerNotRegisteredException : SystemException
     {
-        public HandlerNotRegisteredException() { }
-        public HandlerNotRegisteredException(string issue) : base(issue) { }
+        public HandlerNotRegisteredException()
+        {
+        }
+
+        public HandlerNotRegisteredException(string issue) : base(issue)
+        {
+        }
     }
 
     internal class InvalidMessageStructureException : SystemException
     {
-        public InvalidMessageStructureException() { }
-        public InvalidMessageStructureException(string issue) : base(issue) { }
+        public InvalidMessageStructureException()
+        {
+        }
+
+        public InvalidMessageStructureException(string issue) : base(issue)
+        {
+        }
     }
 
-    internal class MessagingSystem : IDisposable
+    internal class NetworkMessageManager : IDisposable
     {
+        public bool StopProcessing = false;
+
         private struct ReceiveQueueItem
         {
             public FastBufferReader Reader;
-            public MessageHeader Header;
+            public NetworkMessageHeader Header;
             public ulong SenderId;
             public float Timestamp;
             public int MessageHeaderSerializedSize;
@@ -34,7 +46,7 @@ namespace Unity.Netcode
 
         private struct SendQueueItem
         {
-            public BatchHeader BatchHeader;
+            public NetworkBatchHeader BatchHeader;
             public FastBufferWriter Writer;
             public readonly NetworkDelivery NetworkDelivery;
 
@@ -42,11 +54,12 @@ namespace Unity.Netcode
             {
                 Writer = new FastBufferWriter(writerSize, writerAllocator, maxWriterSize);
                 NetworkDelivery = delivery;
-                BatchHeader = new BatchHeader { Magic = BatchHeader.MagicValue };
+                BatchHeader = new NetworkBatchHeader { Magic = NetworkBatchHeader.MagicValue };
             }
         }
 
-        internal delegate void MessageHandler(FastBufferReader reader, ref NetworkContext context, MessagingSystem system);
+        internal delegate void MessageHandler(FastBufferReader reader, ref NetworkContext context, NetworkMessageManager manager);
+
         internal delegate int VersionGetter();
 
         private NativeList<ReceiveQueueItem> m_IncomingMessageQueue = new NativeList<ReceiveQueueItem>(16, Allocator.Persistent);
@@ -58,6 +71,8 @@ namespace Unity.Netcode
         private Dictionary<Type, uint> m_MessageTypes = new Dictionary<Type, uint>();
         private Dictionary<ulong, NativeList<SendQueueItem>> m_SendQueues = new Dictionary<ulong, NativeList<SendQueueItem>>();
 
+        private HashSet<ulong> m_DisconnectedClients = new HashSet<ulong>();
+
         // This is m_PerClientMessageVersion[clientId][messageType] = version
         private Dictionary<ulong, Dictionary<Type, int>> m_PerClientMessageVersions = new Dictionary<ulong, Dictionary<Type, int>>();
         private Dictionary<uint, Type> m_MessagesByHash = new Dictionary<uint, Type>();
@@ -67,7 +82,7 @@ namespace Unity.Netcode
 
         private uint m_HighMessageType;
         private object m_Owner;
-        private IMessageSender m_MessageSender;
+        private INetworkMessageSender m_Sender;
         private bool m_Disposed;
 
         internal Type[] MessageTypes => m_ReverseTypeMap;
@@ -80,8 +95,9 @@ namespace Unity.Netcode
             return m_MessageTypes[t];
         }
 
-        public const int NON_FRAGMENTED_MESSAGE_MAX_SIZE = 1300;
-        public const int FRAGMENTED_MESSAGE_MAX_SIZE = int.MaxValue;
+        public const int DefaultNonFragmentedMessageMaxSize = 1300;
+        public int NonFragmentedMessageMaxSize = DefaultNonFragmentedMessageMaxSize;
+        public int FragmentedMessageMaxSize = int.MaxValue;
 
         internal struct MessageWithHandler
         {
@@ -94,7 +110,7 @@ namespace Unity.Netcode
         {
             var prioritizedTypes = new List<MessageWithHandler>();
 
-            // first pass puts the priority message in the first indices
+            // First pass puts the priority message in the first indices
             // Those are the messages that must be delivered in order to allow re-ordering the others later
             foreach (var t in allowedTypes)
             {
@@ -117,17 +133,18 @@ namespace Unity.Netcode
             return prioritizedTypes;
         }
 
-        public MessagingSystem(IMessageSender messageSender, object owner, IMessageProvider provider = null)
+        public NetworkMessageManager(INetworkMessageSender sender, object owner, INetworkMessageProvider provider = null)
         {
             try
             {
-                m_MessageSender = messageSender;
+                m_Sender = sender;
                 m_Owner = owner;
 
                 if (provider == null)
                 {
                     provider = new ILPPMessageProvider();
                 }
+
                 var allowedTypes = provider.GetMessages();
 
                 allowedTypes.Sort((a, b) => string.CompareOrdinal(a.MessageType.FullName, b.MessageType.FullName));
@@ -144,20 +161,21 @@ namespace Unity.Netcode
             }
         }
 
-        public unsafe void Dispose()
+        public void Dispose()
         {
             if (m_Disposed)
             {
                 return;
             }
 
-            // Can't just iterate SendQueues or SendQueues.Keys because ClientDisconnected removes
-            // from the queue.
+            // Can't just iterate SendQueues or SendQueues.Keys because ClientDisconnected removes from the queue.
             foreach (var kvp in m_SendQueues)
             {
-                CleanupDisconnectedClient(kvp.Key);
+                ClientDisconnected(kvp.Key);
             }
 
+            CleanupDisconnectedClients();
+
             for (var queueIndex = 0; queueIndex < m_IncomingMessageQueue.Length; ++queueIndex)
             {
                 // Avoid copies...
@@ -169,7 +187,7 @@ namespace Unity.Netcode
             m_Disposed = true;
         }
 
-        ~MessagingSystem()
+        ~NetworkMessageManager()
         {
             Dispose();
         }
@@ -186,7 +204,7 @@ namespace Unity.Netcode
 
         private void RegisterMessageType(MessageWithHandler messageWithHandler)
         {
-            // if we are out of space, perform amortized linear growth
+            // If we are out of space, perform amortized linear growth
             if (m_HighMessageType == m_MessageHandlers.Length)
             {
                 Array.Resize(ref m_MessageHandlers, 2 * m_MessageHandlers.Length);
@@ -220,19 +238,18 @@ namespace Unity.Netcode
         {
             unsafe
             {
-                fixed (byte* nativeData = data.Array)
+                fixed (byte* dataPtr = data.Array)
                 {
-                    var batchReader =
-                        new FastBufferReader(nativeData + data.Offset, Allocator.None, data.Count);
-                    if (!batchReader.TryBeginRead(sizeof(BatchHeader)))
+                    var batchReader = new FastBufferReader(dataPtr + data.Offset, Allocator.None, data.Count);
+                    if (!batchReader.TryBeginRead(sizeof(NetworkBatchHeader)))
                     {
                         NetworkLog.LogError("Received a packet too small to contain a BatchHeader. Ignoring it.");
                         return;
                     }
 
-                    batchReader.ReadValue(out BatchHeader batchHeader);
+                    batchReader.ReadValue(out NetworkBatchHeader batchHeader);
 
-                    if (batchHeader.Magic != BatchHeader.MagicValue)
+                    if (batchHeader.Magic != NetworkBatchHeader.MagicValue)
                     {
                         NetworkLog.LogError($"Received a packet with an invalid Magic Value. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Offset: {data.Offset}, Size: {data.Count}, Full receive array: {ByteArrayToString(data.Array, 0, data.Array.Length)}");
                         return;
@@ -259,8 +276,7 @@ namespace Unity.Netcode
 
                     for (var messageIdx = 0; messageIdx < batchHeader.BatchCount; ++messageIdx)
                     {
-
-                        var messageHeader = new MessageHeader();
+                        var messageHeader = new NetworkMessageHeader();
                         var position = batchReader.Position;
                         try
                         {
@@ -280,19 +296,20 @@ namespace Unity.Netcode
                             NetworkLog.LogError("Received a message that claimed a size larger than the packet, ending early!");
                             return;
                         }
+
                         m_IncomingMessageQueue.Add(new ReceiveQueueItem
                         {
                             Header = messageHeader,
                             SenderId = clientId,
                             Timestamp = receiveTime,
                             // Copy the data for this message into a new FastBufferReader that owns that memory.
-                            // We can't guarantee the memory in the ArraySegment stays valid because we don't own it,
-                            // so we must move it to memory we do own.
+                            // We can't guarantee the memory in the ArraySegment stays valid because we don't own it, so we must move it to memory we do own.
                             Reader = new FastBufferReader(batchReader.GetUnsafePtrAtCurrentPosition(), Allocator.TempJob, (int)messageHeader.MessageSize),
                             MessageHeaderSerializedSize = receivedHeaderSize,
                         });
                         batchReader.Seek(batchReader.Position + (int)messageHeader.MessageSize);
                     }
+
                     for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                     {
                         m_Hooks[hookIdx].OnAfterReceiveBatch(clientId, batchHeader.BatchCount, batchReader.Length);
@@ -320,6 +337,7 @@ namespace Unity.Netcode
             {
                 return null;
             }
+
             return m_MessagesByHash[messageHash];
         }
 
@@ -329,6 +347,7 @@ namespace Unity.Netcode
             {
                 return;
             }
+
             var messageType = m_MessagesByHash[messageHash];
 
             if (!m_PerClientMessageVersions.ContainsKey(clientId))
@@ -353,6 +372,7 @@ namespace Unity.Netcode
                 {
                     continue;
                 }
+
                 var messageType = m_MessagesByHash[messagesInIdOrder[i]];
                 var oldId = oldTypes[messageType];
                 var handler = oldHandlers[oldId];
@@ -363,7 +383,7 @@ namespace Unity.Netcode
             }
         }
 
-        public void HandleMessage(in MessageHeader header, FastBufferReader reader, ulong senderId, float timestamp, int serializedHeaderSize)
+        public void HandleMessage(in NetworkMessageHeader header, FastBufferReader reader, ulong senderId, float timestamp, int serializedHeaderSize)
         {
             using (reader)
             {
@@ -372,6 +392,7 @@ namespace Unity.Netcode
                     Debug.LogWarning($"Received a message with invalid message type value {header.MessageType}");
                     return;
                 }
+
                 var context = new NetworkContext
                 {
                     SystemOwner = m_Owner,
@@ -391,13 +412,12 @@ namespace Unity.Netcode
                 var handler = m_MessageHandlers[header.MessageType];
                 for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                 {
-                    m_Hooks[hookIdx].OnBeforeReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<MessageHeader>());
+                    m_Hooks[hookIdx].OnBeforeReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<NetworkMessageHeader>());
                 }
 
-                // This will also log an exception is if the server knows about a message type the client doesn't know
-                // about. In this case the handler will be null. It is still an issue the user must deal with: If the
-                // two connecting builds know about different messages, the server should not send a message to a client
-                // that doesn't know about it
+                // This will also log an exception is if the server knows about a message type the client doesn't know about.
+                // In this case the handler will be null. It is still an issue the user must deal with:
+                // If the two connecting builds know about different messages, the server should not send a message to a client that doesn't know about it
                 if (handler == null)
                 {
                     Debug.LogException(new HandlerNotRegisteredException(header.MessageType.ToString()));
@@ -406,9 +426,7 @@ namespace Unity.Netcode
                 {
                     // No user-land message handler exceptions should escape the receive loop.
                     // If an exception is throw, the message is ignored.
-                    // Example use case: A bad message is received that can't be deserialized and throws
-                    // an OverflowException because it specifies a length greater than the number of bytes in it
-                    // for some dynamic-length value.
+                    // Example use case: A bad message is received that can't be deserialized and throws an OverflowException because it specifies a length greater than the number of bytes in it for some dynamic-length value.
                     try
                     {
                         handler.Invoke(reader, ref context, this);
@@ -418,15 +436,21 @@ namespace Unity.Netcode
                         Debug.LogException(e);
                     }
                 }
+
                 for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                 {
-                    m_Hooks[hookIdx].OnAfterReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<MessageHeader>());
+                    m_Hooks[hookIdx].OnAfterReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<NetworkMessageHeader>());
                 }
             }
         }
 
-        internal unsafe void ProcessIncomingMessageQueue()
+        internal void ProcessIncomingMessageQueue()
         {
+            if (StopProcessing)
+            {
+                return;
+            }
+
             for (var index = 0; index < m_IncomingMessageQueue.Length; ++index)
             {
                 // Avoid copies...
@@ -447,21 +471,22 @@ namespace Unity.Netcode
             {
                 return;
             }
+
             m_SendQueues[clientId] = new NativeList<SendQueueItem>(16, Allocator.Persistent);
         }
 
         internal void ClientDisconnected(ulong clientId)
         {
-            if (!m_SendQueues.ContainsKey(clientId))
-            {
-                return;
-            }
-            CleanupDisconnectedClient(clientId);
-            m_SendQueues.Remove(clientId);
+            m_DisconnectedClients.Add(clientId);
         }
 
         private void CleanupDisconnectedClient(ulong clientId)
         {
+            if (!m_SendQueues.ContainsKey(clientId))
+            {
+                return;
+            }
+
             var queue = m_SendQueues[clientId];
             for (var i = 0; i < queue.Length; ++i)
             {
@@ -469,23 +494,19 @@ namespace Unity.Netcode
             }
 
             queue.Dispose();
+            m_SendQueues.Remove(clientId);
+
+            m_PerClientMessageVersions.Remove(clientId);
         }
 
         internal void CleanupDisconnectedClients()
         {
-            var removeList = new NativeList<ulong>(Allocator.Temp);
-            foreach (var clientId in m_PerClientMessageVersions.Keys)
+            foreach (var clientId in m_DisconnectedClients)
             {
-                if (!m_SendQueues.ContainsKey(clientId))
-                {
-                    removeList.Add(clientId);
-                }
+                CleanupDisconnectedClient(clientId);
             }
 
-            foreach (var clientId in removeList)
-            {
-                m_PerClientMessageVersions.Remove(clientId);
-            }
+            m_DisconnectedClients.Clear();
         }
 
         public static int CreateMessageAndGetVersion<T>() where T : INetworkMessage, new()
@@ -500,14 +521,15 @@ namespace Unity.Netcode
                 if (forReceive)
                 {
                     Debug.LogWarning($"Trying to receive {type.Name} from client {clientId} which is not in a connected state.");
-
                 }
                 else
                 {
                     Debug.LogWarning($"Trying to send {type.Name} to client {clientId} which is not in a connected state.");
                 }
+
                 return -1;
             }
+
             if (!versionMap.TryGetValue(type, out var messageVersion))
             {
                 return -1;
@@ -516,7 +538,7 @@ namespace Unity.Netcode
             return messageVersion;
         }
 
-        public static void ReceiveMessage<T>(FastBufferReader reader, ref NetworkContext context, MessagingSystem system) where T : INetworkMessage, new()
+        public static void ReceiveMessage<T>(FastBufferReader reader, ref NetworkContext context, NetworkMessageManager manager) where T : INetworkMessage, new()
         {
             var message = new T();
             var messageVersion = 0;
@@ -525,24 +547,25 @@ namespace Unity.Netcode
             // and can't change.
             if (typeof(T) != typeof(ConnectionRequestMessage) && typeof(T) != typeof(ConnectionApprovedMessage) && typeof(T) != typeof(DisconnectReasonMessage))
             {
-                messageVersion = system.GetMessageVersion(typeof(T), context.SenderId, true);
+                messageVersion = manager.GetMessageVersion(typeof(T), context.SenderId, true);
                 if (messageVersion < 0)
                 {
                     return;
                 }
             }
+
             if (message.Deserialize(reader, ref context, messageVersion))
             {
-                for (var hookIdx = 0; hookIdx < system.m_Hooks.Count; ++hookIdx)
+                for (var hookIdx = 0; hookIdx < manager.m_Hooks.Count; ++hookIdx)
                 {
-                    system.m_Hooks[hookIdx].OnBeforeHandleMessage(ref message, ref context);
+                    manager.m_Hooks[hookIdx].OnBeforeHandleMessage(ref message, ref context);
                 }
 
                 message.Handle(ref context);
 
-                for (var hookIdx = 0; hookIdx < system.m_Hooks.Count; ++hookIdx)
+                for (var hookIdx = 0; hookIdx < manager.m_Hooks.Count; ++hookIdx)
                 {
-                    system.m_Hooks[hookIdx].OnAfterHandleMessage(ref message, ref context);
+                    manager.m_Hooks[hookIdx].OnAfterHandleMessage(ref message, ref context);
                 }
             }
         }
@@ -574,9 +597,8 @@ namespace Unity.Netcode
             for (var i = 0; i < clientIds.Count; ++i)
             {
                 var messageVersion = 0;
-                // Special case because this is the message that carries the version info - thus the version info isn't
-                // populated yet when we get this. The first part of this message always has to be the version data
-                // and can't change.
+                // Special case because this is the message that carries the version info - thus the version info isn't populated yet when we get this.
+                // The first part of this message always has to be the version data and can't change.
                 if (typeof(TMessageType) != typeof(ConnectionRequestMessage))
                 {
                     messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
@@ -594,9 +616,9 @@ namespace Unity.Netcode
 
                 sentMessageVersions.Add(messageVersion);
 
-                var maxSize = delivery == NetworkDelivery.ReliableFragmentedSequenced ? FRAGMENTED_MESSAGE_MAX_SIZE : NON_FRAGMENTED_MESSAGE_MAX_SIZE;
+                var maxSize = delivery == NetworkDelivery.ReliableFragmentedSequenced ? FragmentedMessageMaxSize : NonFragmentedMessageMaxSize;
 
-                using var tmpSerializer = new FastBufferWriter(NON_FRAGMENTED_MESSAGE_MAX_SIZE - FastBufferWriter.GetWriteSize<MessageHeader>(), Allocator.Temp, maxSize - FastBufferWriter.GetWriteSize<MessageHeader>());
+                using var tmpSerializer = new FastBufferWriter(NonFragmentedMessageMaxSize - FastBufferWriter.GetWriteSize<NetworkMessageHeader>(), Allocator.Temp, maxSize - FastBufferWriter.GetWriteSize<NetworkMessageHeader>());
 
                 message.Serialize(tmpSerializer, messageVersion);
 
@@ -612,9 +634,9 @@ namespace Unity.Netcode
         internal unsafe int SendPreSerializedMessage<TMessageType>(in FastBufferWriter tmpSerializer, int maxSize, ref TMessageType message, NetworkDelivery delivery, in IReadOnlyList<ulong> clientIds, int messageVersionFilter)
             where TMessageType : INetworkMessage
         {
-            using var headerSerializer = new FastBufferWriter(FastBufferWriter.GetWriteSize<MessageHeader>(), Allocator.Temp);
+            using var headerSerializer = new FastBufferWriter(FastBufferWriter.GetWriteSize<NetworkMessageHeader>(), Allocator.Temp);
 
-            var header = new MessageHeader
+            var header = new NetworkMessageHeader
             {
                 MessageSize = (uint)tmpSerializer.Length,
                 MessageType = m_MessageTypes[typeof(TMessageType)],
@@ -624,13 +646,16 @@ namespace Unity.Netcode
 
             for (var i = 0; i < clientIds.Count; ++i)
             {
-                var messageVersion = 0;
-                // Special case because this is the message that carries the version info - thus the version info isn't
-                // populated yet when we get this. The first part of this message always has to be the version data
-                // and can't change.
+                if (m_DisconnectedClients.Contains(clientIds[i]))
+                {
+                    continue;
+                }
+
+                // Special case because this is the message that carries the version info - thus the version info isn't populated yet when we get this.
+                // The first part of this message always has to be the version data and can't change.
                 if (typeof(TMessageType) != typeof(ConnectionRequestMessage))
                 {
-                    messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
+                    var messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
                     if (messageVersion < 0)
                     {
                         // Client doesn't know this message exists, don't send it at all.
@@ -658,20 +683,16 @@ namespace Unity.Netcode
                 var sendQueueItem = m_SendQueues[clientId];
                 if (sendQueueItem.Length == 0)
                 {
-                    sendQueueItem.Add(new SendQueueItem(delivery, NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.TempJob,
-                        maxSize));
-                    sendQueueItem.ElementAt(0).Writer.Seek(sizeof(BatchHeader));
+                    sendQueueItem.Add(new SendQueueItem(delivery, NonFragmentedMessageMaxSize, Allocator.TempJob, maxSize));
+                    sendQueueItem.ElementAt(0).Writer.Seek(sizeof(NetworkBatchHeader));
                 }
                 else
                 {
                     ref var lastQueueItem = ref sendQueueItem.ElementAt(sendQueueItem.Length - 1);
-                    if (lastQueueItem.NetworkDelivery != delivery ||
-                        lastQueueItem.Writer.MaxCapacity - lastQueueItem.Writer.Position
-                        < tmpSerializer.Length + headerSerializer.Length)
+                    if (lastQueueItem.NetworkDelivery != delivery || lastQueueItem.Writer.MaxCapacity - lastQueueItem.Writer.Position < tmpSerializer.Length + headerSerializer.Length)
                     {
-                        sendQueueItem.Add(new SendQueueItem(delivery, NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.TempJob,
-                            maxSize));
-                        sendQueueItem.ElementAt(sendQueueItem.Length - 1).Writer.Seek(sizeof(BatchHeader));
+                        sendQueueItem.Add(new SendQueueItem(delivery, NonFragmentedMessageMaxSize, Allocator.TempJob, maxSize));
+                        sendQueueItem.ElementAt(sendQueueItem.Length - 1).Writer.Seek(sizeof(NetworkBatchHeader));
                     }
                 }
 
@@ -768,6 +789,11 @@ namespace Unity.Netcode
 
         internal unsafe void ProcessSendQueues()
         {
+            if (StopProcessing)
+            {
+                return;
+            }
+
             foreach (var kvp in m_SendQueues)
             {
                 var clientId = kvp.Key;
@@ -775,6 +801,15 @@ namespace Unity.Netcode
                 for (var i = 0; i < sendQueueItem.Length; ++i)
                 {
                     ref var queueItem = ref sendQueueItem.ElementAt(i);
+                    // This is checked at every iteration because
+                    // 1) each writer needs to be disposed, so we have to do the full loop regardless, and
+                    // 2) the call to m_MessageSender.Send() may result in calling ClientDisconnected(), so the result of this check may change partway through iteration
+                    if (m_DisconnectedClients.Contains(clientId))
+                    {
+                        queueItem.Writer.Dispose();
+                        continue;
+                    }
+
                     if (queueItem.BatchHeader.BatchCount == 0)
                     {
                         queueItem.Writer.Dispose();
@@ -789,9 +824,9 @@ namespace Unity.Netcode
                     queueItem.Writer.Seek(0);
 #if UNITY_EDITOR || DEVELOPMENT_BUILD
                     // Skipping the Verify and sneaking the write mark in because we know it's fine.
-                    queueItem.Writer.Handle->AllowedWriteMark = sizeof(BatchHeader);
+                    queueItem.Writer.Handle->AllowedWriteMark = sizeof(NetworkBatchHeader);
 #endif
-                    queueItem.BatchHeader.BatchHash = XXHash.Hash64(queueItem.Writer.GetUnsafePtr() + sizeof(BatchHeader), queueItem.Writer.Length - sizeof(BatchHeader));
+                    queueItem.BatchHeader.BatchHash = XXHash.Hash64(queueItem.Writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), queueItem.Writer.Length - sizeof(NetworkBatchHeader));
 
                     queueItem.BatchHeader.BatchSize = queueItem.Writer.Length;
 
@@ -800,7 +835,7 @@ namespace Unity.Netcode
 
                     try
                     {
-                        m_MessageSender.Send(clientId, queueItem.NetworkDelivery, queueItem.Writer);
+                        m_Sender.Send(clientId, queueItem.NetworkDelivery, queueItem.Writer);
 
                         for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                         {
@@ -812,6 +847,7 @@ namespace Unity.Netcode
                         queueItem.Writer.Dispose();
                     }
                 }
+
                 sendQueueItem.Clear();
             }
         }

Runtime/Metrics/NetworkMetricsManager.cs

@@ -0,0 +1,44 @@
+#if MULTIPLAYER_TOOLS
+using Unity.Multiplayer.Tools;
+#endif
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This probably needs to all be migrated into <see cref="NetworkConnectionManager"/>, but
+    /// keeping it separated for the time being
+    /// </summary>
+    internal class NetworkMetricsManager
+    {
+        internal INetworkMetrics NetworkMetrics { get; private set; }
+
+        private NetworkManager m_NetworkManager;
+
+        public void UpdateMetrics()
+        {
+            NetworkMetrics.UpdateNetworkObjectsCount(m_NetworkManager.SpawnManager.SpawnedObjects.Count);
+            NetworkMetrics.UpdateConnectionsCount((m_NetworkManager.IsServer) ? m_NetworkManager.ConnectionManager.ConnectedClients.Count : 1);
+            NetworkMetrics.DispatchFrame();
+        }
+
+        public void Initialize(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+            if (NetworkMetrics == null)
+            {
+#if MULTIPLAYER_TOOLS
+                NetworkMetrics = new NetworkMetrics();
+#else
+                NetworkMetrics = new NullNetworkMetrics();
+#endif
+            }
+
+#if MULTIPLAYER_TOOLS
+            NetworkSolutionInterface.SetInterface(new NetworkSolutionInterfaceParameters
+            {
+                NetworkObjectProvider = new NetworkObjectProvider(networkManager),
+            });
+#endif
+        }
+    }
+}

Runtime/Metrics/NetworkMetricsManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3b20a0fe127a24d48867c2ee448bdb1b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/NetworkVariable/Collections/NetworkList.cs

@@ -75,7 +75,7 @@ namespace Unity.Netcode
                 return;
             }
 
-            m_NetworkBehaviour.NetworkManager.MarkNetworkObjectDirty(m_NetworkBehaviour.NetworkObject);
+            m_NetworkBehaviour.NetworkManager.BehaviourUpdater.AddForUpdate(m_NetworkBehaviour.NetworkObject);
         }
 
         /// <inheritdoc />
@@ -490,12 +490,14 @@ namespace Unity.Netcode
                 throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
             }
 
+            var value = m_List[index];
             m_List.RemoveAt(index);
 
             var listEvent = new NetworkListEvent<T>()
             {
                 Type = NetworkListEvent<T>.EventType.RemoveAt,
-                Index = index
+                Index = index,
+                Value = value
             };
 
             HandleAddListEvent(listEvent);

Runtime/NetworkVariable/NetworkVariable.cs

@@ -33,6 +33,13 @@ namespace Unity.Netcode
             : base(readPerm, writePerm)
         {
             m_InternalValue = value;
+            // Since we start with IsDirty = true, this doesn't need to be duplicated
+            // right away. It won't get read until after ResetDirty() is called, and
+            // the duplicate will be made there. Avoiding calling
+            // NetworkVariableSerialization<T>.Duplicate() is important because calling
+            // it in the constructor might not give users enough time to set the
+            // DuplicateValue callback if they're using UserNetworkVariableSerialization
+            m_PreviousValue = default;
         }
 
         /// <summary>
@@ -41,6 +48,11 @@ namespace Unity.Netcode
         [SerializeField]
         private protected T m_InternalValue;
 
+        private protected T m_PreviousValue;
+
+        private bool m_HasPreviousValue;
+        private bool m_IsDisposed;
+
         /// <summary>
         /// The value of the NetworkVariable container
         /// </summary>
@@ -61,9 +73,83 @@ namespace Unity.Netcode
                 }
 
                 Set(value);
+                m_IsDisposed = false;
             }
         }
 
+        internal ref T RefValue()
+        {
+            return ref m_InternalValue;
+        }
+
+        public override void Dispose()
+        {
+            if (m_IsDisposed)
+            {
+                return;
+            }
+
+            m_IsDisposed = true;
+            if (m_InternalValue is IDisposable internalValueDisposable)
+            {
+                internalValueDisposable.Dispose();
+            }
+
+            m_InternalValue = default;
+            if (m_HasPreviousValue && m_PreviousValue is IDisposable previousValueDisposable)
+            {
+                m_HasPreviousValue = false;
+                previousValueDisposable.Dispose();
+            }
+
+            m_PreviousValue = default;
+        }
+
+        ~NetworkVariable()
+        {
+            Dispose();
+        }
+
+        /// <summary>
+        /// Gets Whether or not the container is dirty
+        /// </summary>
+        /// <returns>Whether or not the container is dirty</returns>
+        public override bool IsDirty()
+        {
+            // For most cases we can use the dirty flag.
+            // This doesn't work for cases where we're wrapping more complex types
+            // like INetworkSerializable, NativeList, NativeArray, etc.
+            // Changes to the values in those types don't call the Value.set method,
+            // so we can't catch those changes and need to compare the current value
+            // against the previous one.
+            if (base.IsDirty())
+            {
+                return true;
+            }
+
+            // Cache the dirty value so we don't perform this again if we already know we're dirty
+            // Unfortunately we can't cache the NOT dirty state, because that might change
+            // in between to checks... but the DIRTY state won't change until ResetDirty()
+            // is called.
+            var dirty = !NetworkVariableSerialization<T>.AreEqual(ref m_PreviousValue, ref m_InternalValue);
+            SetDirty(dirty);
+            return dirty;
+        }
+
+        /// <summary>
+        /// Resets the dirty state and marks the variable as synced / clean
+        /// </summary>
+        public override void ResetDirty()
+        {
+            base.ResetDirty();
+            // Resetting the dirty value declares that the current value is not dirty
+            // Therefore, we set the m_PreviousValue field to a duplicate of the current
+            // field, so that our next dirty check is made against the current "not dirty"
+            // value.
+            m_HasPreviousValue = true;
+            NetworkVariableSerialization<T>.Serializer.Duplicate(m_InternalValue, ref m_PreviousValue);
+        }
+
         /// <summary>
         /// Sets the <see cref="Value"/>, marks the <see cref="NetworkVariable{T}"/> dirty, and invokes the <see cref="OnValueChanged"/> callback
         /// if there are subscribers to that event.

Runtime/NetworkVariable/NetworkVariableBase.cs

@@ -94,7 +94,8 @@ namespace Unity.Netcode
                                      "Are you modifying a NetworkVariable before the NetworkObject is spawned?");
                     return;
                 }
-                m_NetworkBehaviour.NetworkManager.MarkNetworkObjectDirty(m_NetworkBehaviour.NetworkObject);
+
+                m_NetworkBehaviour.NetworkManager.BehaviourUpdater.AddForUpdate(m_NetworkBehaviour.NetworkObject);
             }
         }
 

Runtime/NetworkVariable/NetworkVariableSerialization.cs

@@ -20,6 +20,8 @@ namespace Unity.Netcode
         // of it to pass it as a ref parameter.
         public void Write(FastBufferWriter writer, ref T value);
         public void Read(FastBufferReader reader, ref T value);
+        internal void ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator);
+        public void Duplicate(in T value, ref T duplicatedValue);
     }
 
     /// <summary>
@@ -35,6 +37,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<short>.ReadWithAllocator(FastBufferReader reader, out short value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in short value, ref short duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -50,6 +62,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<ushort>.ReadWithAllocator(FastBufferReader reader, out ushort value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in ushort value, ref ushort duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -65,6 +87,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<int>.ReadWithAllocator(FastBufferReader reader, out int value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in int value, ref int duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -80,6 +112,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<uint>.ReadWithAllocator(FastBufferReader reader, out uint value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in uint value, ref uint duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -95,6 +137,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<long>.ReadWithAllocator(FastBufferReader reader, out long value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in long value, ref long duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -110,6 +162,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<ulong>.ReadWithAllocator(FastBufferReader reader, out ulong value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in ulong value, ref ulong duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -130,8 +192,84 @@ namespace Unity.Netcode
         {
             reader.ReadUnmanagedSafe(out value);
         }
+
+        void INetworkVariableSerializer<T>.ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in T value, ref T duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
+    internal class UnmanagedArraySerializer<T> : INetworkVariableSerializer<NativeArray<T>> where T : unmanaged
+    {
+        public void Write(FastBufferWriter writer, ref NativeArray<T> value)
+        {
+            writer.WriteUnmanagedSafe(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeArray<T> value)
+        {
+            value.Dispose();
+            reader.ReadUnmanagedSafe(out value, Allocator.Persistent);
+        }
+
+        void INetworkVariableSerializer<NativeArray<T>>.ReadWithAllocator(FastBufferReader reader, out NativeArray<T> value, Allocator allocator)
+        {
+            reader.ReadUnmanagedSafe(out value, allocator);
+        }
+
+        public void Duplicate(in NativeArray<T> value, ref NativeArray<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated || duplicatedValue.Length != value.Length)
+            {
+                if (duplicatedValue.IsCreated)
+                {
+                    duplicatedValue.Dispose();
+                }
+
+                duplicatedValue = new NativeArray<T>(value.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+    internal class UnmanagedListSerializer<T> : INetworkVariableSerializer<NativeList<T>> where T : unmanaged
+    {
+        public void Write(FastBufferWriter writer, ref NativeList<T> value)
+        {
+            writer.WriteUnmanagedSafe(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeList<T> value)
+        {
+            reader.ReadUnmanagedSafeInPlace(ref value);
+        }
+
+        void INetworkVariableSerializer<NativeList<T>>.ReadWithAllocator(FastBufferReader reader, out NativeList<T> value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in NativeList<T> value, ref NativeList<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated)
+            {
+                duplicatedValue = new NativeList<T>(value.Length, Allocator.Persistent);
+            }
+            else if (value.Length != duplicatedValue.Length)
+            {
+                duplicatedValue.ResizeUninitialized(value.Length);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+#endif
+
     /// <summary>
     /// Serializer for FixedStrings
     /// </summary>
@@ -146,8 +284,92 @@ namespace Unity.Netcode
         {
             reader.ReadValueSafeInPlace(ref value);
         }
+
+        void INetworkVariableSerializer<T>.ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in T value, ref T duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
+    /// <summary>
+    /// Serializer for FixedStrings
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class FixedStringArraySerializer<T> : INetworkVariableSerializer<NativeArray<T>> where T : unmanaged, INativeList<byte>, IUTF8Bytes
+    {
+        public void Write(FastBufferWriter writer, ref NativeArray<T> value)
+        {
+            writer.WriteValueSafe(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeArray<T> value)
+        {
+            value.Dispose();
+            reader.ReadValueSafe(out value, Allocator.Persistent);
+        }
+
+        void INetworkVariableSerializer<NativeArray<T>>.ReadWithAllocator(FastBufferReader reader, out NativeArray<T> value, Allocator allocator)
+        {
+            reader.ReadValueSafe(out value, allocator);
+        }
+
+        public void Duplicate(in NativeArray<T> value, ref NativeArray<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated || duplicatedValue.Length != value.Length)
+            {
+                if (duplicatedValue.IsCreated)
+                {
+                    duplicatedValue.Dispose();
+                }
+
+                duplicatedValue = new NativeArray<T>(value.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+    /// <summary>
+    /// Serializer for FixedStrings
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class FixedStringListSerializer<T> : INetworkVariableSerializer<NativeList<T>> where T : unmanaged, INativeList<byte>, IUTF8Bytes
+    {
+        public void Write(FastBufferWriter writer, ref NativeList<T> value)
+        {
+            writer.WriteValueSafe(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeList<T> value)
+        {
+            reader.ReadValueSafeInPlace(ref value);
+        }
+
+        void INetworkVariableSerializer<NativeList<T>>.ReadWithAllocator(FastBufferReader reader, out NativeList<T> value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in NativeList<T> value, ref NativeList<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated)
+            {
+                duplicatedValue = new NativeList<T>(value.Length, Allocator.Persistent);
+            }
+            else if (value.Length != duplicatedValue.Length)
+            {
+                duplicatedValue.ResizeUninitialized(value.Length);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+#endif
+
     /// <summary>
     /// Serializer for unmanaged INetworkSerializable types
     /// </summary>
@@ -163,10 +385,93 @@ namespace Unity.Netcode
         {
             var bufferSerializer = new BufferSerializer<BufferSerializerReader>(new BufferSerializerReader(reader));
             value.NetworkSerialize(bufferSerializer);
+        }
 
+        void INetworkVariableSerializer<T>.ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in T value, ref T duplicatedValue)
+        {
+            duplicatedValue = value;
         }
     }
 
+    /// <summary>
+    /// Serializer for unmanaged INetworkSerializable types
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class UnmanagedNetworkSerializableArraySerializer<T> : INetworkVariableSerializer<NativeArray<T>> where T : unmanaged, INetworkSerializable
+    {
+        public void Write(FastBufferWriter writer, ref NativeArray<T> value)
+        {
+            writer.WriteNetworkSerializable(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeArray<T> value)
+        {
+            value.Dispose();
+            reader.ReadNetworkSerializable(out value, Allocator.Persistent);
+        }
+
+        void INetworkVariableSerializer<NativeArray<T>>.ReadWithAllocator(FastBufferReader reader, out NativeArray<T> value, Allocator allocator)
+        {
+            reader.ReadNetworkSerializable(out value, allocator);
+        }
+
+        public void Duplicate(in NativeArray<T> value, ref NativeArray<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated || duplicatedValue.Length != value.Length)
+            {
+                if (duplicatedValue.IsCreated)
+                {
+                    duplicatedValue.Dispose();
+                }
+
+                duplicatedValue = new NativeArray<T>(value.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+    /// <summary>
+    /// Serializer for unmanaged INetworkSerializable types
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class UnmanagedNetworkSerializableListSerializer<T> : INetworkVariableSerializer<NativeList<T>> where T : unmanaged, INetworkSerializable
+    {
+        public void Write(FastBufferWriter writer, ref NativeList<T> value)
+        {
+            writer.WriteNetworkSerializable(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeList<T> value)
+        {
+            reader.ReadNetworkSerializableInPlace(ref value);
+        }
+
+        void INetworkVariableSerializer<NativeList<T>>.ReadWithAllocator(FastBufferReader reader, out NativeList<T> value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in NativeList<T> value, ref NativeList<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated)
+            {
+                duplicatedValue = new NativeList<T>(value.Length, Allocator.Persistent);
+            }
+            else if (value.Length != duplicatedValue.Length)
+            {
+                duplicatedValue.ResizeUninitialized(value.Length);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+#endif
+
     /// <summary>
     /// Serializer for managed INetworkSerializable types, which differs from the unmanaged implementation in that it
     /// has to be null-aware
@@ -201,6 +506,21 @@ namespace Unity.Netcode
                 value.NetworkSerialize(bufferSerializer);
             }
         }
+
+        void INetworkVariableSerializer<T>.ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in T value, ref T duplicatedValue)
+        {
+            using var writer = new FastBufferWriter(256, Allocator.Temp);
+            var refValue = value;
+            Write(writer, ref refValue);
+
+            using var reader = new FastBufferReader(writer, Allocator.None);
+            Read(reader, ref duplicatedValue);
+        }
     }
 
     /// <summary>
@@ -227,14 +547,26 @@ namespace Unity.Netcode
         public delegate void ReadValueDelegate(FastBufferReader reader, out T value);
 
         /// <summary>
-        /// The <see cref="WriteValueDelegate"/> delegate handler declaration
+        /// The read value delegate handler definition
+        /// </summary>
+        /// <param name="reader">The <see cref="FastBufferReader"/> to read the value of type `T`</param>
+        /// <param name="value">The value of type `T` to be read</param>
+        public delegate void DuplicateValueDelegate(in T value, ref T duplicatedValue);
+
+        /// <summary>
+        /// Callback to write a value
         /// </summary>
         public static WriteValueDelegate WriteValue;
 
         /// <summary>
-        /// The <see cref="ReadValueDelegate"/> delegate handler declaration
+        /// Callback to read a value
         /// </summary>
         public static ReadValueDelegate ReadValue;
+
+        /// <summary>
+        /// Callback to create a duplicate of a value, used to check for dirty status.
+        /// </summary>
+        public static DuplicateValueDelegate DuplicateValue;
     }
 
     /// <summary>
@@ -250,20 +582,34 @@ namespace Unity.Netcode
     {
         public void Write(FastBufferWriter writer, ref T value)
         {
-            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null)
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null || UserNetworkVariableSerialization<T>.DuplicateValue == null)
             {
-                throw new ArgumentException($"Type {typeof(T).FullName} is not supported by {typeof(NetworkVariable<>).Name}. If this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)} and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
+                throw new ArgumentException($"Type {typeof(T).FullName} is not supported by {typeof(NetworkVariable<>).Name}. If this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)}, {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.DuplicateValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
             }
             UserNetworkVariableSerialization<T>.WriteValue(writer, value);
         }
         public void Read(FastBufferReader reader, ref T value)
         {
-            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null)
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null || UserNetworkVariableSerialization<T>.DuplicateValue == null)
             {
-                throw new ArgumentException($"Type {typeof(T).FullName} is not supported by {typeof(NetworkVariable<>).Name}. If this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)} and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
+                throw new ArgumentException($"Type {typeof(T).FullName} is not supported by {typeof(NetworkVariable<>).Name}. If this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)}, {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.DuplicateValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
             }
             UserNetworkVariableSerialization<T>.ReadValue(reader, out value);
         }
+
+        void INetworkVariableSerializer<T>.ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in T value, ref T duplicatedValue)
+        {
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null || UserNetworkVariableSerialization<T>.DuplicateValue == null)
+            {
+                throw new ArgumentException($"Type {typeof(T).FullName} is not supported by {typeof(NetworkVariable<>).Name}. If this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)}, {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.DuplicateValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
+            }
+            UserNetworkVariableSerialization<T>.DuplicateValue(value, ref duplicatedValue);
+        }
     }
 
     /// <summary>
@@ -309,6 +655,26 @@ namespace Unity.Netcode
             NetworkVariableSerialization<T>.Serializer = new UnmanagedTypeSerializer<T>();
         }
 
+        /// <summary>
+        /// Registeres an unmanaged type that will be serialized by a direct memcpy into a buffer
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedByMemcpyArray<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeArray<T>>.Serializer = new UnmanagedArraySerializer<T>();
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registeres an unmanaged type that will be serialized by a direct memcpy into a buffer
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedByMemcpyList<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeList<T>>.Serializer = new UnmanagedListSerializer<T>();
+        }
+#endif
+
         /// <summary>
         /// Registers an unmanaged type that implements INetworkSerializable and will be serialized through a call to
         /// NetworkSerialize
@@ -319,6 +685,28 @@ namespace Unity.Netcode
             NetworkVariableSerialization<T>.Serializer = new UnmanagedNetworkSerializableSerializer<T>();
         }
 
+        /// <summary>
+        /// Registers an unmanaged type that implements INetworkSerializable and will be serialized through a call to
+        /// NetworkSerialize
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedINetworkSerializableArray<T>() where T : unmanaged, INetworkSerializable
+        {
+            NetworkVariableSerialization<NativeArray<T>>.Serializer = new UnmanagedNetworkSerializableArraySerializer<T>();
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers an unmanaged type that implements INetworkSerializable and will be serialized through a call to
+        /// NetworkSerialize
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedINetworkSerializableList<T>() where T : unmanaged, INetworkSerializable
+        {
+            NetworkVariableSerialization<NativeList<T>>.Serializer = new UnmanagedNetworkSerializableListSerializer<T>();
+        }
+#endif
+
         /// <summary>
         /// Registers a managed type that implements INetworkSerializable and will be serialized through a call to
         /// NetworkSerialize
@@ -339,6 +727,28 @@ namespace Unity.Netcode
             NetworkVariableSerialization<T>.Serializer = new FixedStringSerializer<T>();
         }
 
+        /// <summary>
+        /// Registers a FixedString type that will be serialized through FastBufferReader/FastBufferWriter's FixedString
+        /// serializers
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_FixedStringArray<T>() where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            NetworkVariableSerialization<NativeArray<T>>.Serializer = new FixedStringArraySerializer<T>();
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers a FixedString type that will be serialized through FastBufferReader/FastBufferWriter's FixedString
+        /// serializers
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_FixedStringList<T>() where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            NetworkVariableSerialization<NativeList<T>>.Serializer = new FixedStringListSerializer<T>();
+        }
+#endif
+
         /// <summary>
         /// Registers a managed type that will be checked for equality using T.Equals()
         /// </summary>
@@ -357,6 +767,26 @@ namespace Unity.Netcode
             NetworkVariableSerialization<T>.AreEqual = NetworkVariableSerialization<T>.EqualityEquals;
         }
 
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedIEquatableArray<T>() where T : unmanaged, IEquatable<T>
+        {
+            NetworkVariableSerialization<NativeArray<T>>.AreEqual = NetworkVariableSerialization<T>.EqualityEqualsArray;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedIEquatableList<T>() where T : unmanaged, IEquatable<T>
+        {
+            NetworkVariableSerialization<NativeList<T>>.AreEqual = NetworkVariableSerialization<T>.EqualityEqualsList;
+        }
+#endif
+
         /// <summary>
         /// Registers an unmanaged type that will be checked for equality using memcmp and only considered
         /// equal if they are bitwise equivalent in memory
@@ -367,6 +797,28 @@ namespace Unity.Netcode
             NetworkVariableSerialization<T>.AreEqual = NetworkVariableSerialization<T>.ValueEquals;
         }
 
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using memcmp and only considered
+        /// equal if they are bitwise equivalent in memory
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedValueEqualsArray<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeArray<T>>.AreEqual = NetworkVariableSerialization<T>.ValueEqualsArray;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using memcmp and only considered
+        /// equal if they are bitwise equivalent in memory
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedValueEqualsList<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeList<T>>.AreEqual = NetworkVariableSerialization<T>.ValueEqualsList;
+        }
+#endif
+
         /// <summary>
         /// Registers a managed type that will be checked for equality using the == operator
         /// </summary>
@@ -405,6 +857,58 @@ namespace Unity.Netcode
             return UnsafeUtility.MemCmp(aptr, bptr, sizeof(TValueType)) == 0;
         }
 
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool ValueEqualsList<TValueType>(ref NativeList<TValueType> a, ref NativeList<TValueType> b) where TValueType : unmanaged
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+            return UnsafeUtility.MemCmp(aptr, bptr, sizeof(TValueType) * a.Length) == 0;
+        }
+#endif
+
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool ValueEqualsArray<TValueType>(ref NativeArray<TValueType> a, ref NativeArray<TValueType> b) where TValueType : unmanaged
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+            return UnsafeUtility.MemCmp(aptr, bptr, sizeof(TValueType) * a.Length) == 0;
+        }
+
         internal static bool EqualityEqualsObject<TValueType>(ref TValueType a, ref TValueType b) where TValueType : class, IEquatable<TValueType>
         {
             if (a == null)
@@ -425,6 +929,74 @@ namespace Unity.Netcode
             return a.Equals(b);
         }
 
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool EqualityEqualsList<TValueType>(ref NativeList<TValueType> a, ref NativeList<TValueType> b) where TValueType : unmanaged, IEquatable<TValueType>
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+            for (var i = 0; i < a.Length; ++i)
+            {
+                if (!EqualityEquals(ref aptr[i], ref bptr[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+#endif
+
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool EqualityEqualsArray<TValueType>(ref NativeArray<TValueType> a, ref NativeArray<TValueType> b) where TValueType : unmanaged, IEquatable<TValueType>
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+            for (var i = 0; i < a.Length; ++i)
+            {
+                if (!EqualityEquals(ref aptr[i], ref bptr[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         internal static bool ClassEquals<TValueType>(ref TValueType a, ref TValueType b) where TValueType : class
         {
             return a == b;

Runtime/Profiling/ProfilingHooks.cs

@@ -8,8 +8,8 @@ namespace Unity.Netcode
     {
         private Dictionary<Type, ProfilerMarker> m_HandlerProfilerMarkers = new Dictionary<Type, ProfilerMarker>();
         private Dictionary<Type, ProfilerMarker> m_SenderProfilerMarkers = new Dictionary<Type, ProfilerMarker>();
-        private readonly ProfilerMarker m_SendBatch = new ProfilerMarker($"{nameof(MessagingSystem)}.SendBatch");
-        private readonly ProfilerMarker m_ReceiveBatch = new ProfilerMarker($"{nameof(MessagingSystem)}.ReceiveBatchBatch");
+        private readonly ProfilerMarker m_SendBatch = new ProfilerMarker($"{nameof(NetworkMessageManager)}.SendBatch");
+        private readonly ProfilerMarker m_ReceiveBatch = new ProfilerMarker($"{nameof(NetworkMessageManager)}.ReceiveBatchBatch");
 
         private ProfilerMarker GetHandlerProfilerMarker(Type type)
         {
@@ -19,7 +19,7 @@ namespace Unity.Netcode
                 return marker;
             }
 
-            marker = new ProfilerMarker($"{nameof(MessagingSystem)}.DeserializeAndHandle.{type.Name}");
+            marker = new ProfilerMarker($"{nameof(NetworkMessageManager)}.DeserializeAndHandle.{type.Name}");
             m_HandlerProfilerMarkers[type] = marker;
             return marker;
         }
@@ -32,7 +32,7 @@ namespace Unity.Netcode
                 return marker;
             }
 
-            marker = new ProfilerMarker($"{nameof(MessagingSystem)}.SerializeAndEnqueue.{type.Name}");
+            marker = new ProfilerMarker($"{nameof(NetworkMessageManager)}.SerializeAndEnqueue.{type.Name}");
             m_SenderProfilerMarkers[type] = marker;
             return marker;
         }

Runtime/SceneManagement/DefaultSceneManagerHandler.cs

@@ -337,7 +337,7 @@ namespace Unity.Netcode
                 return;
             }
             else // Warn users if they are changing this after there are clients already connected and synchronized
-            if (networkManager.ConnectedClientsIds.Count > (networkManager.IsServer ? 0 : 1) && sceneManager.ClientSynchronizationMode != mode)
+            if (networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
             {
                 if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                 {

Runtime/SceneManagement/NetworkSceneManager.cs

@@ -524,7 +524,7 @@ namespace Unity.Netcode
         /// </summary>
         internal Dictionary<uint, SceneEventData> SceneEventDataStore;
 
-        private NetworkManager m_NetworkManager { get; }
+        internal readonly NetworkManager NetworkManager;
 
         // Keep track of this scene until the NetworkSceneManager is destroyed.
         internal Scene DontDestroyOnLoadScene;
@@ -575,7 +575,7 @@ namespace Unity.Netcode
         /// <returns>SceneEventData instance</returns>
         internal SceneEventData BeginSceneEvent()
         {
-            var sceneEventData = new SceneEventData(m_NetworkManager);
+            var sceneEventData = new SceneEventData(NetworkManager);
             SceneEventDataStore.Add(sceneEventData.SceneEventId, sceneEventData);
             return sceneEventData;
         }
@@ -720,18 +720,18 @@ namespace Unity.Netcode
         /// <param name="mode"><see cref="LoadSceneMode"/> for initial client synchronization</param>
         public void SetClientSynchronizationMode(LoadSceneMode mode)
         {
-            var networkManager = m_NetworkManager;
+            var networkManager = NetworkManager;
             SceneManagerHandler.SetClientSynchronizationMode(ref networkManager, mode);
         }
 
         /// <summary>
         /// Constructor
         /// </summary>
-        /// <param name="networkManager">one <see cref="NetworkManager"/> instance per <see cref="NetworkSceneManager"/> instance</param>
+        /// <param name="networkManager">one <see cref="Netcode.NetworkManager"/> instance per <see cref="NetworkSceneManager"/> instance</param>
         /// <param name="sceneEventDataPoolSize">maximum <see cref="SceneEventData"/> pool size</param>
         internal NetworkSceneManager(NetworkManager networkManager)
         {
-            m_NetworkManager = networkManager;
+            NetworkManager = networkManager;
             SceneEventDataStore = new Dictionary<uint, SceneEventData>();
 
             // Generates the scene name to hash value
@@ -750,7 +750,7 @@ namespace Unity.Netcode
         private void SceneManager_ActiveSceneChanged(Scene current, Scene next)
         {
             // If no clients are connected, then don't worry about notifications
-            if (!(m_NetworkManager.ConnectedClientsIds.Count > (m_NetworkManager.IsHost ? 1 : 0)))
+            if (!(NetworkManager.ConnectedClientsIds.Count > (NetworkManager.IsHost ? 1 : 0)))
             {
                 return;
             }
@@ -771,7 +771,7 @@ namespace Unity.Netcode
                 var sceneEvent = BeginSceneEvent();
                 sceneEvent.SceneEventType = SceneEventType.ActiveSceneChanged;
                 sceneEvent.ActiveSceneHash = BuildIndexToHash[next.buildIndex];
-                SendSceneEventData(sceneEvent.SceneEventId, m_NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
+                SendSceneEventData(sceneEvent.SceneEventId, NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
                 EndSceneEvent(sceneEvent.SceneEventId);
             }
         }
@@ -786,9 +786,18 @@ namespace Unity.Netcode
         /// <returns>true (Valid) or false (Invalid)</returns>
         internal bool ValidateSceneBeforeLoading(uint sceneHash, LoadSceneMode loadSceneMode)
         {
-            var validated = true;
             var sceneName = SceneNameFromHash(sceneHash);
             var sceneIndex = SceneUtility.GetBuildIndexByScenePath(sceneName);
+            return ValidateSceneBeforeLoading(sceneIndex, sceneName, loadSceneMode);
+        }
+
+        /// <summary>
+        /// Overloaded version that is invoked by <see cref="ValidateSceneBeforeLoading"/> and <see cref="SynchronizeNetworkObjects"/>.
+        /// This specifically is to allow runtime generated scenes to be excluded by the server during synchronization.
+        /// </summary>
+        internal bool ValidateSceneBeforeLoading(int sceneIndex, string sceneName, LoadSceneMode loadSceneMode)
+        {
+            var validated = true;
             if (VerifySceneBeforeLoading != null)
             {
                 validated = VerifySceneBeforeLoading.Invoke(sceneIndex, sceneName, loadSceneMode);
@@ -796,9 +805,9 @@ namespace Unity.Netcode
             if (!validated && !m_DisableValidationWarningMessages)
             {
                 var serverHostorClient = "Client";
-                if (m_NetworkManager.IsServer)
+                if (NetworkManager.IsServer)
                 {
-                    serverHostorClient = m_NetworkManager.IsHost ? "Host" : "Server";
+                    serverHostorClient = NetworkManager.IsHost ? "Host" : "Server";
                 }
 
                 Debug.LogWarning($"Scene {sceneName} of Scenes in Build Index {sceneIndex} being loaded in {loadSceneMode} mode failed validation on the {serverHostorClient}!");
@@ -837,7 +846,7 @@ namespace Unity.Netcode
                         if (!ScenesLoaded.ContainsKey(sceneLoaded.handle))
                         {
                             ScenesLoaded.Add(sceneLoaded.handle, sceneLoaded);
-                            SceneManagerHandler.StartTrackingScene(sceneLoaded, true, m_NetworkManager);
+                            SceneManagerHandler.StartTrackingScene(sceneLoaded, true, NetworkManager);
                             return sceneLoaded;
                         }
                     }
@@ -886,7 +895,7 @@ namespace Unity.Netcode
                 // Most common scenario for DontDestroyOnLoad is when NetworkManager is set to not be destroyed
                 if (serverSceneHandle == DontDestroyOnLoadScene.handle)
                 {
-                    SceneBeingSynchronized = m_NetworkManager.gameObject.scene;
+                    SceneBeingSynchronized = NetworkManager.gameObject.scene;
                     return;
                 }
                 else
@@ -940,9 +949,9 @@ namespace Unity.Netcode
             {
                 EventData = SceneEventDataStore[sceneEventId]
             };
-            var size = m_NetworkManager.SendMessage(ref message, k_DeliveryType, targetClientIds);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, k_DeliveryType, targetClientIds);
 
-            m_NetworkManager.NetworkMetrics.TrackSceneEventSent(targetClientIds, (uint)SceneEventDataStore[sceneEventId].SceneEventType, SceneNameFromHash(SceneEventDataStore[sceneEventId].SceneHash), size);
+            NetworkManager.NetworkMetrics.TrackSceneEventSent(targetClientIds, (uint)SceneEventDataStore[sceneEventId].SceneEventType, SceneNameFromHash(SceneEventDataStore[sceneEventId].SceneHash), size);
         }
 
         /// <summary>
@@ -952,16 +961,16 @@ namespace Unity.Netcode
         /// <returns></returns>
         private SceneEventProgress ValidateSceneEventUnloading(Scene scene)
         {
-            if (!m_NetworkManager.IsServer)
+            if (!NetworkManager.IsServer)
             {
                 throw new NotServerException("Only server can start a scene event!");
             }
 
-            if (!m_NetworkManager.NetworkConfig.EnableSceneManagement)
+            if (!NetworkManager.NetworkConfig.EnableSceneManagement)
             {
                 //Log message about enabling SceneManagement
                 throw new Exception(
-                    $"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(NetworkManager)}'s {nameof(NetworkConfig)}. " +
+                    $"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(Netcode.NetworkManager)}'s {nameof(NetworkConfig)}. " +
                     $"Please set {nameof(NetworkConfig.EnableSceneManagement)} flag to true before calling {nameof(LoadScene)} or {nameof(UnloadScene)}.");
             }
 
@@ -981,15 +990,15 @@ namespace Unity.Netcode
         /// <returns></returns>
         private SceneEventProgress ValidateSceneEventLoading(string sceneName)
         {
-            if (!m_NetworkManager.IsServer)
+            if (!NetworkManager.IsServer)
             {
                 throw new NotServerException("Only server can start a scene event!");
             }
-            if (!m_NetworkManager.NetworkConfig.EnableSceneManagement)
+            if (!NetworkManager.NetworkConfig.EnableSceneManagement)
             {
                 //Log message about enabling SceneManagement
                 throw new Exception(
-                    $"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(NetworkManager)}'s {nameof(NetworkConfig)}. " +
+                    $"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(Netcode.NetworkManager)}'s {nameof(NetworkConfig)}. " +
                     $"Please set {nameof(NetworkConfig.EnableSceneManagement)} flag to true before calling {nameof(LoadScene)} or {nameof(UnloadScene)}.");
             }
 
@@ -1017,7 +1026,7 @@ namespace Unity.Netcode
                 return new SceneEventProgress(null, SceneEventProgressStatus.InvalidSceneName);
             }
 
-            var sceneEventProgress = new SceneEventProgress(m_NetworkManager)
+            var sceneEventProgress = new SceneEventProgress(NetworkManager)
             {
                 SceneHash = SceneHashFromNameOrPath(sceneName)
             };
@@ -1052,10 +1061,10 @@ namespace Unity.Netcode
             {
                 EventData = sceneEventData
             };
-            var size = m_NetworkManager.SendMessage(ref message, k_DeliveryType, m_NetworkManager.ConnectedClientsIds);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, k_DeliveryType, NetworkManager.ConnectedClientsIds);
 
-            m_NetworkManager.NetworkMetrics.TrackSceneEventSent(
-                m_NetworkManager.ConnectedClientsIds,
+            NetworkManager.NetworkMetrics.TrackSceneEventSent(
+                NetworkManager.ConnectedClientsIds,
                 (uint)sceneEventProgress.SceneEventType,
                 SceneNameFromHash(sceneEventProgress.SceneHash),
                 size);
@@ -1116,7 +1125,7 @@ namespace Unity.Netcode
             // Any NetworkObjects marked to not be destroyed with a scene and reside within the scene about to be unloaded
             // should be migrated temporarily into the DDOL, once the scene is unloaded they will be migrated into the
             // currently active scene.
-            var networkManager = m_NetworkManager;
+            var networkManager = NetworkManager;
             SceneManagerHandler.MoveObjectsFromSceneToDontDestroyOnLoad(ref networkManager, scene);
 
             var sceneEventData = BeginSceneEvent();
@@ -1179,18 +1188,18 @@ namespace Unity.Netcode
             // Any NetworkObjects marked to not be destroyed with a scene and reside within the scene about to be unloaded
             // should be migrated temporarily into the DDOL, once the scene is unloaded they will be migrated into the
             // currently active scene.
-            var networkManager = m_NetworkManager;
+            var networkManager = NetworkManager;
             SceneManagerHandler.MoveObjectsFromSceneToDontDestroyOnLoad(ref networkManager, scene);
 
             m_IsSceneEventActive = true;
-            var sceneEventProgress = new SceneEventProgress(m_NetworkManager)
+            var sceneEventProgress = new SceneEventProgress(NetworkManager)
             {
                 SceneEventId = sceneEventData.SceneEventId,
                 OnSceneEventCompleted = OnSceneUnloaded
             };
             var sceneUnload = SceneManagerHandler.UnloadSceneAsync(scene, sceneEventProgress);
 
-            SceneManagerHandler.StopTrackingScene(sceneHandle, sceneName, m_NetworkManager);
+            SceneManagerHandler.StopTrackingScene(sceneHandle, sceneName, NetworkManager);
 
             // Remove our server to scene handle lookup
             if (!RemoveServerClientSceneHandle(sceneEventData.SceneHandle, sceneHandle))
@@ -1206,10 +1215,10 @@ namespace Unity.Netcode
                 SceneEventType = sceneEventData.SceneEventType,
                 LoadSceneMode = LoadSceneMode.Additive,     // The only scenes unloaded are scenes that were additively loaded
                 SceneName = sceneName,
-                ClientId = m_NetworkManager.LocalClientId   // Server sent this message to the client, but client is executing it
+                ClientId = NetworkManager.LocalClientId   // Server sent this message to the client, but client is executing it
             });
 
-            OnUnload?.Invoke(m_NetworkManager.LocalClientId, sceneName, sceneUnload);
+            OnUnload?.Invoke(NetworkManager.LocalClientId, sceneName, sceneUnload);
         }
 
         /// <summary>
@@ -1219,7 +1228,7 @@ namespace Unity.Netcode
         private void OnSceneUnloaded(uint sceneEventId)
         {
             // If we are shutdown or about to shutdown, then ignore this event
-            if (!m_NetworkManager.IsListening || m_NetworkManager.ShutdownInProgress)
+            if (!NetworkManager.IsListening || NetworkManager.ShutdownInProgress)
             {
                 return;
             }
@@ -1229,15 +1238,15 @@ namespace Unity.Netcode
 
             var sceneEventData = SceneEventDataStore[sceneEventId];
             // First thing we do, if we are a server, is to send the unload scene event.
-            if (m_NetworkManager.IsServer)
+            if (NetworkManager.IsServer)
             {
                 // Server sends the unload scene notification after unloading because it will despawn all scene relative in-scene NetworkObjects
                 // If we send this event to all clients before the server is finished unloading they will get warning about an object being
                 // despawned that no longer exists
-                SendSceneEventData(sceneEventId, m_NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
+                SendSceneEventData(sceneEventId, NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
 
                 //Only if we are a host do we want register having loaded for the associated SceneEventProgress
-                if (SceneEventProgressTracking.ContainsKey(sceneEventData.SceneEventProgressId) && m_NetworkManager.IsHost)
+                if (SceneEventProgressTracking.ContainsKey(sceneEventData.SceneEventProgressId) && NetworkManager.IsHost)
                 {
                     SceneEventProgressTracking[sceneEventData.SceneEventProgressId].ClientFinishedSceneEvent(NetworkManager.ServerClientId);
                 }
@@ -1252,13 +1261,13 @@ namespace Unity.Netcode
                 SceneEventType = sceneEventData.SceneEventType,
                 LoadSceneMode = sceneEventData.LoadSceneMode,
                 SceneName = SceneNameFromHash(sceneEventData.SceneHash),
-                ClientId = m_NetworkManager.IsServer ? NetworkManager.ServerClientId : m_NetworkManager.LocalClientId
+                ClientId = NetworkManager.IsServer ? NetworkManager.ServerClientId : NetworkManager.LocalClientId
             });
 
-            OnUnloadComplete?.Invoke(m_NetworkManager.LocalClientId, SceneNameFromHash(sceneEventData.SceneHash));
+            OnUnloadComplete?.Invoke(NetworkManager.LocalClientId, SceneNameFromHash(sceneEventData.SceneHash));
 
             // Clients send a notification back to the server they have completed the unload scene event
-            if (!m_NetworkManager.IsServer)
+            if (!NetworkManager.IsServer)
             {
                 SendSceneEventData(sceneEventId, new ulong[] { NetworkManager.ServerClientId });
             }
@@ -1288,7 +1297,7 @@ namespace Unity.Netcode
                 // Validate the scene as well as ignore the DDOL (which will have a negative buildIndex)
                 if (currentActiveScene.name != keyHandleEntry.Value.name && keyHandleEntry.Value.buildIndex >= 0)
                 {
-                    var sceneEventProgress = new SceneEventProgress(m_NetworkManager)
+                    var sceneEventProgress = new SceneEventProgress(NetworkManager)
                     {
                         SceneEventId = sceneEventId,
                         OnSceneEventCompleted = EmptySceneUnloadedOperation
@@ -1299,7 +1308,7 @@ namespace Unity.Netcode
             }
             // clear out our scenes loaded list
             ScenesLoaded.Clear();
-            SceneManagerHandler.ClearSceneTracking(m_NetworkManager);
+            SceneManagerHandler.ClearSceneTracking(NetworkManager);
         }
 
         /// <summary>
@@ -1348,7 +1357,7 @@ namespace Unity.Netcode
                 IsSpawnedObjectsPendingInDontDestroyOnLoad = true;
 
                 // Destroy current scene objects before switching.
-                m_NetworkManager.SpawnManager.ServerDestroySpawnedSceneObjects();
+                NetworkManager.SpawnManager.ServerDestroySpawnedSceneObjects();
 
                 // Preserve the objects that should not be destroyed during the scene event
                 MoveObjectsToDontDestroyOnLoad();
@@ -1390,7 +1399,7 @@ namespace Unity.Netcode
 
             internal static void RegisterScene(NetworkSceneManager networkSceneManager, Scene scene, LoadSceneMode loadSceneMode, AsyncOperation asyncOperation = null)
             {
-                var networkManager = networkSceneManager.m_NetworkManager;
+                var networkManager = networkSceneManager.NetworkManager;
                 if (!s_Instances.ContainsKey(networkManager))
                 {
                     s_Instances.Add(networkManager, new List<SceneUnloadEventHandler>());
@@ -1401,11 +1410,11 @@ namespace Unity.Netcode
 
             private static void SceneUnloadComplete(SceneUnloadEventHandler sceneUnloadEventHandler)
             {
-                if (sceneUnloadEventHandler == null || sceneUnloadEventHandler.m_NetworkSceneManager == null || sceneUnloadEventHandler.m_NetworkSceneManager.m_NetworkManager == null)
+                if (sceneUnloadEventHandler == null || sceneUnloadEventHandler.m_NetworkSceneManager == null || sceneUnloadEventHandler.m_NetworkSceneManager.NetworkManager == null)
                 {
                     return;
                 }
-                var networkManager = sceneUnloadEventHandler.m_NetworkSceneManager.m_NetworkManager;
+                var networkManager = sceneUnloadEventHandler.m_NetworkSceneManager.NetworkManager;
                 if (s_Instances.ContainsKey(networkManager))
                 {
                     s_Instances[networkManager].Remove(sceneUnloadEventHandler);
@@ -1449,7 +1458,7 @@ namespace Unity.Netcode
             {
                 if (m_Scene.handle == scene.handle && !m_ShuttingDown)
                 {
-                    if (m_NetworkSceneManager != null && m_NetworkSceneManager.m_NetworkManager != null)
+                    if (m_NetworkSceneManager != null && m_NetworkSceneManager.NetworkManager != null)
                     {
                         m_NetworkSceneManager.OnSceneEvent?.Invoke(new SceneEvent()
                         {
@@ -1484,7 +1493,7 @@ namespace Unity.Netcode
                     ClientId = clientId
                 });
 
-                m_NetworkSceneManager.OnUnload?.Invoke(networkSceneManager.m_NetworkManager.LocalClientId, m_Scene.name, null);
+                m_NetworkSceneManager.OnUnload?.Invoke(networkSceneManager.NetworkManager.LocalClientId, m_Scene.name, null);
             }
         }
 
@@ -1527,7 +1536,7 @@ namespace Unity.Netcode
                 SceneUnloadEventHandler.RegisterScene(this, SceneManager.GetActiveScene(), LoadSceneMode.Single);
 
             }
-            var sceneEventProgress = new SceneEventProgress(m_NetworkManager)
+            var sceneEventProgress = new SceneEventProgress(NetworkManager)
             {
                 SceneEventId = sceneEventId,
                 OnSceneEventCompleted = OnSceneLoaded
@@ -1540,10 +1549,10 @@ namespace Unity.Netcode
                 SceneEventType = sceneEventData.SceneEventType,
                 LoadSceneMode = sceneEventData.LoadSceneMode,
                 SceneName = sceneName,
-                ClientId = m_NetworkManager.LocalClientId
+                ClientId = NetworkManager.LocalClientId
             });
 
-            OnLoad?.Invoke(m_NetworkManager.LocalClientId, sceneName, sceneEventData.LoadSceneMode, sceneLoad);
+            OnLoad?.Invoke(NetworkManager.LocalClientId, sceneName, sceneEventData.LoadSceneMode, sceneLoad);
         }
 
         /// <summary>
@@ -1553,7 +1562,7 @@ namespace Unity.Netcode
         private void OnSceneLoaded(uint sceneEventId)
         {
             // If we are shutdown or about to shutdown, then ignore this event
-            if (!m_NetworkManager.IsListening || m_NetworkManager.ShutdownInProgress)
+            if (!NetworkManager.IsListening || NetworkManager.ShutdownInProgress)
             {
                 return;
             }
@@ -1586,7 +1595,7 @@ namespace Unity.Netcode
             // not destroy temporary scene are moved into the active scene
             IsSpawnedObjectsPendingInDontDestroyOnLoad = false;
 
-            if (m_NetworkManager.IsServer)
+            if (NetworkManager.IsServer)
             {
                 OnServerLoadedScene(sceneEventId, nextScene);
             }
@@ -1618,8 +1627,8 @@ namespace Unity.Netcode
                     if (!keyValuePairBySceneHandle.Value.IsPlayerObject)
                     {
                         // All in-scene placed NetworkObjects default to being owned by the server
-                        m_NetworkManager.SpawnManager.SpawnNetworkObjectLocally(keyValuePairBySceneHandle.Value,
-                            m_NetworkManager.SpawnManager.GetNetworkObjectId(), true, false, NetworkManager.ServerClientId, true);
+                        NetworkManager.SpawnManager.SpawnNetworkObjectLocally(keyValuePairBySceneHandle.Value,
+                            NetworkManager.SpawnManager.GetNetworkObjectId(), true, false, NetworkManager.ServerClientId, true);
                     }
                 }
             }
@@ -1631,9 +1640,9 @@ namespace Unity.Netcode
             sceneEventData.SceneHandle = scene.handle;
 
             // Send all clients the scene load event
-            for (int j = 0; j < m_NetworkManager.ConnectedClientsList.Count; j++)
+            for (int j = 0; j < NetworkManager.ConnectedClientsList.Count; j++)
             {
-                var clientId = m_NetworkManager.ConnectedClientsList[j].ClientId;
+                var clientId = NetworkManager.ConnectedClientsList[j].ClientId;
                 if (clientId != NetworkManager.ServerClientId)
                 {
                     sceneEventData.TargetClientId = clientId;
@@ -1641,8 +1650,8 @@ namespace Unity.Netcode
                     {
                         EventData = sceneEventData
                     };
-                    var size = m_NetworkManager.SendMessage(ref message, k_DeliveryType, clientId);
-                    m_NetworkManager.NetworkMetrics.TrackSceneEventSent(clientId, (uint)sceneEventData.SceneEventType, scene.name, size);
+                    var size = NetworkManager.ConnectionManager.SendMessage(ref message, k_DeliveryType, clientId);
+                    NetworkManager.NetworkMetrics.TrackSceneEventSent(clientId, (uint)sceneEventData.SceneEventType, scene.name, size);
                 }
             }
 
@@ -1660,7 +1669,7 @@ namespace Unity.Netcode
             OnLoadComplete?.Invoke(NetworkManager.ServerClientId, SceneNameFromHash(sceneEventData.SceneHash), sceneEventData.LoadSceneMode);
 
             //Second, only if we are a host do we want register having loaded for the associated SceneEventProgress
-            if (SceneEventProgressTracking.ContainsKey(sceneEventData.SceneEventProgressId) && m_NetworkManager.IsHost)
+            if (SceneEventProgressTracking.ContainsKey(sceneEventData.SceneEventProgressId) && NetworkManager.IsHost)
             {
                 SceneEventProgressTracking[sceneEventData.SceneEventProgressId].ClientFinishedSceneEvent(NetworkManager.ServerClientId);
             }
@@ -1686,11 +1695,11 @@ namespace Unity.Netcode
                 SceneEventType = SceneEventType.LoadComplete,
                 LoadSceneMode = sceneEventData.LoadSceneMode,
                 SceneName = SceneNameFromHash(sceneEventData.SceneHash),
-                ClientId = m_NetworkManager.LocalClientId,
+                ClientId = NetworkManager.LocalClientId,
                 Scene = scene,
             });
 
-            OnLoadComplete?.Invoke(m_NetworkManager.LocalClientId, SceneNameFromHash(sceneEventData.SceneHash), sceneEventData.LoadSceneMode);
+            OnLoadComplete?.Invoke(NetworkManager.LocalClientId, SceneNameFromHash(sceneEventData.SceneHash), sceneEventData.LoadSceneMode);
 
             EndSceneEvent(sceneEventId);
         }
@@ -1713,7 +1722,7 @@ namespace Unity.Netcode
         internal void SynchronizeNetworkObjects(ulong clientId)
         {
             // Update the clients
-            m_NetworkManager.SpawnManager.UpdateObservedNetworkObjects(clientId);
+            NetworkManager.SpawnManager.UpdateObservedNetworkObjects(clientId);
 
             var sceneEventData = BeginSceneEvent();
             sceneEventData.ClientSynchronizationMode = ClientSynchronizationMode;
@@ -1744,24 +1753,22 @@ namespace Unity.Netcode
                     continue;
                 }
 
-                var sceneHash = SceneHashFromNameOrPath(scene.path);
-
                 // This would depend upon whether we are additive or not
                 // If we are the base scene, then we set the root scene index;
                 if (activeScene == scene)
                 {
-                    if (!ValidateSceneBeforeLoading(sceneHash, sceneEventData.LoadSceneMode))
+                    if (!ValidateSceneBeforeLoading(scene.buildIndex, scene.name, sceneEventData.LoadSceneMode))
                     {
                         continue;
                     }
-                    sceneEventData.SceneHash = sceneHash;
+                    sceneEventData.SceneHash = SceneHashFromNameOrPath(scene.path);
                     sceneEventData.SceneHandle = scene.handle;
                 }
-                else if (!ValidateSceneBeforeLoading(sceneHash, LoadSceneMode.Additive))
+                else if (!ValidateSceneBeforeLoading(scene.buildIndex, scene.name, LoadSceneMode.Additive))
                 {
                     continue;
                 }
-                sceneEventData.AddSceneToSynchronize(sceneHash, scene.handle);
+                sceneEventData.AddSceneToSynchronize(SceneHashFromNameOrPath(scene.path), scene.handle);
             }
 
             sceneEventData.AddSpawnedNetworkObjects();
@@ -1771,8 +1778,8 @@ namespace Unity.Netcode
             {
                 EventData = sceneEventData
             };
-            var size = m_NetworkManager.SendMessage(ref message, k_DeliveryType, clientId);
-            m_NetworkManager.NetworkMetrics.TrackSceneEventSent(clientId, (uint)sceneEventData.SceneEventType, "", size);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, k_DeliveryType, clientId);
+            NetworkManager.NetworkMetrics.TrackSceneEventSent(clientId, (uint)sceneEventData.SceneEventType, "", size);
 
             // Notify the local server that the client has been sent the synchronize event
             OnSceneEvent?.Invoke(new SceneEvent()
@@ -1811,17 +1818,17 @@ namespace Unity.Netcode
                 OnSceneEvent?.Invoke(new SceneEvent()
                 {
                     SceneEventType = SceneEventType.Synchronize,
-                    ClientId = m_NetworkManager.LocalClientId,
+                    ClientId = NetworkManager.LocalClientId,
                 });
 
-                OnSynchronize?.Invoke(m_NetworkManager.LocalClientId);
+                OnSynchronize?.Invoke(NetworkManager.LocalClientId);
             }
 
             // Always check to see if the scene needs to be validated
             if (!ValidateSceneBeforeLoading(sceneHash, loadSceneMode))
             {
                 HandleClientSceneEvent(sceneEventId);
-                if (m_NetworkManager.LogLevel == LogLevel.Developer)
+                if (NetworkManager.LogLevel == LogLevel.Developer)
                 {
                     NetworkLog.LogInfo($"Client declined to load the scene {sceneName}, continuing with synchronization.");
                 }
@@ -1835,12 +1842,12 @@ namespace Unity.Netcode
             // it should pass through to post load processing (ClientLoadedSynchronization).
             // For ClientSynchronizationMode LoadSceneMode.Additive, if the scene is already loaded or the active scene is the scene to be loaded (does not require it to
             // be the initial primary scene) then go ahead and pass through to post load processing (ClientLoadedSynchronization).
-            var shouldPassThrough = SceneManagerHandler.ClientShouldPassThrough(sceneName, sceneHash == sceneEventData.SceneHash, ClientSynchronizationMode, m_NetworkManager);
+            var shouldPassThrough = SceneManagerHandler.ClientShouldPassThrough(sceneName, sceneHash == sceneEventData.SceneHash, ClientSynchronizationMode, NetworkManager);
 
             if (!shouldPassThrough)
             {
                 // If not, then load the scene
-                var sceneEventProgress = new SceneEventProgress(m_NetworkManager)
+                var sceneEventProgress = new SceneEventProgress(NetworkManager)
                 {
                     SceneEventId = sceneEventId,
                     OnSceneEventCompleted = ClientLoadedSynchronization
@@ -1854,10 +1861,10 @@ namespace Unity.Netcode
                     SceneEventType = SceneEventType.Load,
                     LoadSceneMode = loadSceneMode,
                     SceneName = sceneName,
-                    ClientId = m_NetworkManager.LocalClientId,
+                    ClientId = NetworkManager.LocalClientId,
                 });
 
-                OnLoad?.Invoke(m_NetworkManager.LocalClientId, sceneName, loadSceneMode, sceneLoad);
+                OnLoad?.Invoke(NetworkManager.LocalClientId, sceneName, loadSceneMode, sceneLoad);
             }
             else
             {
@@ -1875,7 +1882,7 @@ namespace Unity.Netcode
         {
             var sceneEventData = SceneEventDataStore[sceneEventId];
             var sceneName = SceneNameFromHash(sceneEventData.ClientSceneHash);
-            var nextScene = SceneManagerHandler.GetSceneFromLoadedScenes(sceneName, m_NetworkManager);
+            var nextScene = SceneManagerHandler.GetSceneFromLoadedScenes(sceneName, NetworkManager);
             if (!nextScene.IsValid())
             {
                 nextScene = GetAndAddNewlyLoadedSceneByName(sceneName);
@@ -1915,9 +1922,9 @@ namespace Unity.Netcode
             {
                 EventData = responseSceneEventData
             };
-            var size = m_NetworkManager.SendMessage(ref message, k_DeliveryType, NetworkManager.ServerClientId);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, k_DeliveryType, NetworkManager.ServerClientId);
 
-            m_NetworkManager.NetworkMetrics.TrackSceneEventSent(NetworkManager.ServerClientId, (uint)responseSceneEventData.SceneEventType, sceneName, size);
+            NetworkManager.NetworkMetrics.TrackSceneEventSent(NetworkManager.ServerClientId, (uint)responseSceneEventData.SceneEventType, sceneName, size);
 
             EndSceneEvent(responseSceneEventData.SceneEventId);
 
@@ -1928,10 +1935,10 @@ namespace Unity.Netcode
                 LoadSceneMode = loadSceneMode,
                 SceneName = sceneName,
                 Scene = nextScene,
-                ClientId = m_NetworkManager.LocalClientId,
+                ClientId = NetworkManager.LocalClientId,
             });
 
-            OnLoadComplete?.Invoke(m_NetworkManager.LocalClientId, sceneName, loadSceneMode);
+            OnLoadComplete?.Invoke(NetworkManager.LocalClientId, sceneName, loadSceneMode);
 
             // Check to see if we still have scenes to load and synchronize with
             HandleClientSceneEvent(sceneEventId);
@@ -1944,7 +1951,7 @@ namespace Unity.Netcode
         /// </summary>
         private void SynchronizeNetworkObjectScene()
         {
-            foreach (var networkObject in m_NetworkManager.SpawnManager.SpawnedObjectsList)
+            foreach (var networkObject in NetworkManager.SpawnManager.SpawnedObjectsList)
             {
                 // This is only done for dynamically spawned NetworkObjects
                 // Theoretically, a server could have NetworkObjects in a server-side only scene, if the client doesn't have that scene loaded
@@ -1969,9 +1976,9 @@ namespace Unity.Netcode
 
                             SceneManager.MoveGameObjectToScene(networkObject.gameObject, scene);
                         }
-                        else if (m_NetworkManager.LogLevel <= LogLevel.Normal)
+                        else if (NetworkManager.LogLevel <= LogLevel.Normal)
                         {
-                            NetworkLog.LogWarningServer($"[Client-{m_NetworkManager.LocalClientId}][{networkObject.gameObject.name}] Server - " +
+                            NetworkLog.LogWarningServer($"[Client-{NetworkManager.LocalClientId}][{networkObject.gameObject.name}] Server - " +
                                 $"client scene mismatch detected! Client-side has no scene loaded with handle ({networkObject.SceneOriginHandle})!");
                         }
                     }
@@ -2026,8 +2033,6 @@ namespace Unity.Netcode
                         {
                             // Include anything in the DDOL scene
                             PopulateScenePlacedObjects(DontDestroyOnLoadScene, false);
-                            // Synchronize the NetworkObjects for this scene
-                            sceneEventData.SynchronizeSceneNetworkObjects(m_NetworkManager);
 
                             // If needed, set the currently active scene
                             if (HashToBuildIndex.ContainsKey(sceneEventData.ActiveSceneHash))
@@ -2039,23 +2044,26 @@ namespace Unity.Netcode
                                 }
                             }
 
-                            // If needed, migrate dynamically spawned NetworkObjects to the same scene as on the server side
+                            // Spawn and Synchronize all NetworkObjects
+                            sceneEventData.SynchronizeSceneNetworkObjects(NetworkManager);
+
+                            // If needed, migrate dynamically spawned NetworkObjects to the same scene as they are on the server
                             SynchronizeNetworkObjectScene();
 
                             sceneEventData.SceneEventType = SceneEventType.SynchronizeComplete;
                             SendSceneEventData(sceneEventId, new ulong[] { NetworkManager.ServerClientId });
 
                             // All scenes are synchronized, let the server know we are done synchronizing
-                            m_NetworkManager.IsConnectedClient = true;
+                            NetworkManager.IsConnectedClient = true;
 
                             // Client is now synchronized and fully "connected".  This also means the client can send "RPCs" at this time
-                            m_NetworkManager.InvokeOnClientConnectedCallback(m_NetworkManager.LocalClientId);
+                            NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(NetworkManager.LocalClientId);
 
                             // Notify the client that they have finished synchronizing
                             OnSceneEvent?.Invoke(new SceneEvent()
                             {
                                 SceneEventType = sceneEventData.SceneEventType,
-                                ClientId = m_NetworkManager.LocalClientId, // Client sent this to the server
+                                ClientId = NetworkManager.LocalClientId, // Client sent this to the server
                             });
 
                             // Process any SceneEventType.ObjectSceneChanged messages that
@@ -2068,10 +2076,10 @@ namespace Unity.Netcode
                             // scene not synchronized by the server will remain loaded)
                             if (PostSynchronizationSceneUnloading && ClientSynchronizationMode == LoadSceneMode.Additive)
                             {
-                                SceneManagerHandler.UnloadUnassignedScenes(m_NetworkManager);
+                                SceneManagerHandler.UnloadUnassignedScenes(NetworkManager);
                             }
 
-                            OnSynchronizeComplete?.Invoke(m_NetworkManager.LocalClientId);
+                            OnSynchronizeComplete?.Invoke(NetworkManager.LocalClientId);
 
                             EndSceneEvent(sceneEventId);
                         }
@@ -2191,11 +2199,11 @@ namespace Unity.Netcode
                         // TODO 2023: We should have a better name for this or have multiple states the
                         // client progresses through (the name and associated legacy behavior/expected state
                         // of the client was persisted since MLAPI)
-                        m_NetworkManager.InvokeOnClientConnectedCallback(clientId);
+                        NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(clientId);
 
                         // Check to see if the client needs to resynchronize and before sending the message make sure the client is still connected to avoid
                         // a potential crash within the MessageSystem (i.e. sending to a client that no longer exists)
-                        if (sceneEventData.ClientNeedsReSynchronization() && !DisableReSynchronization && m_NetworkManager.ConnectedClients.ContainsKey(clientId))
+                        if (sceneEventData.ClientNeedsReSynchronization() && !DisableReSynchronization && NetworkManager.ConnectedClients.ContainsKey(clientId))
                         {
                             sceneEventData.SceneEventType = SceneEventType.ReSynchronize;
                             SendSceneEventData(sceneEventId, new ulong[] { clientId });
@@ -2225,13 +2233,13 @@ namespace Unity.Netcode
         /// <param name="reader">data associated with the scene event</param>
         internal void HandleSceneEvent(ulong clientId, FastBufferReader reader)
         {
-            if (m_NetworkManager != null)
+            if (NetworkManager != null)
             {
                 var sceneEventData = BeginSceneEvent();
 
                 sceneEventData.Deserialize(reader);
 
-                m_NetworkManager.NetworkMetrics.TrackSceneEventReceived(
+                NetworkManager.NetworkMetrics.TrackSceneEventReceived(
                    clientId, (uint)sceneEventData.SceneEventType, SceneNameFromHash(sceneEventData.SceneHash), reader.Length);
 
                 if (sceneEventData.IsSceneEventClientSide())
@@ -2250,7 +2258,7 @@ namespace Unity.Netcode
                             // used if the server is synchronizing the same scenes (i.e. if a matching scene is already loaded on the
                             // client side, then that scene will be used as opposed to loading another scene). This allows for clients
                             // to reconnect to a network session without having to unload all of the scenes and reload all of the scenes.
-                            SceneManagerHandler.PopulateLoadedScenes(ref ScenesLoaded, m_NetworkManager);
+                            SceneManagerHandler.PopulateLoadedScenes(ref ScenesLoaded, NetworkManager);
                         }
                     }
                     HandleClientSceneEvent(sceneEventData.SceneEventId);
@@ -2262,7 +2270,7 @@ namespace Unity.Netcode
             }
             else
             {
-                Debug.LogError($"{nameof(HandleSceneEvent)} was invoked but {nameof(NetworkManager)} reference was null!");
+                Debug.LogError($"{nameof(HandleSceneEvent)} was invoked but {nameof(Netcode.NetworkManager)} reference was null!");
             }
         }
 
@@ -2274,7 +2282,7 @@ namespace Unity.Netcode
         {
             // Create a local copy of the spawned objects list since the spawn manager will adjust the list as objects
             // are despawned.
-            var localSpawnedObjectsHashSet = new HashSet<NetworkObject>(m_NetworkManager.SpawnManager.SpawnedObjectsList);
+            var localSpawnedObjectsHashSet = new HashSet<NetworkObject>(NetworkManager.SpawnManager.SpawnedObjectsList);
             foreach (var networkObject in localSpawnedObjectsHashSet)
             {
                 if (networkObject == null || (networkObject != null && networkObject.gameObject.scene == DontDestroyOnLoadScene))
@@ -2291,7 +2299,7 @@ namespace Unity.Netcode
                         UnityEngine.Object.DontDestroyOnLoad(networkObject.gameObject);
                     }
                 }
-                else if (m_NetworkManager.IsServer)
+                else if (NetworkManager.IsServer)
                 {
                     networkObject.Despawn();
                 }
@@ -2330,7 +2338,7 @@ namespace Unity.Netcode
                 var globalObjectIdHash = networkObjectInstance.GlobalObjectIdHash;
                 var sceneHandle = networkObjectInstance.gameObject.scene.handle;
                 // We check to make sure the NetworkManager instance is the same one to be "NetcodeIntegrationTestHelpers" compatible and filter the list on a per scene basis (for additive scenes)
-                if (networkObjectInstance.IsSceneObject != false && (networkObjectInstance.NetworkManager == m_NetworkManager ||
+                if (networkObjectInstance.IsSceneObject != false && (networkObjectInstance.NetworkManager == NetworkManager ||
                     networkObjectInstance.NetworkManagerOwner == null) && sceneHandle == sceneToFilterBy.handle)
                 {
                     if (!ScenePlacedObjects.ContainsKey(globalObjectIdHash))
@@ -2358,7 +2366,7 @@ namespace Unity.Netcode
         /// <param name="scene">scene to move the NetworkObjects to</param>
         internal void MoveObjectsFromDontDestroyOnLoadToScene(Scene scene)
         {
-            foreach (var networkObject in m_NetworkManager.SpawnManager.SpawnedObjectsList)
+            foreach (var networkObject in NetworkManager.SpawnManager.SpawnedObjectsList)
             {
                 if (networkObject == null)
                 {
@@ -2389,9 +2397,9 @@ namespace Unity.Netcode
         internal void NotifyNetworkObjectSceneChanged(NetworkObject networkObject)
         {
             // Really, this should never happen but in case it does
-            if (!m_NetworkManager.IsServer)
+            if (!NetworkManager.IsServer)
             {
-                if (m_NetworkManager.LogLevel == LogLevel.Developer)
+                if (NetworkManager.LogLevel == LogLevel.Developer)
                 {
                     NetworkLog.LogErrorServer("[Please Report This Error][NotifyNetworkObjectSceneChanged] A client is trying to notify of an object's scene change!");
                 }
@@ -2402,7 +2410,7 @@ namespace Unity.Netcode
             if (networkObject.IsSceneObject != false)
             {
                 // Really, this should ever happen but in case it does
-                if (m_NetworkManager.LogLevel == LogLevel.Developer)
+                if (NetworkManager.LogLevel == LogLevel.Developer)
                 {
                     NetworkLog.LogErrorServer("[Please Report This Error][NotifyNetworkObjectSceneChanged] Trying to notify in-scene placed object scene change!");
                 }
@@ -2468,20 +2476,57 @@ namespace Unity.Netcode
             ObjectsMigratedIntoNewScene.Clear();
         }
 
+
+        private List<int> m_ScenesToRemoveFromObjectMigration = new List<int>();
+
         /// <summary>
-        /// Should be invoked during PostLateUpdate just prior to the
-        /// MessagingSystem processes its outbound message queue.
+        /// Should be invoked during PostLateUpdate just prior to the NetworkMessageManager processes its outbound message queue.
         /// </summary>
         internal void CheckForAndSendNetworkObjectSceneChanged()
         {
             // Early exit if not the server or there is nothing pending
-            if (!m_NetworkManager.IsServer || ObjectsMigratedIntoNewScene.Count == 0)
+            if (!NetworkManager.IsServer || ObjectsMigratedIntoNewScene.Count == 0)
             {
                 return;
             }
+
+            // Double check that the NetworkObjects to migrate still exist
+            m_ScenesToRemoveFromObjectMigration.Clear();
+            foreach (var sceneEntry in ObjectsMigratedIntoNewScene)
+            {
+                for (int i = sceneEntry.Value.Count - 1; i >= 0; i--)
+                {
+                    // Remove NetworkObjects that are no longer spawned
+                    if (!sceneEntry.Value[i].IsSpawned)
+                    {
+                        sceneEntry.Value.RemoveAt(i);
+                    }
+                }
+                // If the scene entry no longer has any NetworkObjects to migrate
+                // then add it to the list of scenes to be removed from the table
+                // of scenes containing NetworkObjects to migrate.
+                if (sceneEntry.Value.Count == 0)
+                {
+                    m_ScenesToRemoveFromObjectMigration.Add(sceneEntry.Key);
+                }
+            }
+
+            // Remove sceneHandle entries that no longer have any NetworkObjects remaining
+            foreach (var sceneHandle in m_ScenesToRemoveFromObjectMigration)
+            {
+                ObjectsMigratedIntoNewScene.Remove(sceneHandle);
+            }
+
+            // If there is nothing to send a migration notification for then exit
+            if (ObjectsMigratedIntoNewScene.Count == 0)
+            {
+                return;
+            }
+
+            // Some NetworkObjects still exist, send the message
             var sceneEvent = BeginSceneEvent();
             sceneEvent.SceneEventType = SceneEventType.ObjectSceneChanged;
-            SendSceneEventData(sceneEvent.SceneEventId, m_NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
+            SendSceneEventData(sceneEvent.SceneEventId, NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
             EndSceneEvent(sceneEvent.SceneEventId);
         }
 

Runtime/Serialization/BufferSerializer.cs

@@ -124,6 +124,25 @@ namespace Unity.Netcode
         /// <typeparam name="T">The type being serialized</typeparam>
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Implementation.SerializeValue(ref value);
 
+        /// <summary>
+        /// Read or write a NativeArray of struct values implementing ISerializeByMemcpy
+        /// </summary>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Implementation.SerializeValue(ref value, allocator);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read or write a NativeList of struct values implementing ISerializeByMemcpy
+        /// </summary>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        public void SerializeValue<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Implementation.SerializeValue(ref value);
+#endif
+
         /// <summary>
         /// Read or write a struct or class value implementing INetworkSerializable
         /// </summary>
@@ -266,6 +285,7 @@ namespace Unity.Netcode
         // Those two are necessary to serialize FixedStrings efficiently
         // - otherwise we'd just be memcpy'ing the whole thing even if
         // most of it isn't used.
+
         /// <summary>
         /// Read or write a FixedString value
         /// </summary>
@@ -275,6 +295,27 @@ namespace Unity.Netcode
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Implementation.SerializeValue(ref value);
 
+        /// <summary>
+        /// Read or write a NativeArray of FixedString values
+        /// </summary>
+        /// <typeparam name="T">The network serializable type</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution of FixedStrings</param>
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Implementation.SerializeValue(ref value, allocator);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read or write a NativeList of FixedString values
+        /// </summary>
+        /// <typeparam name="T">The network serializable type</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution of FixedStrings</param>
+        public void SerializeValue<T>(ref NativeList<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Implementation.SerializeValue(ref value);
+#endif
+
         /// <summary>
         /// Read or write a NetworkSerializable value.
         /// SerializeValue() is the preferred method to do this - this is provided for backward compatibility only.
@@ -381,6 +422,31 @@ namespace Unity.Netcode
         /// <param name="unused">An unused parameter used for enabling overload resolution of structs</param>
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Implementation.SerializeValuePreChecked(ref value);
 
+        /// <summary>
+        /// Serialize a NativeArray of structs, "pre-checked", which skips buffer checks.
+        /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
+        /// calling this. In release builds, calling this without calling "PreCheck" may read or write
+        /// past the end of the buffer, which will cause memory corruption and undefined behavior.
+        /// </summary>
+        /// <typeparam name="T">The network serializable types in an array</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution of structs</param>
+        public void SerializeValuePreChecked<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Implementation.SerializeValuePreChecked(ref value, allocator);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Serialize a NativeList of structs, "pre-checked", which skips buffer checks.
+        /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
+        /// calling this. In release builds, calling this without calling "PreCheck" may read or write
+        /// past the end of the buffer, which will cause memory corruption and undefined behavior.
+        /// </summary>
+        /// <typeparam name="T">The network serializable types in an array</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution of structs</param>
+        public void SerializeValuePreChecked<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Implementation.SerializeValuePreChecked(ref value);
+#endif
+
         /// <summary>
         /// Serialize a Vector2, "pre-checked", which skips buffer checks.
         /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
@@ -463,7 +529,7 @@ namespace Unity.Netcode
         public void SerializeValuePreChecked(ref Vector4 value) => m_Implementation.SerializeValuePreChecked(ref value);
 
         /// <summary>
-        /// Serialize a Vector4Array, "pre-checked", which skips buffer checks.
+        /// Serialize a Vector4 array, "pre-checked", which skips buffer checks.
         /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
         /// calling this. In release builds, calling this without calling "PreCheck" may read or write
         /// past the end of the buffer, which will cause memory corruption and undefined behavior.

Runtime/Serialization/BufferSerializerReader.cs

@@ -30,34 +30,56 @@ namespace Unity.Netcode
         public void SerializeValue(ref byte value) => m_Reader.ReadByteSafe(out value);
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Reader.ReadValueSafe(out value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Reader.ReadValueSafe(out value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Reader.ReadValueSafe(out value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Reader.ReadValueSafe(out value);
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Reader.ReadValueSafe(out value, allocator);
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValue<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Reader.ReadValueSafeInPlace(ref value);
+#endif
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => m_Reader.ReadNetworkSerializableInPlace(ref value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => m_Reader.ReadValue(out value);
 
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Reader.ReadValueSafe(out value);
 
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator) where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Reader.ReadValueSafe(out value, allocator);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValue<T>(ref NativeList<T> value) where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Reader.ReadValueSafeInPlace(ref value);
+#endif
+
         public void SerializeValue(ref Vector2 value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Vector2[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Vector3 value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Vector3[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Vector2Int value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Vector2Int[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Vector3Int value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Vector3Int[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Vector4 value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Vector4[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Quaternion value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Quaternion[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Color value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Color[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Color32 value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Color32[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Ray value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Ray[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Ray2D value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Ray2D[] value) => m_Reader.ReadValueSafe(out value);
 
@@ -72,30 +94,48 @@ namespace Unity.Netcode
         public void SerializeValuePreChecked(ref byte value) => m_Reader.ReadByte(out value);
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Reader.ReadValue(out value);
+        public void SerializeValuePreChecked<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Reader.ReadValue(out value, allocator);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValuePreChecked<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Reader.ReadValueInPlace(ref value);
+#endif
+
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Vector2 value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Vector2[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Vector3 value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Vector3[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Vector2Int value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Vector2Int[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Vector3Int value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Vector3Int[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Vector4 value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Vector4[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Quaternion value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Quaternion[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Color value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Color[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Color32 value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Color32[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Ray value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Ray[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Ray2D value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Ray2D[] value) => m_Reader.ReadValue(out value);
     }

Runtime/Serialization/BufferSerializerWriter.cs

@@ -30,33 +30,55 @@ namespace Unity.Netcode
         public void SerializeValue(ref byte value) => m_Writer.WriteByteSafe(value);
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Writer.WriteValueSafe(value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Writer.WriteValueSafe(value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Writer.WriteValueSafe(value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Writer.WriteValueSafe(value);
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Writer.WriteValueSafe(value);
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValue<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Writer.WriteValueSafe(value);
+#endif
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => m_Writer.WriteValue(value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => m_Writer.WriteValue(value);
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Writer.WriteValueSafe(value);
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator) where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Writer.WriteValueSafe(value);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValue<T>(ref NativeList<T> value) where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Writer.WriteValueSafe(value);
+#endif
 
         public void SerializeValue(ref Vector2 value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Vector2[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Vector3 value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Vector3[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Vector2Int value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Vector2Int[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Vector3Int value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Vector3Int[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Vector4 value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Vector4[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Quaternion value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Quaternion[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Color value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Color[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Color32 value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Color32[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Ray value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Ray[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Ray2D value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Ray2D[] value) => m_Writer.WriteValueSafe(value);
 
@@ -77,29 +99,44 @@ namespace Unity.Netcode
 
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Writer.WriteValue(value);
+        public void SerializeValuePreChecked<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Writer.WriteValue(value);
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValuePreChecked<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Writer.WriteValue(value);
+#endif
+
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Writer.WriteValue(value);
 
         public void SerializeValuePreChecked(ref Vector2 value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Vector2[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Vector3 value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Vector3[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Vector2Int value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Vector2Int[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Vector3Int value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Vector3Int[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Vector4 value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Vector4[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Quaternion value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Quaternion[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Color value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Color[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Color32 value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Color32[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Ray value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Ray[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Ray2D value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Ray2D[] value) => m_Writer.WriteValue(value);
     }

Runtime/Serialization/FastBufferReader.cs

@@ -62,7 +62,7 @@ namespace Unity.Netcode
 
         private static unsafe ReaderHandle* CreateHandle(byte* buffer, int length, int offset, Allocator copyAllocator, Allocator internalAllocator)
         {
-            ReaderHandle* readerHandle = null;
+            ReaderHandle* readerHandle;
             if (copyAllocator == Allocator.None)
             {
                 readerHandle = (ReaderHandle*)UnsafeUtility.Malloc(sizeof(ReaderHandle), UnsafeUtility.AlignOf<byte>(), internalAllocator);
@@ -461,6 +461,42 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Read a NativeArray of INetworkSerializables
+        /// </summary>
+        /// <param name="value">INetworkSerializable instance</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray</param>
+        /// <typeparam name="T">the array to read the values of type `T` into</typeparam>
+        /// <exception cref="NotImplementedException"></exception>
+        public void ReadNetworkSerializable<T>(out NativeArray<T> value, Allocator allocator) where T : unmanaged, INetworkSerializable
+        {
+            ReadValueSafe(out int size);
+            value = new NativeArray<T>(size, allocator);
+            for (var i = 0; i < size; ++i)
+            {
+                ReadNetworkSerializable(out T item);
+                value[i] = item;
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read a NativeList of INetworkSerializables
+        /// </summary>
+        /// <param name="value">INetworkSerializable instance</param>
+        /// <typeparam name="T">the array to read the values of type `T` into</typeparam>
+        /// <exception cref="NotImplementedException"></exception>
+        public void ReadNetworkSerializableInPlace<T>(ref NativeList<T> value) where T : unmanaged, INetworkSerializable
+        {
+            ReadValueSafe(out int size);
+            value.Resize(size, NativeArrayOptions.UninitializedMemory);
+            for (var i = 0; i < size; ++i)
+            {
+                ReadNetworkSerializable(out value.ElementAt(i));
+            }
+        }
+#endif
+
         /// <summary>
         /// Read an INetworkSerializable in-place, without constructing a new one
         /// Note that this will NOT check for null before calling NetworkSerialize
@@ -757,6 +793,44 @@ namespace Unity.Netcode
                 ReadBytesSafe(bytes, sizeInBytes);
             }
         }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void ReadUnmanaged<T>(out NativeArray<T> value, Allocator allocator) where T : unmanaged
+        {
+            ReadUnmanaged(out int sizeInTs);
+            int sizeInBytes = sizeInTs * sizeof(T);
+            value = new NativeArray<T>(sizeInTs, allocator);
+            byte* bytes = (byte*)value.GetUnsafePtr();
+            ReadBytes(bytes, sizeInBytes);
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void ReadUnmanagedSafe<T>(out NativeArray<T> value, Allocator allocator) where T : unmanaged
+        {
+            ReadUnmanagedSafe(out int sizeInTs);
+            int sizeInBytes = sizeInTs * sizeof(T);
+            value = new NativeArray<T>(sizeInTs, allocator);
+            byte* bytes = (byte*)value.GetUnsafePtr();
+            ReadBytesSafe(bytes, sizeInBytes);
+        }
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void ReadUnmanagedInPlace<T>(ref NativeList<T> value) where T : unmanaged
+        {
+            ReadUnmanaged(out int sizeInTs);
+            int sizeInBytes = sizeInTs * sizeof(T);
+            value.Resize(sizeInTs, NativeArrayOptions.UninitializedMemory);
+            byte* bytes = (byte*)value.GetUnsafePtr();
+            ReadBytes(bytes, sizeInBytes);
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void ReadUnmanagedSafeInPlace<T>(ref NativeList<T> value) where T : unmanaged
+        {
+            ReadUnmanagedSafe(out int sizeInTs);
+            int sizeInBytes = sizeInTs * sizeof(T);
+            value.Resize(sizeInTs, NativeArrayOptions.UninitializedMemory);
+            byte* bytes = (byte*)value.GetUnsafePtr();
+            ReadBytesSafe(bytes, sizeInBytes);
+        }
+#endif
 
         /// <summary>
         /// Read a NetworkSerializable value
@@ -800,6 +874,19 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => ReadNetworkSerializable(out value);
 
+        /// <summary>
+        /// Read a NetworkSerializable NativeArray
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out NativeArray<T> value, Allocator allocator, FastBufferWriter.ForNetworkSerializable unused = default) where T : unmanaged, INetworkSerializable => ReadNetworkSerializable(out value, allocator);
+
 
         /// <summary>
         /// Read a struct
@@ -819,6 +906,72 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ReadValue<T>(out T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => ReadUnmanaged(out value);
 
+        /// <summary>
+        /// Read a struct NativeArray
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue<T>(out NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.ReadWithAllocator(this, out value, allocator);
+            }
+            else
+            {
+                ReadUnmanaged(out value, allocator);
+            }
+        }
+
+        /// <summary>
+        /// Read a struct NativeArray using a Temp allocator. Equivalent to ReadValue(out value, Allocator.Temp)
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueTemp<T>(out NativeArray<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.ReadWithAllocator(this, out value, Allocator.Temp);
+            }
+            else
+            {
+                ReadUnmanaged(out value, Allocator.Temp);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read a struct NativeList
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueInPlace<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeList<T>>.Serializer.Read(this, ref value);
+            }
+            else
+            {
+                ReadUnmanagedInPlace(ref value);
+            }
+        }
+#endif
+
         /// <summary>
         /// Read a struct
         ///
@@ -843,6 +996,81 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => ReadUnmanagedSafe(out value);
 
+        /// <summary>
+        /// Read a struct NativeArray
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.ReadWithAllocator(this, out value, allocator);
+            }
+            else
+            {
+                ReadUnmanagedSafe(out value, allocator);
+            }
+        }
+
+        /// <summary>
+        /// Read a struct NativeArray using a Temp allocator. Equivalent to ReadValueSafe(out value, Allocator.Temp)
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafeTemp<T>(out NativeArray<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.ReadWithAllocator(this, out value, Allocator.Temp);
+            }
+            else
+            {
+                ReadUnmanagedSafe(out value, Allocator.Temp);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read a struct NativeList
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafeInPlace<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeList<T>>.Serializer.Read(this, ref value);
+            }
+            else
+            {
+                ReadUnmanagedSafeInPlace(ref value);
+            }
+        }
+#endif
+
         /// <summary>
         /// Read a primitive value (int, bool, etc)
         /// Accepts any value that implements the given interfaces, but is not guaranteed to work correctly
@@ -880,7 +1108,7 @@ namespace Unity.Netcode
         public void ReadValueSafe<T>(out T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => ReadUnmanagedSafe(out value);
 
         /// <summary>
-        /// Read a primitive value (int, bool, etc)
+        /// Read a primitive value (int, bool, etc) array
         /// Accepts any value that implements the given interfaces, but is not guaranteed to work correctly
         /// on values that are not primitives.
         ///
@@ -936,6 +1164,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => ReadUnmanagedSafe(out value);
 
+
         /// <summary>
         /// Read a Vector2
         /// </summary>
@@ -1346,5 +1575,94 @@ namespace Unity.Netcode
             value.Length = length;
             ReadBytesSafe(value.GetUnsafePtr(), length);
         }
+
+        /// <summary>
+        /// Read a FixedString NativeArray.
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <param name="value">the value to read</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void ReadValueSafe<T>(out NativeArray<T> value, Allocator allocator)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            ReadUnmanagedSafe(out int length);
+            value = new NativeArray<T>(length, allocator);
+            var ptr = (T*)value.GetUnsafePtr();
+            for (var i = 0; i < length; ++i)
+            {
+                ReadValueSafeInPlace(ref ptr[i]);
+            }
+        }
+
+        /// <summary>
+        /// Read a FixedString NativeArray using a Temp allocator. Equivalent to ReadValueSafe(out value, Allocator.Temp)
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <param name="value">the value to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void ReadValueSafeTemp<T>(out NativeArray<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            ReadUnmanagedSafe(out int length);
+            value = new NativeArray<T>(length, Allocator.Temp);
+            var ptr = (T*)value.GetUnsafePtr();
+            for (var i = 0; i < length; ++i)
+            {
+                ReadValueSafeInPlace(ref ptr[i]);
+            }
+        }
+
+        /// <summary>
+        /// Read a FixedString NativeArray using a Temp allocator. Equivalent to ReadValueSafe(out value, Allocator.Temp)
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <param name="value">the value to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            ReadUnmanagedSafe(out int length);
+            value = new T[length];
+            for (var i = 0; i < length; ++i)
+            {
+                ReadValueSafeInPlace(ref value[i]);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read a FixedString NativeList.
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <param name="value">the value to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafeInPlace<T>(ref NativeList<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            ReadUnmanagedSafe(out int length);
+            value.Resize(length, NativeArrayOptions.UninitializedMemory);
+            for (var i = 0; i < length; ++i)
+            {
+                ReadValueSafeInPlace(ref value.ElementAt(i));
+            }
+        }
+#endif
     }
 }

Runtime/Serialization/FastBufferWriter.cs

@@ -452,6 +452,42 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Write a NativeArray of INetworkSerializables
+        /// </summary>
+        /// <param name="array">The value to write</param>
+        /// <param name="count"></param>
+        /// <param name="offset"></param>
+        /// <typeparam name="T"></typeparam>
+        public void WriteNetworkSerializable<T>(NativeArray<T> array, int count = -1, int offset = 0) where T : unmanaged, INetworkSerializable
+        {
+            int sizeInTs = count != -1 ? count : array.Length - offset;
+            WriteValueSafe(sizeInTs);
+            foreach (var item in array)
+            {
+                WriteNetworkSerializable(item);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Write a NativeList of INetworkSerializables
+        /// </summary>
+        /// <param name="array">The value to write</param>
+        /// <param name="count"></param>
+        /// <param name="offset"></param>
+        /// <typeparam name="T"></typeparam>
+        public void WriteNetworkSerializable<T>(NativeList<T> array, int count = -1, int offset = 0) where T : unmanaged, INetworkSerializable
+        {
+            int sizeInTs = count != -1 ? count : array.Length - offset;
+            WriteValueSafe(sizeInTs);
+            foreach (var item in array)
+            {
+                WriteNetworkSerializable(item);
+            }
+        }
+#endif
+
         /// <summary>
         /// Writes a string
         /// </summary>
@@ -536,6 +572,40 @@ namespace Unity.Netcode
             return sizeof(int) + sizeInBytes;
         }
 
+        /// <summary>
+        /// Get the required size to write a NativeArray
+        /// </summary>
+        /// <param name="array">The array to write</param>
+        /// <param name="count">The amount of elements to write</param>
+        /// <param name="offset">Where in the array to start</param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int GetWriteSize<T>(NativeArray<T> array, int count = -1, int offset = 0) where T : unmanaged
+        {
+            int sizeInTs = count != -1 ? count : array.Length - offset;
+            int sizeInBytes = sizeInTs * sizeof(T);
+            return sizeof(int) + sizeInBytes;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Get the required size to write a NativeList
+        /// </summary>
+        /// <param name="array">The array to write</param>
+        /// <param name="count">The amount of elements to write</param>
+        /// <param name="offset">Where in the array to start</param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int GetWriteSize<T>(NativeList<T> array, int count = -1, int offset = 0) where T : unmanaged
+        {
+            int sizeInTs = count != -1 ? count : array.Length - offset;
+            int sizeInBytes = sizeInTs * sizeof(T);
+            return sizeof(int) + sizeInBytes;
+        }
+#endif
+
         /// <summary>
         /// Write a partial value. The specified number of bytes is written from the value and the rest is ignored.
         /// </summary>
@@ -680,6 +750,32 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Write multiple bytes to the stream
+        /// </summary>
+        /// <param name="value">Value to write</param>
+        /// <param name="size">Number of bytes to write</param>
+        /// <param name="offset">Offset into the buffer to begin writing</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void WriteBytes(NativeArray<byte> value, int size = -1, int offset = 0)
+        {
+            byte* ptr = (byte*)value.GetUnsafePtr();
+            WriteBytes(ptr, size == -1 ? value.Length : size, offset);
+        }
+
+        /// <summary>
+        /// Write multiple bytes to the stream
+        /// </summary>
+        /// <param name="value">Value to write</param>
+        /// <param name="size">Number of bytes to write</param>
+        /// <param name="offset">Offset into the buffer to begin writing</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void WriteBytes(NativeList<byte> value, int size = -1, int offset = 0)
+        {
+            byte* ptr = (byte*)value.GetUnsafePtr();
+            WriteBytes(ptr, size == -1 ? value.Length : size, offset);
+        }
+
         /// <summary>
         /// Write multiple bytes to the stream
         ///
@@ -698,6 +794,32 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Write multiple bytes to the stream
+        /// </summary>
+        /// <param name="value">Value to write</param>
+        /// <param name="size">Number of bytes to write</param>
+        /// <param name="offset">Offset into the buffer to begin writing</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void WriteBytesSafe(NativeArray<byte> value, int size = -1, int offset = 0)
+        {
+            byte* ptr = (byte*)value.GetUnsafePtr();
+            WriteBytesSafe(ptr, size == -1 ? value.Length : size, offset);
+        }
+
+        /// <summary>
+        /// Write multiple bytes to the stream
+        /// </summary>
+        /// <param name="value">Value to write</param>
+        /// <param name="size">Number of bytes to write</param>
+        /// <param name="offset">Offset into the buffer to begin writing</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void WriteBytesSafe(NativeList<byte> value, int size = -1, int offset = 0)
+        {
+            byte* ptr = (byte*)value.GetUnsafePtr();
+            WriteBytesSafe(ptr, size == -1 ? value.Length : size, offset);
+        }
+
         /// <summary>
         /// Copy the contents of this writer into another writer.
         /// The contents will be copied from the beginning of this writer to its current position.
@@ -749,6 +871,44 @@ namespace Unity.Netcode
             return value.Length + sizeof(int);
         }
 
+        /// <summary>
+        /// Get the write size for an array of FixedStrings
+        /// </summary>
+        /// <param name="value"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public static int GetWriteSize<T>(in NativeArray<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            var size = sizeof(int);
+            foreach (var item in value)
+            {
+                size += sizeof(int) + item.Length;
+            }
+
+            return size;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Get the write size for an array of FixedStrings
+        /// </summary>
+        /// <param name="value"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public static int GetWriteSize<T>(in NativeList<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            var size = sizeof(int);
+            foreach (var item in value)
+            {
+                size += sizeof(int) + item.Length;
+            }
+
+            return size;
+        }
+#endif
+
         /// <summary>
         /// Get the size required to write an unmanaged value of type T
         /// </summary>
@@ -799,6 +959,50 @@ namespace Unity.Netcode
             }
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void WriteUnmanaged<T>(NativeArray<T> value) where T : unmanaged
+        {
+            WriteUnmanaged(value.Length);
+            var ptr = (T*)value.GetUnsafePtr();
+            {
+                byte* bytes = (byte*)ptr;
+                WriteBytes(bytes, sizeof(T) * value.Length);
+            }
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void WriteUnmanagedSafe<T>(NativeArray<T> value) where T : unmanaged
+        {
+            WriteUnmanagedSafe(value.Length);
+            var ptr = (T*)value.GetUnsafePtr();
+            {
+                byte* bytes = (byte*)ptr;
+                WriteBytesSafe(bytes, sizeof(T) * value.Length);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void WriteUnmanaged<T>(NativeList<T> value) where T : unmanaged
+        {
+            WriteUnmanaged(value.Length);
+            var ptr = (T*)value.GetUnsafePtr();
+            {
+                byte* bytes = (byte*)ptr;
+                WriteBytes(bytes, sizeof(T) * value.Length);
+            }
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void WriteUnmanagedSafe<T>(NativeList<T> value) where T : unmanaged
+        {
+            WriteUnmanagedSafe(value.Length);
+            var ptr = (T*)value.GetUnsafePtr();
+            {
+                byte* bytes = (byte*)ptr;
+                WriteBytesSafe(bytes, sizeof(T) * value.Length);
+            }
+        }
+#endif
+
         /// <summary>
         /// This empty struct exists to allow overloading WriteValue based on generic constraints.
         /// At the bytecode level, constraints aren't included in the method signature, so if multiple
@@ -869,6 +1073,20 @@ namespace Unity.Netcode
 
         }
 
+        /// <summary>
+        /// This empty struct exists to allow overloading WriteValue based on generic constraints.
+        /// At the bytecode level, constraints aren't included in the method signature, so if multiple
+        /// methods exist with the same signature, it causes a compile error because they would end up
+        /// being emitted as the same method, even if the constraints are different.
+        /// Adding an empty struct with a default value gives them different signatures in the bytecode,
+        /// which then allows the compiler to do overload resolution based on the generic constraints
+        /// without the user having to pass the struct in themselves.
+        /// </summary>
+        public struct ForGeneric
+        {
+
+        }
+
         /// <summary>
         /// Write a NetworkSerializable value
         /// </summary>
@@ -929,6 +1147,50 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteValue<T>(T[] value, ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => WriteUnmanaged(value);
 
+        /// <summary>
+        /// Write a struct NativeArray
+        /// </summary>
+        /// <param name="value">The values to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(NativeArray<T> value, ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.Write(this, ref value);
+            }
+            else
+            {
+                WriteUnmanaged(value);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Write a struct NativeList
+        /// </summary>
+        /// <param name="value">The values to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(NativeList<T> value, ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeList<T>>.Serializer.Write(this, ref value);
+            }
+            else
+            {
+                WriteUnmanaged(value);
+            }
+        }
+#endif
+
         /// <summary>
         /// Write a struct
         ///
@@ -953,6 +1215,56 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteValueSafe<T>(T[] value, ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => WriteUnmanagedSafe(value);
 
+        /// <summary>
+        /// Write a struct NativeArray
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple writes at once by calling TryBeginWrite.
+        /// </summary>
+        /// <param name="value">The values to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(NativeArray<T> value, ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.Write(this, ref value);
+            }
+            else
+            {
+                WriteUnmanagedSafe(value);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Write a struct NativeList
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple writes at once by calling TryBeginWrite.
+        /// </summary>
+        /// <param name="value">The values to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(NativeList<T> value, ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeList<T>>.Serializer.Write(this, ref value);
+            }
+            else
+            {
+                WriteUnmanagedSafe(value);
+            }
+        }
+#endif
+
         /// <summary>
         /// Write a primitive value (int, bool, etc)
         /// Accepts any value that implements the given interfaces, but is not guaranteed to work correctly
@@ -1185,7 +1497,6 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteValue(Ray2D[] value) => WriteUnmanaged(value);
 
-
         /// <summary>
         /// Write a Vector2
         ///
@@ -1415,6 +1726,65 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Write an array of FixedString values. Writes only the part of each string that's actually used.
+        /// When calling TryBeginWrite, ensure you calculate the write size correctly (preferably by calling
+        /// FastBufferWriter.GetWriteSize())
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(T[] value, ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+
+        /// <summary>
+        /// Write a NativeArray of FixedString values. Writes only the part of each string that's actually used.
+        /// When calling TryBeginWrite, ensure you calculate the write size correctly (preferably by calling
+        /// FastBufferWriter.GetWriteSize())
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(in NativeArray<T> value, ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Write a NativeList of FixedString values. Writes only the part of each string that's actually used.
+        /// When calling TryBeginWrite, ensure you calculate the write size correctly (preferably by calling
+        /// FastBufferWriter.GetWriteSize())
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(in NativeList<T> value, ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+#endif
+
 
         /// <summary>
         /// Write a FixedString value. Writes only the part of the string that's actually used.
@@ -1435,5 +1805,76 @@ namespace Unity.Netcode
             }
             WriteValue(value);
         }
+
+        /// <summary>
+        /// Write a NativeArray of FixedString values. Writes only the part of each string that's actually used.
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple writes at once by calling TryBeginWrite.
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(T[] value, ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            if (!TryBeginWriteInternal(GetWriteSize(value)))
+            {
+                throw new OverflowException("Writing past the end of the buffer");
+            }
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+
+        /// <summary>
+        /// Write a NativeArray of FixedString values. Writes only the part of each string that's actually used.
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple writes at once by calling TryBeginWrite.
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(in NativeArray<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            if (!TryBeginWriteInternal(GetWriteSize(value)))
+            {
+                throw new OverflowException("Writing past the end of the buffer");
+            }
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Write a NativeList of FixedString values. Writes only the part of each string that's actually used.
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple writes at once by calling TryBeginWrite.
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(in NativeList<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            if (!TryBeginWriteInternal(GetWriteSize(value)))
+            {
+                throw new OverflowException("Writing past the end of the buffer");
+            }
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+#endif
     }
 }

Runtime/Serialization/IReaderWriter.cs

@@ -96,6 +96,25 @@ namespace Unity.Netcode
         /// <typeparam name="T">The type being serialized</typeparam>
         void SerializeValue<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy;
 
+        /// <summary>
+        /// Read or write a NativeArray of struct values implementing ISerializeByMemcpy
+        /// </summary>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged;
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read or write a NativeList of struct values implementing ISerializeByMemcpy
+        /// </summary>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        void SerializeValue<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged;
+#endif
+
         /// <summary>
         /// Read or write a struct or class value implementing INetworkSerializable
         /// </summary>
@@ -121,6 +140,27 @@ namespace Unity.Netcode
         void SerializeValue<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes;
 
+        /// <summary>
+        /// Read or write NativeArray of FixedString values
+        /// </summary>
+        /// <param name="value">The value to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes;
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read or write a NativeList of FixedString values
+        /// </summary>
+        /// <param name="value">The value to read/write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        void SerializeValue<T>(ref NativeList<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes;
+#endif
+
         /// <summary>
         /// Read or write a Vector2 value
         /// </summary>
@@ -344,6 +384,31 @@ namespace Unity.Netcode
         /// <param name="unused">An unused parameter that can be used for enabling overload resolution based on generic constraints</param>
         void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy;
 
+        /// <summary>
+        /// Serialize a NativeArray of structs, "pre-checked", which skips buffer checks.
+        /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
+        /// calling this. In release builds, calling this without calling "PreCheck" may read or write
+        /// past the end of the buffer, which will cause memory corruption and undefined behavior.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter that can be used for enabling overload resolution based on generic constraints</param>
+        void SerializeValuePreChecked<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged;
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Serialize a NativeList of structs, "pre-checked", which skips buffer checks.
+        /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
+        /// calling this. In release builds, calling this without calling "PreCheck" may read or write
+        /// past the end of the buffer, which will cause memory corruption and undefined behavior.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="unused">An unused parameter that can be used for enabling overload resolution based on generic constraints</param>
+        void SerializeValuePreChecked<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged;
+#endif
+
         /// <summary>
         /// Serialize a FixedString, "pre-checked", which skips buffer checks.
         /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
@@ -438,7 +503,7 @@ namespace Unity.Netcode
         void SerializeValuePreChecked(ref Vector4 value);
 
         /// <summary>
-        /// Serialize a Vector4Array, "pre-checked", which skips buffer checks.
+        /// Serialize a Vector4 array, "pre-checked", which skips buffer checks.
         /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
         /// calling this. In release builds, calling this without calling "PreCheck" may read or write
         /// past the end of the buffer, which will cause memory corruption and undefined behavior.

Runtime/Spawning/NetworkPrefabHandler.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using UnityEngine;
 
@@ -49,6 +50,8 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkPrefabHandler
     {
+        private NetworkManager m_NetworkManager;
+
         /// <summary>
         /// Links a network prefab asset to a class with the INetworkPrefabInstanceHandler interface
         /// </summary>
@@ -60,6 +63,8 @@ namespace Unity.Netcode
         /// </summary>
         private readonly Dictionary<uint, uint> m_PrefabInstanceToPrefabAsset = new Dictionary<uint, uint>();
 
+        internal static string PrefabDebugHelper(NetworkPrefab networkPrefab) => $"{nameof(NetworkPrefab)} \"{networkPrefab.Prefab.name}\"";
+
         /// <summary>
         /// Use a <see cref="GameObject"/> to register a class that implements the <see cref="INetworkPrefabInstanceHandler"/> interface with the <see cref="NetworkPrefabHandler"/>
         /// </summary>
@@ -132,23 +137,23 @@ namespace Unity.Netcode
                             }
                             else
                             {
-                                throw new System.Exception($"{targetNetworkObject.name} does not have a {nameof(NetworkObject)} component!");
+                                throw new Exception($"{targetNetworkObject.name} does not have a {nameof(NetworkObject)} component!");
                             }
                         }
                     }
                     else
                     {
-                        throw new System.Exception($"{sourceNetworkPrefab.name} does not have a {nameof(NetworkObject)} component!");
+                        throw new Exception($"{sourceNetworkPrefab.name} does not have a {nameof(NetworkObject)} component!");
                     }
                 }
                 else
                 {
-                    throw new System.Exception($"You should only call {nameof(RegisterHostGlobalObjectIdHashValues)} as a Host!");
+                    throw new Exception($"You should only call {nameof(RegisterHostGlobalObjectIdHashValues)} as a Host!");
                 }
             }
             else
             {
-                throw new System.Exception($"You can only call {nameof(RegisterHostGlobalObjectIdHashValues)} once NetworkManager is listening!");
+                throw new Exception($"You can only call {nameof(RegisterHostGlobalObjectIdHashValues)} once NetworkManager is listening!");
             }
         }
 
@@ -190,6 +195,7 @@ namespace Unity.Netcode
                         break;
                     }
                 }
+
                 m_PrefabInstanceToPrefabAsset.Remove(networkPrefabHashKey);
             }
 
@@ -201,30 +207,21 @@ namespace Unity.Netcode
         /// </summary>
         /// <param name="networkPrefab"></param>
         /// <returns>true or false</returns>
-        internal bool ContainsHandler(GameObject networkPrefab)
-        {
-            return ContainsHandler(networkPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash);
-        }
+        internal bool ContainsHandler(GameObject networkPrefab) => ContainsHandler(networkPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash);
 
         /// <summary>
         /// Check to see if a <see cref="NetworkObject"/> is registered to an <see cref="INetworkPrefabInstanceHandler"/> implementation
         /// </summary>
         /// <param name="networkObject"></param>
         /// <returns>true or false</returns>
-        internal bool ContainsHandler(NetworkObject networkObject)
-        {
-            return ContainsHandler(networkObject.GlobalObjectIdHash);
-        }
+        internal bool ContainsHandler(NetworkObject networkObject) => ContainsHandler(networkObject.GlobalObjectIdHash);
 
         /// <summary>
         /// Check to see if a <see cref="NetworkObject.GlobalObjectIdHash"/> is registered to an <see cref="INetworkPrefabInstanceHandler"/> implementation
         /// </summary>
         /// <param name="networkPrefabHash"></param>
         /// <returns>true or false</returns>
-        internal bool ContainsHandler(uint networkPrefabHash)
-        {
-            return m_PrefabAssetToPrefabHandler.ContainsKey(networkPrefabHash) || m_PrefabInstanceToPrefabAsset.ContainsKey(networkPrefabHash);
-        }
+        internal bool ContainsHandler(uint networkPrefabHash) => m_PrefabAssetToPrefabHandler.ContainsKey(networkPrefabHash) || m_PrefabInstanceToPrefabAsset.ContainsKey(networkPrefabHash);
 
         /// <summary>
         /// Returns the source NetworkPrefab's <see cref="NetworkObject.GlobalObjectIdHash"/>
@@ -237,9 +234,10 @@ namespace Unity.Netcode
             {
                 return networkPrefabHash;
             }
-            else if (m_PrefabInstanceToPrefabAsset.ContainsKey(networkPrefabHash))
+
+            if (m_PrefabInstanceToPrefabAsset.TryGetValue(networkPrefabHash, out var hash))
             {
-                return m_PrefabInstanceToPrefabAsset[networkPrefabHash];
+                return hash;
             }
 
             return 0;
@@ -256,9 +254,9 @@ namespace Unity.Netcode
         /// <returns></returns>
         internal NetworkObject HandleNetworkPrefabSpawn(uint networkPrefabAssetHash, ulong ownerClientId, Vector3 position, Quaternion rotation)
         {
-            if (m_PrefabAssetToPrefabHandler.ContainsKey(networkPrefabAssetHash))
+            if (m_PrefabAssetToPrefabHandler.TryGetValue(networkPrefabAssetHash, out var prefabInstanceHandler))
             {
-                var networkObjectInstance = m_PrefabAssetToPrefabHandler[networkPrefabAssetHash].Instantiate(ownerClientId, position, rotation);
+                var networkObjectInstance = prefabInstanceHandler.Instantiate(ownerClientId, position, rotation);
 
                 //Now we must make sure this alternate PrefabAsset spawned in place of the prefab asset with the networkPrefabAssetHash (GlobalObjectIdHash)
                 //is registered and linked to the networkPrefabAssetHash so during the HandleNetworkPrefabDestroy process we can identify the alternate prefab asset.
@@ -282,19 +280,146 @@ namespace Unity.Netcode
             var networkObjectInstanceHash = networkObjectInstance.GlobalObjectIdHash;
 
             // Do we have custom overrides registered?
-            if (m_PrefabInstanceToPrefabAsset.ContainsKey(networkObjectInstanceHash))
+            if (m_PrefabInstanceToPrefabAsset.TryGetValue(networkObjectInstanceHash, out var networkPrefabAssetHash))
             {
-                var networkPrefabAssetHash = m_PrefabInstanceToPrefabAsset[networkObjectInstanceHash];
-                if (m_PrefabAssetToPrefabHandler.ContainsKey(networkPrefabAssetHash))
+                if (m_PrefabAssetToPrefabHandler.TryGetValue(networkPrefabAssetHash, out var prefabInstanceHandler))
                 {
-                    m_PrefabAssetToPrefabHandler[networkPrefabAssetHash].Destroy(networkObjectInstance);
+                    prefabInstanceHandler.Destroy(networkObjectInstance);
                 }
             }
             else // Otherwise the NetworkObject is the source NetworkPrefab
-            if (m_PrefabAssetToPrefabHandler.ContainsKey(networkObjectInstanceHash))
+            if (m_PrefabAssetToPrefabHandler.TryGetValue(networkObjectInstanceHash, out var prefabInstanceHandler))
             {
-                m_PrefabAssetToPrefabHandler[networkObjectInstanceHash].Destroy(networkObjectInstance);
+                prefabInstanceHandler.Destroy(networkObjectInstance);
             }
         }
+
+        /// <summary>
+        /// Returns the <see cref="GameObject"/> to use as the override as could be defined within the NetworkPrefab list
+        /// Note: This should be used to create <see cref="GameObject"/> pools (with <see cref="NetworkObject"/> components)
+        /// under the scenario where you are using the Host model as it spawns everything locally. As such, the override
+        /// will not be applied when spawning locally on a Host.
+        /// Related Classes and Interfaces:
+        /// <see cref="INetworkPrefabInstanceHandler"/>
+        /// </summary>
+        /// <param name="gameObject">the <see cref="GameObject"/> to be checked for a <see cref="NetworkManager"/> defined NetworkPrefab override</param>
+        /// <returns>a <see cref="GameObject"/> that is either the override or if no overrides exist it returns the same as the one passed in as a parameter</returns>
+        public GameObject GetNetworkPrefabOverride(GameObject gameObject)
+        {
+            if (gameObject.TryGetComponent<NetworkObject>(out var networkObject))
+            {
+                if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(networkObject.GlobalObjectIdHash))
+                {
+                    switch (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].Override)
+                    {
+                        case NetworkPrefabOverride.Hash:
+                        case NetworkPrefabOverride.Prefab:
+                            {
+                                return m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].OverridingTargetPrefab;
+                            }
+                    }
+                }
+            }
+
+            return gameObject;
+        }
+
+        /// <summary>
+        /// Adds a new prefab to the network prefab list.
+        /// This can be any GameObject with a NetworkObject component, from any source (addressables, asset
+        /// bundles, Resource.Load, dynamically created, etc)
+        ///
+        /// There are three limitations to this method:
+        /// - If you have NetworkConfig.ForceSamePrefabs enabled, you can only do this before starting
+        /// networking, and the server and all connected clients must all have the same exact set of prefabs
+        /// added via this method before connecting
+        /// - Adding a prefab on the server does not automatically add it on the client - it's up to you
+        /// to make sure the client and server are synchronized via whatever method makes sense for your game
+        /// (RPCs, configurations, deterministic loading, etc)
+        /// - If the server sends a Spawn message to a client that has not yet added a prefab for, the spawn message
+        /// and any other relevant messages will be held for a configurable time (default 1 second, configured via
+        /// NetworkConfig.SpawnTimeout) before an error is logged. This is intended to enable the SDK to gracefully
+        /// handle unexpected conditions (slow disks, slow network, etc) that slow down asset loading. This timeout
+        /// should not be relied on and code shouldn't be written around it - your code should be written so that
+        /// the asset is expected to be loaded before it's needed.
+        /// </summary>
+        /// <param name="prefab"></param>
+        /// <exception cref="Exception"></exception>
+        public void AddNetworkPrefab(GameObject prefab)
+        {
+            if (m_NetworkManager.IsListening && m_NetworkManager.NetworkConfig.ForceSamePrefabs)
+            {
+                throw new Exception($"All prefabs must be registered before starting {nameof(NetworkManager)} when {nameof(NetworkConfig.ForceSamePrefabs)} is enabled.");
+            }
+
+            var networkObject = prefab.GetComponent<NetworkObject>();
+            if (!networkObject)
+            {
+                throw new Exception($"All {nameof(NetworkPrefab)}s must contain a {nameof(NetworkObject)} component.");
+            }
+
+            var networkPrefab = new NetworkPrefab { Prefab = prefab };
+            bool added = m_NetworkManager.NetworkConfig.Prefabs.Add(networkPrefab);
+            if (m_NetworkManager.IsListening && added)
+            {
+                m_NetworkManager.DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, networkObject.GlobalObjectIdHash);
+            }
+        }
+
+        /// <summary>
+        /// Remove a prefab from the prefab list.
+        /// As with AddNetworkPrefab, this is specific to the client it's called on -
+        /// calling it on the server does not automatically remove anything on any of the
+        /// client processes.
+        ///
+        /// Like AddNetworkPrefab, when NetworkConfig.ForceSamePrefabs is enabled,
+        /// this cannot be called after connecting.
+        /// </summary>
+        /// <param name="prefab"></param>
+        public void RemoveNetworkPrefab(GameObject prefab)
+        {
+            if (m_NetworkManager.IsListening && m_NetworkManager.NetworkConfig.ForceSamePrefabs)
+            {
+                throw new Exception($"Prefabs cannot be removed after starting {nameof(NetworkManager)} when {nameof(NetworkConfig.ForceSamePrefabs)} is enabled.");
+            }
+
+            var globalObjectIdHash = prefab.GetComponent<NetworkObject>().GlobalObjectIdHash;
+            m_NetworkManager.NetworkConfig.Prefabs.Remove(prefab);
+            if (ContainsHandler(globalObjectIdHash))
+            {
+                RemoveHandler(globalObjectIdHash);
+            }
+        }
+
+        /// <summary>
+        /// If one exists, registers the player prefab
+        /// </summary>
+        internal void RegisterPlayerPrefab()
+        {
+            var networkConfig = m_NetworkManager.NetworkConfig;
+            // If we have a player prefab, then we need to verify it is in the list of NetworkPrefabOverrideLinks for client side spawning.
+            if (networkConfig.PlayerPrefab != null)
+            {
+                if (networkConfig.PlayerPrefab.TryGetComponent<NetworkObject>(out var playerPrefabNetworkObject))
+                {
+                    //In the event there is no NetworkPrefab entry (i.e. no override for default player prefab)
+                    if (!networkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(playerPrefabNetworkObject.GlobalObjectIdHash))
+                    {
+                        //Then add a new entry for the player prefab
+                        AddNetworkPrefab(networkConfig.PlayerPrefab);
+                    }
+                }
+                else
+                {
+                    // Provide the name of the prefab with issues so the user can more easily find the prefab and fix it
+                    Debug.LogError($"{nameof(NetworkConfig.PlayerPrefab)} (\"{networkConfig.PlayerPrefab.name}\") has no NetworkObject assigned to it!.");
+                }
+            }
+        }
+
+        internal void Initialize(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+        }
     }
 }

Runtime/Spawning/NetworkSpawnManager.cs

@@ -10,6 +10,9 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkSpawnManager
     {
+        // Stores the objects that need to be shown at end-of-frame
+        internal Dictionary<ulong, List<NetworkObject>> ObjectsToShowToClient = new Dictionary<ulong, List<NetworkObject>>();
+
         /// <summary>
         /// The currently spawned objects
         /// </summary>
@@ -37,6 +40,41 @@ namespace Unity.Netcode
         /// </summary>
         private Dictionary<ulong, ulong> m_ObjectToOwnershipTable = new Dictionary<ulong, ulong>();
 
+        internal void MarkObjectForShowingTo(NetworkObject networkObject, ulong clientId)
+        {
+            if (!ObjectsToShowToClient.ContainsKey(clientId))
+            {
+                ObjectsToShowToClient.Add(clientId, new List<NetworkObject>());
+            }
+            ObjectsToShowToClient[clientId].Add(networkObject);
+        }
+
+        // returns whether any matching objects would have become visible and were returned to hidden state
+        internal bool RemoveObjectFromShowingTo(NetworkObject networkObject, ulong clientId)
+        {
+            var ret = false;
+            if (!ObjectsToShowToClient.ContainsKey(clientId))
+            {
+                return false;
+            }
+
+            // probably overkill, but deals with multiple entries
+            while (ObjectsToShowToClient[clientId].Contains(networkObject))
+            {
+                Debug.LogWarning(
+                    "Object was shown and hidden from the same client in the same Network frame. As a result, the client will _not_ receive a NetworkSpawn");
+                ObjectsToShowToClient[clientId].Remove(networkObject);
+                ret = true;
+            }
+
+            if (ret)
+            {
+                networkObject.Observers.Remove(clientId);
+            }
+
+            return ret;
+        }
+
         /// <summary>
         /// Used to update a NetworkObject's ownership
         /// </summary>
@@ -141,11 +179,6 @@ namespace Unity.Netcode
         /// </summary>
         public NetworkManager NetworkManager { get; }
 
-        internal NetworkSpawnManager(NetworkManager networkManager)
-        {
-            NetworkManager = networkManager;
-        }
-
         internal readonly Queue<ReleasedNetworkId> ReleasedNetworkObjectIds = new Queue<ReleasedNetworkId>();
         private ulong m_NetworkObjectIdCounter;
 
@@ -223,7 +256,7 @@ namespace Unity.Netcode
                 NetworkObjectId = networkObject.NetworkObjectId,
                 OwnerClientId = networkObject.OwnerClientId
             };
-            var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, NetworkManager.ConnectedClientsIds);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, NetworkManager.ConnectedClientsIds);
 
             foreach (var client in NetworkManager.ConnectedClients)
             {
@@ -286,7 +319,7 @@ namespace Unity.Netcode
             {
                 if (networkObject.IsNetworkVisibleTo(client.Value.ClientId))
                 {
-                    var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, client.Value.ClientId);
+                    var size = NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, client.Value.ClientId);
                     NetworkManager.NetworkMetrics.TrackOwnershipChangeSent(client.Key, networkObject, size);
                 }
             }
@@ -584,8 +617,10 @@ namespace Unity.Netcode
                 }
             }
 
-            if (NetworkManager.IsServer)
+            // If we are the server and should spawn with observers
+            if (NetworkManager.IsServer && networkObject.SpawnWithObservers)
             {
+                // Add client observers
                 for (int i = 0; i < NetworkManager.ConnectedClientsList.Count; i++)
                 {
                     if (networkObject.CheckObjectVisibility == null || networkObject.CheckObjectVisibility(NetworkManager.ConnectedClientsList[i].ClientId))
@@ -600,7 +635,7 @@ namespace Unity.Netcode
 
             networkObject.InvokeBehaviourNetworkSpawn();
 
-            NetworkManager.DeferredMessageManager.ProcessTriggers(IDeferredMessageManager.TriggerType.OnSpawn, networkId);
+            NetworkManager.DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnSpawn, networkId);
 
             // propagate the IsSceneObject setting to child NetworkObjects
             var children = networkObject.GetComponentsInChildren<NetworkObject>();
@@ -633,7 +668,7 @@ namespace Unity.Netcode
             {
                 ObjectInfo = networkObject.GetMessageSceneObject(clientId)
             };
-            var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, clientId);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, clientId);
             NetworkManager.NetworkMetrics.TrackObjectSpawnSent(clientId, networkObject, size);
         }
 
@@ -883,7 +918,7 @@ namespace Unity.Netcode
                             NetworkObjectId = networkObject.NetworkObjectId,
                             DestroyGameObject = networkObject.IsSceneObject != false ? destroyGameObject : true
                         };
-                        var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, m_TargetClientIds);
+                        var size = NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, m_TargetClientIds);
                         foreach (var targetClientId in m_TargetClientIds)
                         {
                             NetworkManager.NetworkMetrics.TrackObjectDestroySent(targetClientId, networkObject, size);
@@ -944,5 +979,27 @@ namespace Unity.Netcode
                 }
             }
         }
+
+        /// <summary>
+        /// See <see cref="NetworkBehaviourUpdater.NetworkBehaviourUpdater_Tick"/>
+        /// </summary>
+        internal void HandleNetworkObjectShow()
+        {
+            // Handle NetworkObjects to show
+            foreach (var client in ObjectsToShowToClient)
+            {
+                ulong clientId = client.Key;
+                foreach (var networkObject in client.Value)
+                {
+                    SendSpawnCallForObject(clientId, networkObject);
+                }
+            }
+            ObjectsToShowToClient.Clear();
+        }
+
+        internal NetworkSpawnManager(NetworkManager networkManager)
+        {
+            NetworkManager = networkManager;
+        }
     }
 }

Runtime/Timing/NetworkTickSystem.cs

@@ -50,7 +50,7 @@ namespace Unity.Netcode
         {
             if (tickRate == 0)
             {
-                throw new ArgumentException("Tickrate must be a positive value.", nameof(tickRate));
+                throw new ArgumentException("Tick rate must be a positive value.", nameof(tickRate));
             }
 
             TickRate = tickRate;

Runtime/Timing/NetworkTimeSystem.cs

@@ -1,4 +1,5 @@
 using System;
+using Unity.Profiling;
 
 namespace Unity.Netcode
 {
@@ -8,6 +9,34 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkTimeSystem
     {
+        /// <summary>
+        /// TODO 2023-Q2: Not sure if this just needs to go away, but there is nothing that ever replaces this
+        /// </summary>
+        /// <remarks>
+        /// This was the original comment when it lived in NetworkManager:
+        /// todo talk with UX/Product, find good default value for this
+        /// </remarks>
+        private const float k_DefaultBufferSizeSec = 0.05f;
+
+        /// <summary>
+        /// Time synchronization frequency defaults to 1 synchronization message per second
+        /// </summary>
+        private const double k_TimeSyncFrequency = 1.0d;
+
+        /// <summary>
+        /// The threshold, in seconds, used to force a hard catchup of network time
+        /// </summary>
+        private const double k_HardResetThresholdSeconds = 0.2d;
+
+        /// <summary>
+        /// Default adjustment ratio
+        /// </summary>
+        private const double k_DefaultAdjustmentRatio = 0.01d;
+
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+        private static ProfilerMarker s_SyncTime = new ProfilerMarker($"{nameof(NetworkManager)}.SyncTime");
+#endif
+
         private double m_TimeSec;
         private double m_CurrentLocalTimeOffset;
         private double m_DesiredLocalTimeOffset;
@@ -50,6 +79,16 @@ namespace Unity.Netcode
         internal double LastSyncedServerTimeSec { get; private set; }
         internal double LastSyncedRttSec { get; private set; }
 
+        private NetworkConnectionManager m_ConnectionManager;
+        private NetworkTransport m_NetworkTransport;
+        private NetworkTickSystem m_NetworkTickSystem;
+        private NetworkManager m_NetworkManager;
+
+        /// <summary>
+        /// <see cref="k_TimeSyncFrequency"/>
+        /// </summary>
+        private int m_TimeSyncFrequencyTicks;
+
         /// <summary>
         /// The constructor class for <see cref="NetworkTickSystem"/>
         /// </summary>
@@ -57,7 +96,7 @@ namespace Unity.Netcode
         /// <param name="serverBufferSec">The amount of the time in seconds the client should buffer incoming messages from the server.</param>
         /// <param name="hardResetThresholdSec">The threshold, in seconds, used to force a hard catchup of network time.</param>
         /// <param name="adjustmentRatio">The ratio at which the NetworkTimeSystem speeds up or slows down time.</param>
-        public NetworkTimeSystem(double localBufferSec, double serverBufferSec, double hardResetThresholdSec, double adjustmentRatio = 0.01d)
+        public NetworkTimeSystem(double localBufferSec, double serverBufferSec = k_DefaultBufferSizeSec, double hardResetThresholdSec = k_HardResetThresholdSeconds, double adjustmentRatio = k_DefaultAdjustmentRatio)
         {
             LocalBufferSec = localBufferSec;
             ServerBufferSec = serverBufferSec;
@@ -65,6 +104,89 @@ namespace Unity.Netcode
             AdjustmentRatio = adjustmentRatio;
         }
 
+        /// <summary>
+        /// The primary time system is initialized when a server-host or client is started
+        /// </summary>
+        internal NetworkTickSystem Initialize(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+            m_ConnectionManager = networkManager.ConnectionManager;
+            m_NetworkTransport = networkManager.NetworkConfig.NetworkTransport;
+            m_TimeSyncFrequencyTicks = (int)(k_TimeSyncFrequency * networkManager.NetworkConfig.TickRate);
+            m_NetworkTickSystem = new NetworkTickSystem(networkManager.NetworkConfig.TickRate, 0, 0);
+            // Only the server side needs to register for tick based time synchronization
+            if (m_ConnectionManager.LocalClient.IsServer)
+            {
+                m_NetworkTickSystem.Tick += OnTickSyncTime;
+            }
+
+            return m_NetworkTickSystem;
+        }
+
+        internal void UpdateTime()
+        {
+            // As a client wait to run the time system until we are connected.
+            // As a client or server don't worry about the time system if we are no longer processing messages
+            if (!m_ConnectionManager.LocalClient.IsServer && !m_ConnectionManager.LocalClient.IsConnected)
+            {
+                return;
+            }
+
+            // Only update RTT here, server time is updated by time sync messages
+            var reset = Advance(m_NetworkManager.RealTimeProvider.UnscaledDeltaTime);
+            if (reset)
+            {
+                m_NetworkTickSystem.Reset(LocalTime, ServerTime);
+            }
+
+            m_NetworkTickSystem.UpdateTick(LocalTime, ServerTime);
+
+            if (!m_ConnectionManager.LocalClient.IsServer)
+            {
+                Sync(LastSyncedServerTimeSec + m_NetworkManager.RealTimeProvider.UnscaledDeltaTime, m_NetworkTransport.GetCurrentRtt(NetworkManager.ServerClientId) / 1000d);
+            }
+        }
+
+        /// <summary>
+        /// Server-Side:
+        /// Synchronizes time with clients based on the given <see cref="m_TimeSyncFrequencyTicks"/>.
+        /// Also: <see cref="k_TimeSyncFrequency"/>
+        /// </summary>
+        /// <remarks>
+        /// The default is to send 1 time synchronization message per second
+        /// </remarks>
+        private void OnTickSyncTime()
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            s_SyncTime.Begin();
+#endif
+
+            // Check if we need to send a time synchronization message, and if so send it
+            if (m_ConnectionManager.LocalClient.IsServer && m_NetworkTickSystem.ServerTime.Tick % m_TimeSyncFrequencyTicks == 0)
+            {
+                var message = new TimeSyncMessage
+                {
+                    Tick = m_NetworkTickSystem.ServerTime.Tick
+                };
+                m_ConnectionManager.SendMessage(ref message, NetworkDelivery.Unreliable, m_ConnectionManager.ConnectedClientIds);
+            }
+
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            s_SyncTime.End();
+#endif
+        }
+
+        /// <summary>
+        /// Invoke when shutting down the NetworkManager
+        /// </summary>
+        internal void Shutdown()
+        {
+            if (m_ConnectionManager.LocalClient.IsServer)
+            {
+                m_NetworkTickSystem.Tick -= OnTickSyncTime;
+            }
+        }
+
         /// <summary>
         /// Creates a new instance of the <see cref="NetworkTimeSystem"/> class for a server instance.
         /// The server will not apply any buffer values which ensures that local time equals server time.

Runtime/Transports/UTP/UnityTransport.cs

@@ -524,7 +524,7 @@ namespace Unity.Netcode.Transports.UTP
                 //reflection, but this does not live in the context of a performance-critical loop, it runs once at initial connection time.
                 if (m_RelayServerData.Equals(default(RelayServerData)))
                 {
-                    Debug.LogError("You must call SetRelayServerData() at least once before calling StartRelayServer.");
+                    Debug.LogError("You must call SetRelayServerData() at least once before calling StartClient.");
                     return false;
                 }
 
@@ -536,6 +536,13 @@ namespace Unity.Netcode.Transports.UTP
                 serverEndpoint = ConnectionData.ServerEndPoint;
             }
 
+            // Verify the endpoint is valid before proceeding
+            if (serverEndpoint.Family == NetworkFamily.Invalid)
+            {
+                Debug.LogError($"Target server network address ({ConnectionData.Address}) is {nameof(NetworkFamily.Invalid)}!");
+                return false;
+            }
+
             InitDriver();
 
             var bindEndpoint = serverEndpoint.Family == NetworkFamily.Ipv6 ? NetworkEndpoint.AnyIpv6 : NetworkEndpoint.AnyIpv4;
@@ -554,6 +561,13 @@ namespace Unity.Netcode.Transports.UTP
 
         private bool ServerBindAndListen(NetworkEndpoint endPoint)
         {
+            // Verify the endpoint is valid before proceeding
+            if (endPoint.Family == NetworkFamily.Invalid)
+            {
+                Debug.LogError($"Network listen address ({ConnectionData.Address}) is {nameof(NetworkFamily.Invalid)}!");
+                return false;
+            }
+
             InitDriver();
 
             int result = m_Driver.Bind(endPoint);
@@ -696,7 +710,7 @@ namespace Unity.Netcode.Transports.UTP
             //reflection, but this does not live in the context of a performance-critical loop, it runs once at initial connection time.
             if (m_RelayServerData.Equals(default(RelayServerData)))
             {
-                Debug.LogError("You must call SetRelayServerData() at least once before calling StartRelayServer.");
+                Debug.LogError("You must call SetRelayServerData() at least once before calling StartServer.");
                 return false;
             }
             else
@@ -939,7 +953,7 @@ namespace Unity.Netcode.Transports.UTP
                     {
                         continue;
                     }
-                    var transportClientId = NetworkManager.ClientIdToTransportId(ngoConnectionId);
+                    var transportClientId = NetworkManager.ConnectionManager.ClientIdToTransportId(ngoConnectionId);
                     ExtractNetworkMetricsForClient(transportClientId);
                 }
             }
@@ -1163,7 +1177,7 @@ namespace Unity.Netcode.Transports.UTP
 
             if (NetworkManager != null)
             {
-                var transportId = NetworkManager.ClientIdToTransportId(clientId);
+                var transportId = NetworkManager.ConnectionManager.ClientIdToTransportId(clientId);
 
                 var rtt = ExtractRtt(ParseClientId(transportId));
                 if (rtt > 0)
@@ -1268,7 +1282,7 @@ namespace Unity.Netcode.Transports.UTP
                     // provide any reliability guarantees anymore. Disconnect the client since at
                     // this point they're bound to become desynchronized.
 
-                    var ngoClientId = NetworkManager?.TransportIdToClientId(clientId) ?? clientId;
+                    var ngoClientId = NetworkManager?.ConnectionManager.TransportIdToClientId(clientId) ?? clientId;
                     Debug.LogError($"Couldn't add payload of size {payload.Count} to reliable send queue. " +
                         $"Closing connection {ngoClientId} as reliability guarantees can't be maintained.");
 
@@ -1368,24 +1382,22 @@ namespace Unity.Netcode.Transports.UTP
         /// </summary>
         public override void Shutdown()
         {
-            if (!m_Driver.IsCreated)
+            if (m_Driver.IsCreated)
             {
-                return;
-            }
+                // Flush all send queues to the network. NGO can be configured to flush its message
+                // queue on shutdown. But this only calls the Send() method, which doesn't actually
+                // get anything to the network.
+                foreach (var kvp in m_SendQueue)
+                {
+                    SendBatchedMessages(kvp.Key, kvp.Value);
+                }
 
-            // Flush all send queues to the network. NGO can be configured to flush its message
-            // queue on shutdown. But this only calls the Send() method, which doesn't actually
-            // get anything to the network.
-            foreach (var kvp in m_SendQueue)
-            {
-                SendBatchedMessages(kvp.Key, kvp.Value);
+                // The above flush only puts the message in UTP internal buffers, need an update to
+                // actually get the messages on the wire. (Normally a flush send would be sufficient,
+                // but there might be disconnect messages and those require an update call.)
+                m_Driver.ScheduleUpdate().Complete();
             }
 
-            // The above flush only puts the message in UTP internal buffers, need an update to
-            // actually get the messages on the wire. (Normally a flush send would be sufficient,
-            // but there might be disconnect messages and those require an update call.)
-            m_Driver.ScheduleUpdate().Complete();
-
             DisposeInternals();
 
             m_ReliableReceiveQueues.Clear();