com.unity.netcode.gameobjects@1.0.0-pre.10

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.0.0-pre.10] - 2022-06-21 ### Added - Added a new `OnTransportFailure` callback to `NetworkManager`. This callback is invoked when the manager's `NetworkTransport` encounters an unrecoverable error. Transport failures also cause the `NetworkManager` to shut down. Currently, this is only used by `UnityTransport` to signal a timeout of its connection to the Unity Relay servers. (#1994) - Added `NetworkEvent.TransportFailure`, which can be used by implementations of `NetworkTransport` to signal to `NetworkManager` that an unrecoverable error was encountered. (#1994) - Added test to ensure a warning occurs when nesting NetworkObjects in a NetworkPrefab (#1969) - Added `NetworkManager.RemoveNetworkPrefab(...)` to remove a prefab from the prefabs list (#1950) ### Changed - Updated `UnityTransport` dependency on `com.unity.transport` to 1.1.0. (#2025) - (API Breaking) `ConnectionApprovalCallback` is no longer an `event` and will not allow more than 1 handler registered at a time. Also, `ConnectionApprovalCallback` is now a `Func<>` taking `ConnectionApprovalRequest` in and returning `ConnectionApprovalResponse` back out (#1972) ### Removed ### Fixed - Fixed issue where dynamically spawned `NetworkObject`s could throw an exception if the scene of origin handle was zero (0) and the `NetworkObject` was already spawned. (#2017) - Fixed issue where `NetworkObject.Observers` was not being cleared when despawned. (#2009) - Fixed `NetworkAnimator` could not run in the server authoritative mode. (#2003) - Fixed issue where late joining clients would get a soft synchronization error if any in-scene placed NetworkObjects were parented under another `NetworkObject`. (#1985) - Fixed issue where `NetworkBehaviourReference` would throw a type cast exception if using `NetworkBehaviourReference.TryGet` and the component type was not found. (#1984) - Fixed `NetworkSceneManager` was not sending scene event notifications for the currently active scene and any additively loaded scenes when loading a new scene in `LoadSceneMode.Single` mode. (#1975) - Fixed issue where one or more clients disconnecting during a scene event would cause `LoadEventCompleted` or `UnloadEventCompleted` to wait until the `NetworkConfig.LoadSceneTimeOut` period before being triggered. (#1973) - Fixed issues when multiple `ConnectionApprovalCallback`s were registered (#1972) - Fixed a regression in serialization support: `FixedString`, `Vector2Int`, and `Vector3Int` types can now be used in NetworkVariables and RPCs again without requiring a `ForceNetworkSerializeByMemcpy<>` wrapper. (#1961) - Fixed generic types that inherit from NetworkBehaviour causing crashes at compile time. (#1976) - Fixed endless dialog boxes when adding a `NetworkBehaviour` to a `NetworkManager` or vice-versa. (#1947) - Fixed `NetworkAnimator` issue where it was only synchronizing parameters if the layer or state changed or was transitioning between states. (#1946) - Fixed `NetworkAnimator` issue where when it did detect a parameter had changed it would send all parameters as opposed to only the parameters that changed. (#1946) - Fixed `NetworkAnimator` issue where it was not always disposing the `NativeArray` that is allocated when spawned. (#1946) - Fixed `NetworkAnimator` issue where it was not taking the animation speed or state speed multiplier into consideration. (#1946) - Fixed `NetworkAnimator` issue where it was not properly synchronizing late joining clients if they joined while `Animator` was transitioning between states. (#1946) - Fixed `NetworkAnimator` issue where the server was not relaying changes to non-owner clients when a client was the owner. (#1946) - Fixed issue where the `PacketLoss` metric for tools would return the packet loss over a connection lifetime instead of a single frame. (#2004)
com.unity.netcode.gameobjects@1.0.0-pre.9
2022-06-21 00:00:00 +00:00 · 2022-05-10 00:00:00 +00:00 · 2022-04-27 00:00:00 +00:00 · 2022-04-01 00:00:00 +00:00 · 2022-03-02 00:00:00 +00:00
321 changed files with 20227 additions and 8423 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,140 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)

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

+## [1.0.0-pre.10] - 2022-06-21
+
+### Added
+
+- Added a new `OnTransportFailure` callback to `NetworkManager`. This callback is invoked when the manager's `NetworkTransport` encounters an unrecoverable error. Transport failures also cause the `NetworkManager` to shut down. Currently, this is only used by `UnityTransport` to signal a timeout of its connection to the Unity Relay servers. (#1994)
+- Added `NetworkEvent.TransportFailure`, which can be used by implementations of `NetworkTransport` to signal to `NetworkManager` that an unrecoverable error was encountered. (#1994)
+- Added test to ensure a warning occurs when nesting NetworkObjects in a NetworkPrefab (#1969)
+- Added `NetworkManager.RemoveNetworkPrefab(...)` to remove a prefab from the prefabs list (#1950)
+
+### Changed
+
+- Updated `UnityTransport` dependency on `com.unity.transport` to 1.1.0. (#2025)
+- (API Breaking) `ConnectionApprovalCallback` is no longer an `event` and will not allow more than 1 handler registered at a time. Also, `ConnectionApprovalCallback` is now a `Func<>` taking `ConnectionApprovalRequest` in and returning `ConnectionApprovalResponse` back out (#1972)
+
+### Removed
+
+### Fixed
+- Fixed issue where dynamically spawned `NetworkObject`s could throw an exception if the scene of origin handle was zero (0) and the `NetworkObject` was already spawned. (#2017)
+- Fixed issue where `NetworkObject.Observers` was not being cleared when despawned. (#2009)
+- Fixed `NetworkAnimator` could not run in the server authoritative mode. (#2003)
+- Fixed issue where late joining clients would get a soft synchronization error if any in-scene placed NetworkObjects were parented under another `NetworkObject`. (#1985)
+- Fixed issue where `NetworkBehaviourReference` would throw a type cast exception if using `NetworkBehaviourReference.TryGet` and the component type was not found. (#1984)
+- Fixed `NetworkSceneManager` was not sending scene event notifications for the currently active scene and any additively loaded scenes when loading a new scene in `LoadSceneMode.Single` mode. (#1975)
+- Fixed issue where one or more clients disconnecting during a scene event would cause `LoadEventCompleted` or `UnloadEventCompleted` to wait until the `NetworkConfig.LoadSceneTimeOut` period before being triggered. (#1973)
+- Fixed issues when multiple `ConnectionApprovalCallback`s were registered (#1972)
+- Fixed a regression in serialization support: `FixedString`, `Vector2Int`, and `Vector3Int` types can now be used in NetworkVariables and RPCs again without requiring a `ForceNetworkSerializeByMemcpy<>` wrapper. (#1961)
+- Fixed generic types that inherit from NetworkBehaviour causing crashes at compile time. (#1976)
+- Fixed endless dialog boxes when adding a `NetworkBehaviour` to a `NetworkManager` or vice-versa. (#1947)
+- Fixed `NetworkAnimator` issue where it was only synchronizing parameters if the layer or state changed or was transitioning between states. (#1946)
+- Fixed `NetworkAnimator` issue where when it did detect a parameter had changed it would send all parameters as opposed to only the parameters that changed. (#1946)
+- Fixed `NetworkAnimator` issue where it was not always disposing the `NativeArray` that is allocated when spawned. (#1946)
+- Fixed `NetworkAnimator` issue where it was not taking the animation speed or state speed multiplier into consideration. (#1946)
+- Fixed `NetworkAnimator` issue where it was not properly synchronizing late joining clients if they joined while `Animator` was transitioning between states. (#1946)
+- Fixed `NetworkAnimator` issue where the server was not relaying changes to non-owner clients when a client was the owner. (#1946)
+- Fixed issue where the `PacketLoss` metric for tools would return the packet loss over a connection lifetime instead of a single frame. (#2004)
+
+## [1.0.0-pre.9] - 2022-05-10
+
+### Fixed
+
+- Fixed Hosting again after failing to host now works correctly (#1938)
+- Fixed NetworkManager to cleanup connected client lists after stopping (#1945)
+- Fixed NetworkHide followed by NetworkShow on the same frame works correctly (#1940)
+
+## [1.0.0-pre.8] - 2022-04-27
+
+### Changed
+
+- `unmanaged` structs are no longer universally accepted as RPC parameters because some structs (i.e., structs with pointers in them, such as `NativeList<T>`) can't be supported by the default memcpy struct serializer. Structs that are intended to be serialized across the network must add `INetworkSerializeByMemcpy` to the interface list (i.e., `struct Foo : INetworkSerializeByMemcpy`). This interface is empty and just serves to mark the struct as compatible with memcpy serialization. For external structs you can't edit, you can pass them to RPCs by wrapping them in `ForceNetworkSerializeByMemcpy<T>`. (#1901)
+- Changed requirement to register in-scene placed NetworkObjects with `NetworkManager` in order to respawn them.  In-scene placed NetworkObjects are now automatically tracked during runtime and no longer need to be registered as a NetworkPrefab.  (#1898)
+
+### Removed
+
+- Removed `SIPTransport` (#1870)
+- Removed `ClientNetworkTransform` from the package samples and moved to Boss Room's Utilities package which can be found [here](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/main/Packages/com.unity.multiplayer.samples.coop/Utilities/Net/ClientAuthority/ClientNetworkTransform.cs) (#1912)
+
+### Fixed
+- Fixed issue where `NetworkSceneManager` did not synchronize despawned in-scene placed NetworkObjects. (#1898)
+- Fixed `NetworkTransform` generating false positive rotation delta checks when rolling over between 0 and 360 degrees. (#1890)
+- Fixed client throwing an exception if it has messages in the outbound queue when processing the `NetworkEvent.Disconnect` event and is using UTP. (#1884)
+- Fixed issue during client synchronization if 'ValidateSceneBeforeLoading' returned false it would halt the client synchronization process resulting in a client that was approved but not synchronized or fully connected with the server. (#1883)
+- Fixed an issue where UNetTransport.StartServer would return success even if the underlying transport failed to start (#854)
+- Passing generic types to RPCs no longer causes a native crash (#1901)
+- Fixed a compile failure when compiling against com.unity.nuget.mono-cecil >= 1.11.4 (#1920)
+- Fixed an issue where calling `Shutdown` on a `NetworkManager` that was already shut down would cause an immediate shutdown the next time it was started (basically the fix makes `Shutdown` idempotent). (#1877)
+
+## [1.0.0-pre.7] - 2022-04-06
+
+### Added
+
+- Added editor only check prior to entering into play mode if the currently open and active scene is in the build list and if not displays a dialog box asking the user if they would like to automatically add it prior to entering into play mode. (#1828)
+- Added `UnityTransport` implementation and `com.unity.transport` package dependency (#1823)
+- Added `NetworkVariableWritePermission` to `NetworkVariableBase` and implemented `Owner` client writable netvars. (#1762)
+- `UnityTransport` settings can now be set programmatically. (#1845)
+- `FastBufferWriter` and Reader IsInitialized property. (#1859)
+- Prefabs can now be added to the network at **runtime** (i.e., from an addressable asset). If `ForceSamePrefabs` is false, this can happen after a connection has been formed. (#1882)
+- When `ForceSamePrefabs` is false, a configurable delay (default 1 second, configurable via `NetworkConfig.SpawnTimeout`) has been introduced to gracefully handle race conditions where a spawn call has been received for an object whose prefab is still being loaded. (#1882)
+
+### Changed
+
+- Changed `NetcodeIntegrationTestHelpers` to use `UnityTransport` (#1870)
+- Updated `UnityTransport` dependency on `com.unity.transport` to 1.0.0 (#1849)
+
+### Removed
+
+- Removed `SnapshotSystem` (#1852)
+- Removed `com.unity.modules.animation`, `com.unity.modules.physics` and `com.unity.modules.physics2d` dependencies from the package (#1812)
+- Removed `com.unity.collections` dependency from the package (#1849)
+
+### Fixed
+
+- Fixed in-scene placed NetworkObjects not being found/ignored after a client disconnects and then reconnects. (#1850)
+- Fixed issue where `UnityTransport` send queues were not flushed when calling `DisconnectLocalClient` or `DisconnectRemoteClient`. (#1847)
+- Fixed NetworkBehaviour dependency verification check for an existing NetworkObject not searching from root parent transform relative GameObject. (#1841)
+- Fixed issue where entries were not being removed from the NetworkSpawnManager.OwnershipToObjectsTable. (#1838)
+- Fixed ClientRpcs would always send to all connected clients by default as opposed to only sending to the NetworkObject's Observers list by default. (#1836)
+- Fixed clarity for NetworkSceneManager client side notification when it receives a scene hash value that does not exist in its local hash table. (#1828)
+- Fixed client throws a key not found exception when it times out using UNet or UTP. (#1821)
+- Fixed network variable updates are no longer limited to 32,768 bytes when NetworkConfig.EnsureNetworkVariableLengthSafety is enabled. The limits are now determined by what the transport can send in a message. (#1811)
+- Fixed in-scene NetworkObjects get destroyed if a client fails to connect and shuts down the NetworkManager. (#1809)
+- Fixed user never being notified in the editor that a NetworkBehaviour requires a NetworkObject to function properly. (#1808)
+- Fixed PlayerObjects and dynamically spawned NetworkObjects not being added to the NetworkClient's OwnedObjects (#1801)
+- Fixed issue where NetworkManager would continue starting even if the NetworkTransport selected failed. (#1780)
+- Fixed issue when spawning new player if an already existing player exists it does not remove IsPlayer from the previous player (#1779)
+- Fixed lack of notification that NetworkManager and NetworkObject cannot be added to the same GameObject with in-editor notifications (#1777)
+- Fixed parenting warning printing for false positives (#1855)
+
+## [1.0.0-pre.6] - 2022-03-02
+
+### Added
+- NetworkAnimator now properly synchrhonizes all animation layers as well as runtime-adjusted weighting between them (#1765)
+- Added first set of tests for NetworkAnimator - parameter syncing, trigger set / reset, override network animator (#1735)
+
+### Fixed
+- Fixed an issue where sometimes the first client to connect to the server could see messages from the server as coming from itself. (#1683)
+- Fixed an issue where clients seemed to be able to send messages to ClientId 1, but these messages would actually still go to the server (id 0) instead of that client. (#1683)
+- Improved clarity of error messaging when a client attempts to send a message to a destination other than the server, which isn't allowed. (#1683)
+- Disallowed async keyword in RPCs (#1681)
+- Fixed an issue where Alpha release versions of Unity (version 2022.2.0a5 and later) will not compile due to the UNet Transport no longer existing (#1678)
+- Fixed messages larger than 64k being written with incorrectly truncated message size in header (#1686) (credit: @kaen)
+- Fixed overloading RPC methods causing collisions and failing on IL2CPP targets. (#1694)
+- Fixed spawn flow to propagate `IsSceneObject` down to children NetworkObjects, decouple implicit relationship between object spawning & `IsSceneObject` flag (#1685)
+- Fixed error when serializing ConnectionApprovalMessage with scene management disabled when one or more objects is hidden via the CheckObjectVisibility delegate (#1720)
+- Fixed CheckObjectVisibility delegate not being properly invoked for connecting clients when Scene Management is enabled. (#1680)
+- Fixed NetworkList to properly call INetworkSerializable's NetworkSerialize() method (#1682)
+- Fixed NetworkVariables containing more than 1300 bytes of data (such as large NetworkLists) no longer cause an OverflowException (the limit on data size is now whatever limit the chosen transport imposes on fragmented NetworkDelivery mechanisms) (#1725)
+- Fixed ServerRpcParams and ClientRpcParams must be the last parameter of an RPC in order to function properly. Added a compile-time check to ensure this is the case and trigger an error if they're placed elsewhere (#1721)
+- Fixed FastBufferReader being created with a length of 1 if provided an input of length 0 (#1724)
+- Fixed The NetworkConfig's checksum hash includes the NetworkTick so that clients with a different tickrate than the server are identified and not allowed to connect (#1728)
+- Fixed OwnedObjects not being properly modified when using ChangeOwnership (#1731)
+- Improved performance in NetworkAnimator (#1735)
+- Removed the "always sync" network animator (aka "autosend") parameters (#1746)
+- Fixed in-scene placed NetworkObjects not respawning after shutting down the NetworkManager and then starting it back up again (#1769)
+
 ## [1.0.0-pre.5] - 2022-01-26

 ### Added
@@ -15,12 +149,15 @@ Additional documentation and release notes are available at [Multiplayer Documen
 ### Changed

 - NetworkManager's GameObject is no longer allowed to be nested under one or more GameObject(s).(#1484)
- NetworkManager DontDestroy property was removed and now NetworkManager always is migrated into the DontDestroyOnLoad scene. (#1484)
+- NetworkManager DontDestroy property was removed and now NetworkManager always is migrated into the DontDestroyOnLoad scene. (#1484)'

 ### Fixed

 - Fixed network tick value sometimes being duplicated or skipped. (#1614)
 - Fixed The ClientNetworkTransform sample script to allow for owner changes at runtime. (#1606)
+- Fixed When the LogLevel is set to developer NetworkBehaviour generates warning messages when it should not (#1631)
+- Fixed NetworkTransport Initialize now can receive the associated NetworkManager instance to avoid using NetworkManager.Singleton in transport layer (#1677)
+- Fixed a bug where NetworkList.Contains value was inverted (#1363)

 ## [1.0.0-pre.4] - 2021-01-04

--- a/Components/Interpolator/BufferedLinearInterpolator.cs
+++ b/Components/Interpolator/BufferedLinearInterpolator.cs
@@ -4,14 +4,13 @@ using UnityEngine;

 namespace Unity.Netcode
 {
-
    /// <summary>
    /// Solves for incoming values that are jittered
    /// Partially solves for message loss. Unclamped lerping helps hide this, but not completely
    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    internal abstract class BufferedLinearInterpolator<T> where T : struct
+    public abstract class BufferedLinearInterpolator<T> where T : struct
    {
+        internal float MaxInterpolationBound = 3.0f;
        private struct BufferedItem
        {
            public T Item;
@@ -24,6 +23,10 @@ namespace Unity.Netcode
            }
        }

+        /// <summary>
+        /// There’s two factors affecting interpolation: buffering (set in NetworkManager’s NetworkTimeSystem) and interpolation time, which is the amount of time it’ll take to reach the target. This is to affect the second one.
+        /// </summary>
+        public float MaximumInterpolationTime = 0.1f;

        private const double k_SmallValue = 9.999999439624929E-11; // copied from Vector3's equal operator

@@ -69,6 +72,19 @@ namespace Unity.Netcode

        private bool InvalidState => m_Buffer.Count == 0 && m_LifetimeConsumedCount == 0;

+        /// <summary>
+        /// Resets Interpolator to initial state
+        /// </summary>
+        public void Clear()
+        {
+            m_Buffer.Clear();
+            m_EndTimeConsumed = 0.0d;
+            m_StartTimeConsumed = 0.0d;
+        }
+
+        /// <summary>
+        /// Teleports current interpolation value to targetValue.
+        /// </summary>
        public void ResetTo(T targetValue, double serverTime)
        {
            m_LifetimeConsumedCount = 1;
@@ -82,7 +98,6 @@ namespace Unity.Netcode
            Update(0, serverTime, serverTime);
        }

-
        // todo if I have value 1, 2, 3 and I'm treating 1 to 3, I shouldn't interpolate between 1 and 3, I should interpolate from 1 to 2, then from 2 to 3 to get the best path
        private void TryConsumeFromBuffer(double renderTime, double serverTime)
        {
@@ -179,26 +194,34 @@ namespace Unity.Netcode

                    if (t < 0.0f)
                    {
-                        throw new OverflowException($"t = {t} but must be >= 0. range {range}, RenderTime {renderTime}, Start time {m_StartTimeConsumed}, end time {m_EndTimeConsumed}");
+                        // There is no mechanism to guarantee renderTime to not be before m_StartTimeConsumed
+                        // This clamps t to a minimum of 0 and fixes issues with longer frames and pauses
+
+                        if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+                        {
+                            NetworkLog.LogError($"renderTime was before m_StartTimeConsumed. This should never happen. {nameof(renderTime)} is {renderTime}, {nameof(m_StartTimeConsumed)} is {m_StartTimeConsumed}");
+                        }
+                        t = 0.0f;
                    }

-                    if (t > 3.0f) // max extrapolation
+                    if (t > MaxInterpolationBound) // max extrapolation
                    {
                        // TODO this causes issues with teleport, investigate
-                        // todo make this configurable
                        t = 1.0f;
                    }
                }

                var target = InterpolateUnclamped(m_InterpStartValue, m_InterpEndValue, t);
-                float maxInterpTime = 0.1f;
-                m_CurrentInterpValue = Interpolate(m_CurrentInterpValue, target, deltaTime / maxInterpTime); // second interpolate to smooth out extrapolation jumps
+                m_CurrentInterpValue = Interpolate(m_CurrentInterpValue, target, deltaTime / MaximumInterpolationTime); // second interpolate to smooth out extrapolation jumps
            }

            m_NbItemsReceivedThisFrame = 0;
            return m_CurrentInterpValue;
        }

+        /// <summary>
+        /// Add measurements to be used during interpolation. These will be buffered before being made available to be displayed as "latest value".
+        /// </summary>
        public void AddMeasurement(T newMeasurement, double sentTime)
        {
            m_NbItemsReceivedThisFrame++;
@@ -211,6 +234,8 @@ namespace Unity.Netcode
                {
                    m_LastBufferedItemReceived = new BufferedItem(newMeasurement, sentTime);
                    ResetTo(newMeasurement, sentTime);
+                    // Next line keeps renderTime above m_StartTimeConsumed. Fixes pause/unpause issues
+                    m_Buffer.Add(m_LastBufferedItemReceived);
                }

                return;
@@ -223,17 +248,25 @@ namespace Unity.Netcode
            }
        }

+        /// <summary>
+        /// Gets latest value from the interpolator. This is updated every update as time goes by.
+        /// </summary>
        public T GetInterpolatedValue()
        {
            return m_CurrentInterpValue;
        }

+        /// <summary>
+        /// Method to override and adapted to the generic type. This assumes interpolation for that value will be clamped.
+        /// </summary>
        protected abstract T Interpolate(T start, T end, float time);
+        /// <summary>
+        /// Method to override and adapted to the generic type. This assumes interpolation for that value will not be clamped.
+        /// </summary>
        protected abstract T InterpolateUnclamped(T start, T end, float time);
    }

-
-    internal class BufferedLinearInterpolatorFloat : BufferedLinearInterpolator<float>
+    public class BufferedLinearInterpolatorFloat : BufferedLinearInterpolator<float>
    {
        protected override float InterpolateUnclamped(float start, float end, float time)
        {
@@ -246,7 +279,7 @@ namespace Unity.Netcode
        }
    }

-    internal class BufferedLinearInterpolatorQuaternion : BufferedLinearInterpolator<Quaternion>
+    public class BufferedLinearInterpolatorQuaternion : BufferedLinearInterpolator<Quaternion>
    {
        protected override Quaternion InterpolateUnclamped(Quaternion start, Quaternion end, float time)
        {
--- a/Components/NetworkAnimator.cs
+++ b/Components/NetworkAnimator.cs
--- a/Components/NetworkRigidbody.cs
+++ b/Components/NetworkRigidbody.cs
@@ -1,80 +1,102 @@
+#if COM_UNITY_MODULES_PHYSICS
 using UnityEngine;

 namespace Unity.Netcode.Components
 {
    /// <summary>
    /// NetworkRigidbody allows for the use of <see cref="Rigidbody"/> on network objects. By controlling the kinematic
-    /// mode of the rigidbody and disabling it on all peers but the authoritative one.
+    /// mode of the <see cref="Rigidbody"/> and disabling it on all peers but the authoritative one.
    /// </summary>
    [RequireComponent(typeof(Rigidbody))]
    [RequireComponent(typeof(NetworkTransform))]
    public class NetworkRigidbody : NetworkBehaviour
    {
+        /// <summary>
+        /// Determines if we are server (true) or owner (false) authoritative
+        /// </summary>
+        private bool m_IsServerAuthoritative;
+
        private Rigidbody m_Rigidbody;
        private NetworkTransform m_NetworkTransform;
-
-        private bool m_OriginalKinematic;
        private RigidbodyInterpolation m_OriginalInterpolation;

-        // Used to cache the authority state of this rigidbody during the last frame
+        // Used to cache the authority state of this Rigidbody during the last frame
        private bool m_IsAuthority;

-        /// <summary>
-        /// Gets a bool value indicating whether this <see cref="NetworkRigidbody"/> on this peer currently holds authority.
-        /// </summary>
-        private bool HasAuthority => m_NetworkTransform.CanCommitToTransform;
-
        private void Awake()
        {
-            m_Rigidbody = GetComponent<Rigidbody>();
            m_NetworkTransform = GetComponent<NetworkTransform>();
-        }
-
-        private void FixedUpdate()
-        {
-            if (NetworkManager.IsListening)
-            {
-                if (HasAuthority != m_IsAuthority)
-                {
-                    m_IsAuthority = HasAuthority;
-                    UpdateRigidbodyKinematicMode();
-                }
-            }
-        }
-
-        // Puts the rigidbody in a kinematic non-interpolated mode on everyone but the server.
-        private void UpdateRigidbodyKinematicMode()
-        {
-            if (m_IsAuthority == false)
-            {
-                m_OriginalKinematic = m_Rigidbody.isKinematic;
-                m_Rigidbody.isKinematic = true;
+            m_IsServerAuthoritative = m_NetworkTransform.IsServerAuthoritative();

+            m_Rigidbody = GetComponent<Rigidbody>();
            m_OriginalInterpolation = m_Rigidbody.interpolation;
-                // Set interpolation to none, the NetworkTransform component interpolates the position of the object.
-                m_Rigidbody.interpolation = RigidbodyInterpolation.None;
+
+            // Set interpolation to none if NetworkTransform is handling interpolation, otherwise it sets it to the original value
+            m_Rigidbody.interpolation = m_NetworkTransform.Interpolate ? RigidbodyInterpolation.None : m_OriginalInterpolation;
+
+            // Turn off physics for the rigid body until spawned, otherwise
+            // clients can run fixed update before the first full
+            // NetworkTransform update
+            m_Rigidbody.isKinematic = true;
+        }
+
+        /// <summary>
+        /// For owner authoritative (i.e. ClientNetworkTransform)
+        /// we adjust our authority when we gain ownership
+        /// </summary>
+        public override void OnGainedOwnership()
+        {
+            UpdateOwnershipAuthority();
+        }
+
+        /// <summary>
+        /// For owner authoritative(i.e. ClientNetworkTransform)
+        /// we adjust our authority when we have lost ownership
+        /// </summary>
+        public override void OnLostOwnership()
+        {
+            UpdateOwnershipAuthority();
+        }
+
+        /// <summary>
+        /// Sets the authority differently depending upon
+        /// whether it is server or owner authoritative
+        /// </summary>
+        private void UpdateOwnershipAuthority()
+        {
+            if (m_IsServerAuthoritative)
+            {
+                m_IsAuthority = NetworkManager.IsServer;
            }
            else
            {
-                // Resets the rigidbody back to it's non replication only state. Happens on shutdown and when authority is lost
-                m_Rigidbody.isKinematic = m_OriginalKinematic;
-                m_Rigidbody.interpolation = m_OriginalInterpolation;
+                m_IsAuthority = IsOwner;
            }
+
+            // If you have authority then you are not kinematic
+            m_Rigidbody.isKinematic = !m_IsAuthority;
+
+            // Set interpolation of the Rigidbody based on authority
+            // With authority: let local transform handle interpolation
+            // Without authority: let the NetworkTransform handle interpolation
+            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : RigidbodyInterpolation.None;
        }

        /// <inheritdoc />
        public override void OnNetworkSpawn()
        {
-            m_IsAuthority = HasAuthority;
-            m_OriginalKinematic = m_Rigidbody.isKinematic;
-            m_OriginalInterpolation = m_Rigidbody.interpolation;
-            UpdateRigidbodyKinematicMode();
+            UpdateOwnershipAuthority();
        }

        /// <inheritdoc />
        public override void OnNetworkDespawn()
        {
-            UpdateRigidbodyKinematicMode();
+            m_Rigidbody.interpolation = m_OriginalInterpolation;
+            // Turn off physics for the rigid body until spawned, otherwise
+            // non-owners can run fixed updates before the first full
+            // NetworkTransform update and physics will be applied (i.e. gravity, etc)
+            m_Rigidbody.isKinematic = true;
        }
    }
 }
+#endif // COM_UNITY_MODULES_PHYSICS
--- a/Components/NetworkRigidbody2D.cs
+++ b/Components/NetworkRigidbody2D.cs
@@ -1,3 +1,4 @@
+#if COM_UNITY_MODULES_PHYSICS2D
 using UnityEngine;

 namespace Unity.Netcode.Components
@@ -78,3 +79,4 @@ namespace Unity.Netcode.Components
        }
    }
 }
+#endif // COM_UNITY_MODULES_PHYSICS2D
--- a/Components/NetworkTransform.cs
+++ b/Components/NetworkTransform.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using UnityEngine;
-using Random = UnityEngine.Random;

 namespace Unity.Netcode.Components
 {
@@ -15,9 +14,10 @@ namespace Unity.Netcode.Components
    [DefaultExecutionOrder(100000)] // this is needed to catch the update time after the transform was updated by user scripts
    public class NetworkTransform : NetworkBehaviour
    {
-        public const float PositionThresholdDefault = .001f;
-        public const float RotAngleThresholdDefault = .01f;
-        public const float ScaleThresholdDefault = .01f;
+        public const float PositionThresholdDefault = 0.001f;
+        public const float RotAngleThresholdDefault = 0.01f;
+        public const float ScaleThresholdDefault = 0.01f;
+
        public delegate (Vector3 pos, Quaternion rotOut, Vector3 scale) OnClientRequestChangeDelegate(Vector3 pos, Quaternion rot, Vector3 scale);
        public OnClientRequestChangeDelegate OnClientRequestChange;

@@ -38,7 +38,7 @@ namespace Unity.Netcode.Components
            // 11-15: <unused>
            private ushort m_Bitset;

-            public bool InLocalSpace
+            internal bool InLocalSpace
            {
                get => (m_Bitset & (1 << k_InLocalSpaceBit)) != 0;
                set
@@ -49,7 +49,7 @@ namespace Unity.Netcode.Components
            }

            // Position
-            public bool HasPositionX
+            internal bool HasPositionX
            {
                get => (m_Bitset & (1 << k_PositionXBit)) != 0;
                set
@@ -59,7 +59,7 @@ namespace Unity.Netcode.Components
                }
            }

-            public bool HasPositionY
+            internal bool HasPositionY
            {
                get => (m_Bitset & (1 << k_PositionYBit)) != 0;
                set
@@ -69,7 +69,7 @@ namespace Unity.Netcode.Components
                }
            }

-            public bool HasPositionZ
+            internal bool HasPositionZ
            {
                get => (m_Bitset & (1 << k_PositionZBit)) != 0;
                set
@@ -80,7 +80,7 @@ namespace Unity.Netcode.Components
            }

            // RotAngles
-            public bool HasRotAngleX
+            internal bool HasRotAngleX
            {
                get => (m_Bitset & (1 << k_RotAngleXBit)) != 0;
                set
@@ -90,7 +90,7 @@ namespace Unity.Netcode.Components
                }
            }

-            public bool HasRotAngleY
+            internal bool HasRotAngleY
            {
                get => (m_Bitset & (1 << k_RotAngleYBit)) != 0;
                set
@@ -100,7 +100,7 @@ namespace Unity.Netcode.Components
                }
            }

-            public bool HasRotAngleZ
+            internal bool HasRotAngleZ
            {
                get => (m_Bitset & (1 << k_RotAngleZBit)) != 0;
                set
@@ -111,7 +111,7 @@ namespace Unity.Netcode.Components
            }

            // Scale
-            public bool HasScaleX
+            internal bool HasScaleX
            {
                get => (m_Bitset & (1 << k_ScaleXBit)) != 0;
                set
@@ -121,7 +121,7 @@ namespace Unity.Netcode.Components
                }
            }

-            public bool HasScaleY
+            internal bool HasScaleY
            {
                get => (m_Bitset & (1 << k_ScaleYBit)) != 0;
                set
@@ -131,7 +131,7 @@ namespace Unity.Netcode.Components
                }
            }

-            public bool HasScaleZ
+            internal bool HasScaleZ
            {
                get => (m_Bitset & (1 << k_ScaleZBit)) != 0;
                set
@@ -141,7 +141,7 @@ namespace Unity.Netcode.Components
                }
            }

-            public bool IsTeleportingNextFrame
+            internal bool IsTeleportingNextFrame
            {
                get => (m_Bitset & (1 << k_TeleportingBit)) != 0;
                set
@@ -151,12 +151,12 @@ namespace Unity.Netcode.Components
                }
            }

-            public float PositionX, PositionY, PositionZ;
-            public float RotAngleX, RotAngleY, RotAngleZ;
-            public float ScaleX, ScaleY, ScaleZ;
-            public double SentTime;
+            internal float PositionX, PositionY, PositionZ;
+            internal float RotAngleX, RotAngleY, RotAngleZ;
+            internal float ScaleX, ScaleY, ScaleZ;
+            internal double SentTime;

-            public Vector3 Position
+            internal Vector3 Position
            {
                get { return new Vector3(PositionX, PositionY, PositionZ); }
                set
@@ -167,7 +167,7 @@ namespace Unity.Netcode.Components
                }
            }

-            public Vector3 Rotation
+            internal Vector3 Rotation
            {
                get { return new Vector3(RotAngleX, RotAngleY, RotAngleZ); }
                set
@@ -178,7 +178,7 @@ namespace Unity.Netcode.Components
                }
            }

-            public Vector3 Scale
+            internal Vector3 Scale
            {
                get { return new Vector3(ScaleX, ScaleY, ScaleZ); }
                set
@@ -249,7 +249,10 @@ namespace Unity.Netcode.Components
        public bool SyncScaleX = true, SyncScaleY = true, SyncScaleZ = true;

        public float PositionThreshold = PositionThresholdDefault;
+
+        [Range(0.001f, 360.0f)]
        public float RotAngleThreshold = RotAngleThresholdDefault;
+
        public float ScaleThreshold = ScaleThresholdDefault;

        /// <summary>
@@ -260,8 +263,10 @@ namespace Unity.Netcode.Components
        /// </summary>
        [Tooltip("Sets whether this transform should sync in local space or in world space")]
        public bool InLocalSpace = false;
+        private bool m_LastInterpolateLocal = false; // was the last frame local

        public bool Interpolate = true;
+        private bool m_LastInterpolate = true; // was the last frame interpolated

        /// <summary>
        /// Used to determine who can write to this transform. Server only for this transform.
@@ -270,7 +275,7 @@ namespace Unity.Netcode.Components
        /// If using different values, please use RPCs to write to the server. Netcode doesn't support client side network variable writing
        /// </summary>
        // This is public to make sure that users don't depend on this IsClient && IsOwner check in their code. If this logic changes in the future, we can make it invisible here
-        public bool CanCommitToTransform;
+        public bool CanCommitToTransform { get; protected set; }
        protected bool m_CachedIsServer;
        protected NetworkManager m_CachedNetworkManager;

@@ -278,8 +283,6 @@ namespace Unity.Netcode.Components

        private NetworkTransformState m_LocalAuthoritativeNetworkState;

-        private NetworkTransformState m_PrevNetworkState;
-
        private const int k_DebugDrawLineTime = 10;

        private bool m_HasSentLastValue = false; // used to send one last value, so clients can make the difference between lost replication data (clients extrapolate) and no more data to send.
@@ -367,8 +370,12 @@ namespace Unity.Netcode.Components
        private void CommitLocallyAndReplicate(NetworkTransformState networkState)
        {
            m_ReplicatedNetworkState.Value = networkState;
+
+            if (Interpolate)
+            {
                AddInterpolatedState(networkState);
            }
+        }

        private void ResetInterpolatedStateToCurrentAuthoritativeState()
        {
@@ -384,6 +391,16 @@ namespace Unity.Netcode.Components
            m_ScaleZInterpolator.ResetTo(m_LocalAuthoritativeNetworkState.ScaleZ, serverTime);
        }

+        /// <summary>
+        /// Will apply the transform to the LocalAuthoritativeNetworkState and get detailed isDirty information returned.
+        /// </summary>
+        /// <param name="transform">transform to apply</param>
+        /// <returns>bool isDirty, bool isPositionDirty, bool isRotationDirty, bool isScaleDirty</returns>
+        internal (bool isDirty, bool isPositionDirty, bool isRotationDirty, bool isScaleDirty) ApplyLocalNetworkState(Transform transform)
+        {
+            return ApplyTransformToNetworkStateWithInfo(ref m_LocalAuthoritativeNetworkState, m_CachedNetworkManager.LocalTime.Time, transform);
+        }
+
        // updates `NetworkState` properties if they need to and returns a `bool` indicating whether or not there was any changes made
        // returned boolean would be useful to change encapsulating `NetworkVariable<NetworkState>`'s dirty state, e.g. ReplNetworkState.SetDirty(isDirty);
        internal bool ApplyTransformToNetworkState(ref NetworkTransformState networkState, double dirtyTime, Transform transformToUse)
@@ -444,7 +461,7 @@ namespace Unity.Netcode.Components
            }

            if (SyncRotAngleX &&
-                Mathf.Abs(networkState.RotAngleX - rotAngles.x) > RotAngleThreshold)
+                Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleX, rotAngles.x)) > RotAngleThreshold)
            {
                networkState.RotAngleX = rotAngles.x;
                networkState.HasRotAngleX = true;
@@ -452,7 +469,7 @@ namespace Unity.Netcode.Components
            }

            if (SyncRotAngleY &&
-                Mathf.Abs(networkState.RotAngleY - rotAngles.y) > RotAngleThreshold)
+                Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleY, rotAngles.y)) > RotAngleThreshold)
            {
                networkState.RotAngleY = rotAngles.y;
                networkState.HasRotAngleY = true;
@@ -460,7 +477,7 @@ namespace Unity.Netcode.Components
            }

            if (SyncRotAngleZ &&
-                Mathf.Abs(networkState.RotAngleZ - rotAngles.z) > RotAngleThreshold)
+                Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleZ, rotAngles.z)) > RotAngleThreshold)
            {
                networkState.RotAngleZ = rotAngles.z;
                networkState.HasRotAngleZ = true;
@@ -503,8 +520,6 @@ namespace Unity.Netcode.Components

        private void ApplyInterpolatedNetworkStateToTransform(NetworkTransformState networkState, Transform transformToUpdate)
        {
-            m_PrevNetworkState = networkState;
-
            var interpolatedPosition = InLocalSpace ? transformToUpdate.localPosition : transformToUpdate.position;

            // todo: we should store network state w/ quats vs. euler angles
@@ -532,7 +547,12 @@ namespace Unity.Netcode.Components
            // again, we should be using quats here
            if (SyncRotAngleX || SyncRotAngleY || SyncRotAngleZ)
            {
-                var eulerAngles = m_RotationInterpolator.GetInterpolatedValue().eulerAngles;
+                var eulerAngles = new Vector3();
+                if (Interpolate)
+                {
+                    eulerAngles = m_RotationInterpolator.GetInterpolatedValue().eulerAngles;
+                }
+
                if (SyncRotAngleX)
                {
                    interpolatedRotAngles.x = networkState.IsTeleportingNextFrame || !Interpolate ? networkState.Rotation.x : eulerAngles.x;
@@ -576,8 +596,6 @@ namespace Unity.Netcode.Components
                {
                    transformToUpdate.position = interpolatedPosition;
                }
-
-                m_PrevNetworkState.Position = interpolatedPosition;
            }

            // RotAngles Apply
@@ -591,22 +609,55 @@ namespace Unity.Netcode.Components
                {
                    transformToUpdate.rotation = Quaternion.Euler(interpolatedRotAngles);
                }
-
-                m_PrevNetworkState.Rotation = interpolatedRotAngles;
            }

            // Scale Apply
            if (SyncScaleX || SyncScaleY || SyncScaleZ)
            {
                transformToUpdate.localScale = interpolatedScale;
-                m_PrevNetworkState.Scale = interpolatedScale;
            }
        }

-        private void AddInterpolatedState(NetworkTransformState newState)
+        private void AddInterpolatedState(NetworkTransformState newState, bool reset = false)
        {
            var sentTime = newState.SentTime;

+            if (reset)
+            {
+                if (newState.HasPositionX)
+                {
+                    m_PositionXInterpolator.ResetTo(newState.PositionX, sentTime);
+                }
+
+                if (newState.HasPositionY)
+                {
+                    m_PositionYInterpolator.ResetTo(newState.PositionY, sentTime);
+                }
+
+                if (newState.HasPositionZ)
+                {
+                    m_PositionZInterpolator.ResetTo(newState.PositionZ, sentTime);
+                }
+
+                m_RotationInterpolator.ResetTo(Quaternion.Euler(newState.Rotation), sentTime);
+
+                if (newState.HasScaleX)
+                {
+                    m_ScaleXInterpolator.ResetTo(newState.ScaleX, sentTime);
+                }
+
+                if (newState.HasScaleY)
+                {
+                    m_ScaleYInterpolator.ResetTo(newState.ScaleY, sentTime);
+                }
+
+                if (newState.HasScaleZ)
+                {
+                    m_ScaleZInterpolator.ResetTo(newState.ScaleZ, sentTime);
+                }
+
+                return;
+            }
            if (newState.HasPositionX)
            {
                m_PositionXInterpolator.AddMeasurement(newState.PositionX, sentTime);
@@ -644,7 +695,6 @@ namespace Unity.Netcode.Components
        {
            if (!NetworkObject.IsSpawned)
            {
-                // todo MTT-849 should never happen but yet it does! maybe revisit/dig after NetVar updates and snapshot system lands?
                return;
            }

@@ -654,17 +704,29 @@ namespace Unity.Netcode.Components
                return;
            }

-            Debug.DrawLine(newState.Position, newState.Position + Vector3.up + Vector3.left, Color.green, 10, false);
-
-            AddInterpolatedState(newState);
+            if (Interpolate)
+            {
+                AddInterpolatedState(newState, (newState.InLocalSpace != m_LastInterpolateLocal));
+            }
+            m_LastInterpolateLocal = newState.InLocalSpace;

            if (m_CachedNetworkManager.LogLevel == LogLevel.Developer)
            {
                var pos = new Vector3(newState.PositionX, newState.PositionY, newState.PositionZ);
-                Debug.DrawLine(pos, pos + Vector3.up + Vector3.left * Random.Range(0.5f, 2f), Color.green, k_DebugDrawLineTime, false);
            }
        }

+        public void SetMaxInterpolationBound(float maxInterpolationBound)
+        {
+            m_PositionXInterpolator.MaxInterpolationBound = maxInterpolationBound;
+            m_PositionYInterpolator.MaxInterpolationBound = maxInterpolationBound;
+            m_PositionZInterpolator.MaxInterpolationBound = maxInterpolationBound;
+            m_RotationInterpolator.MaxInterpolationBound = maxInterpolationBound;
+            m_ScaleXInterpolator.MaxInterpolationBound = maxInterpolationBound;
+            m_ScaleYInterpolator.MaxInterpolationBound = maxInterpolationBound;
+            m_ScaleZInterpolator.MaxInterpolationBound = maxInterpolationBound;
+        }
+
        private void Awake()
        {
            // we only want to create our interpolators during Awake so that, when pooled, we do not create tons
@@ -734,14 +796,12 @@ namespace Unity.Netcode.Components
            {
                m_ReplicatedNetworkState.SetDirty(true);
            }
-            else
+            else if (m_Transform != null)
            {
                ApplyInterpolatedNetworkStateToTransform(m_ReplicatedNetworkState.Value, m_Transform);
            }
        }

-        #region state set
-
        /// <summary>
        /// Directly sets a state on the authoritative transform.
        /// This will override any changes made previously to the transform
@@ -801,7 +861,6 @@ namespace Unity.Netcode.Components
            m_Transform.localScale = scale;
            m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame = shouldTeleport;
        }
-        #endregion

        // todo this is currently in update, to be able to catch any transform changes. A FixedUpdate mode could be added to be less intense, but it'd be
        // conditional to users only making transform update changes in FixedUpdate.
@@ -812,14 +871,23 @@ namespace Unity.Netcode.Components
                return;
            }

+            if (!Interpolate && m_LastInterpolate)
+            {
+                // if we just stopped interpolating, let's clear the interpolators
+                foreach (var interpolator in m_AllFloatInterpolators)
+                {
+                    interpolator.Clear();
+                }
+            }
+
+            m_LastInterpolate = Interpolate;
+
            if (CanCommitToTransform)
            {
                if (m_CachedIsServer)
                {
                    TryCommitTransformToServer(m_Transform, m_CachedNetworkManager.LocalTime.Time);
                }
-
-                m_PrevNetworkState = m_LocalAuthoritativeNetworkState;
            }

            // apply interpolated value
@@ -831,45 +899,22 @@ namespace Unity.Netcode.Components
                var cachedServerTime = serverTime.Time;
                var cachedRenderTime = serverTime.TimeTicksAgo(1).Time;

+                if (Interpolate)
+                {
                    foreach (var interpolator in m_AllFloatInterpolators)
                    {
                        interpolator.Update(cachedDeltaTime, cachedRenderTime, cachedServerTime);
                    }

                    m_RotationInterpolator.Update(cachedDeltaTime, cachedRenderTime, cachedServerTime);
+                }

                if (!CanCommitToTransform)
                {
-#if NGO_TRANSFORM_DEBUG
-                    if (m_CachedNetworkManager.LogLevel == LogLevel.Developer)
-                    {
-                        // TODO: This should be a component gizmo - not some debug draw based on log level
-                        var interpolatedPosition = new Vector3(m_PositionXInterpolator.GetInterpolatedValue(), m_PositionYInterpolator.GetInterpolatedValue(), m_PositionZInterpolator.GetInterpolatedValue());
-                        Debug.DrawLine(interpolatedPosition, interpolatedPosition + Vector3.up, Color.magenta, k_DebugDrawLineTime, false);
-
-                        // try to update previously consumed NetworkState
-                        // if we have any changes, that means made some updates locally
-                        // we apply the latest ReplNetworkState again to revert our changes
-                        var oldStateDirtyInfo = ApplyTransformToNetworkStateWithInfo(ref m_PrevNetworkState, 0, m_Transform);
-
-                        // there are several bugs in this code, as we the message is dumped out under odd circumstances
-                        //  For Matt, it would trigger when an object's rotation was perturbed by colliding with another
-                        //  object vs. explicitly rotating it
-                        if (oldStateDirtyInfo.isPositionDirty || oldStateDirtyInfo.isScaleDirty || (oldStateDirtyInfo.isRotationDirty && SyncRotAngleX && SyncRotAngleY && SyncRotAngleZ))
-                        {
-                            // ignoring rotation dirty since quaternions will mess with euler angles, making this impossible to determine if the change to a single axis comes
-                            // from an unauthorized transform change or euler to quaternion conversion artifacts.
-                            var dirtyField = oldStateDirtyInfo.isPositionDirty ? "position" : oldStateDirtyInfo.isRotationDirty ? "rotation" : "scale";
-                            Debug.LogWarning($"A local change to {dirtyField} without authority detected, reverting back to latest interpolated network state!", this);
-                        }
-                    }
-#endif
-
                    // Apply updated interpolated value
                    ApplyInterpolatedNetworkStateToTransform(m_ReplicatedNetworkState.Value, m_Transform);
                }
            }
-
            m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame = false;
        }

@@ -896,5 +941,21 @@ namespace Unity.Netcode.Components
            TryCommitValuesToServer(newPosition, newRotationEuler, newScale, m_CachedNetworkManager.LocalTime.Time);
            m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame = false;
        }
+
+        /// <summary>
+        /// Override this method and return false to switch to owner authoritative mode
+        /// </summary>
+        protected virtual bool OnIsServerAuthoritative()
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Used by <see cref="NetworkRigidbody"/> to determines if this is server or owner authoritative.
+        /// </summary>
+        internal bool IsServerAuthoritative()
+        {
+            return OnIsServerAuthoritative();
+        }
    }
 }
--- a/Components/com.unity.netcode.components.asmdef
+++ b/Components/com.unity.netcode.components.asmdef
@@ -5,13 +5,22 @@
        "Unity.Netcode.Runtime",
        "Unity.Collections"
    ],
-    "includePlatforms": [],
-    "excludePlatforms": [],
    "allowUnsafeCode": true,
-    "overrideReferences": false,
-    "precompiledReferences": [],
-    "autoReferenced": true,
-    "defineConstraints": [],
-    "versionDefines": [],
-    "noEngineReferences": false
+    "versionDefines": [
+        {
+            "name": "com.unity.modules.animation",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_ANIMATION"
+        },
+        {
+            "name": "com.unity.modules.physics",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_PHYSICS"
+        },
+        {
+            "name": "com.unity.modules.physics2d",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_PHYSICS2D"
+        }
+    ]
 }
--- a/Documentation~/Index.md
+++ b/Documentation~/Index.md
@@ -1,31 +0,0 @@
-# About Netcode for GameObjects
-
-Unity Netcode for GameObjects is a high-level networking library built to abstract networking. This allows developers to focus on the game rather than low level protocols and networking frameworks. 
-
-## Guides
-
-See guides below to install Unity Netcode for GameObjects, set up your project, and get started with your first networked game:
-
-* [Documentation](https://docs-multiplayer.unity3d.com/docs/getting-started/about-mlapi)
-* [Installation](https://docs-multiplayer.unity3d.com/docs/migration/install)
-* [First Steps](https://docs-multiplayer.unity3d.com/docs/tutorials/helloworld/helloworldintro)
-* [API Reference](https://docs-multiplayer.unity3d.com/docs/mlapi-api/introduction)
-
-# Technical details
-
-## Requirements
-
-This version of Netcode for GameObjects is compatible with the following Unity versions and platforms:
-
-* 2020.3 and later
-* Windows, Mac, Linux platforms
-
-## Document revision history
-
-|Date|Reason|
-|---|---|
-|March 10, 2021|Document created. Matches package version 0.1.0|
-|June 1, 2021|Update and add links for additional content. Matches patch version 0.1.0 and hotfixes.|
-|June 3, 2021|Update document to acknowledge Unity min version change. Matches package version 0.2.0|
-|August 5, 2021|Update product/package name|
-|September 9,2021|Updated the links and name of the file.|
--- a/Documentation~/index.md
+++ b/Documentation~/index.md
@@ -0,0 +1,35 @@
+# About Netcode for GameObjects
+
+Netcode for GameObjects is a Unity package that provides networking capabilities to GameObject & MonoBehaviour workflows.
+
+## Guides
+
+See guides below to install Unity Netcode for GameObjects, set up your project, and get started with your first networked game:
+
+- [Documentation](https://docs-multiplayer.unity3d.com/netcode/current/about)
+- [Installation](https://docs-multiplayer.unity3d.com/netcode/current/migration/install)
+- [First Steps](https://docs-multiplayer.unity3d.com/netcode/current/tutorials/helloworld/helloworldintro)
+- [API Reference](https://docs-multiplayer.unity3d.com/netcode/current/api/introduction)
+
+# Technical details
+
+## Requirements
+
+Netcode for GameObjects targets the following Unity versions:
+- Unity 2020.3, 2021.1, 2021.2 and 2021.3
+
+On the following runtime platforms:
+- Windows, MacOS, and Linux
+- iOS and Android
+- Most closed platforms, such as consoles. Contact us for more information about specific closed platforms.
+
+## Document revision history
+
+|Date|Reason|
+|---|---|
+|March 10, 2021|Document created. Matches package version 0.1.0|
+|June 1, 2021|Update and add links for additional content. Matches patch version 0.1.0 and hotfixes.|
+|June 3, 2021|Update document to acknowledge Unity min version change. Matches package version 0.2.0|
+|August 5, 2021|Update product/package name|
+|September 9,2021|Updated the links and name of the file.|
+|April 20, 2022|Updated links|
--- a/Editor/CodeGen/CodeGenHelpers.cs
+++ b/Editor/CodeGen/CodeGenHelpers.cs
@@ -6,6 +6,7 @@ using System.Text;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Mono.Cecil.Rocks;
+using Unity.Collections;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
 using UnityEngine;
@@ -22,7 +23,13 @@ namespace Unity.Netcode.Editor.CodeGen
        public static readonly string ClientRpcAttribute_FullName = typeof(ClientRpcAttribute).FullName;
        public static readonly string ServerRpcParams_FullName = typeof(ServerRpcParams).FullName;
        public static readonly string ClientRpcParams_FullName = typeof(ClientRpcParams).FullName;
+        public static readonly string ClientRpcSendParams_FullName = typeof(ClientRpcSendParams).FullName;
+        public static readonly string ClientRpcReceiveParams_FullName = typeof(ClientRpcReceiveParams).FullName;
+        public static readonly string ServerRpcSendParams_FullName = typeof(ServerRpcSendParams).FullName;
+        public static readonly string ServerRpcReceiveParams_FullName = typeof(ServerRpcReceiveParams).FullName;
        public static readonly string INetworkSerializable_FullName = typeof(INetworkSerializable).FullName;
+        public static readonly string INetworkSerializeByMemcpy_FullName = typeof(INetworkSerializeByMemcpy).FullName;
+        public static readonly string IUTF8Bytes_FullName = typeof(IUTF8Bytes).FullName;
        public static readonly string UnityColor_FullName = typeof(Color).FullName;
        public static readonly string UnityColor32_FullName = typeof(Color32).FullName;
        public static readonly string UnityVector2_FullName = typeof(Vector2).FullName;
@@ -73,6 +80,35 @@ namespace Unity.Netcode.Editor.CodeGen
            return false;
        }

+        public static string FullNameWithGenericParameters(this TypeReference typeReference, GenericParameter[] contextGenericParameters, TypeReference[] contextGenericParameterTypes)
+        {
+            var name = typeReference.FullName;
+            if (typeReference.HasGenericParameters)
+            {
+                name += "<";
+                for (var i = 0; i < typeReference.Resolve().GenericParameters.Count; ++i)
+                {
+                    if (i != 0)
+                    {
+                        name += ", ";
+                    }
+
+                    for (var j = 0; j < contextGenericParameters.Length; ++j)
+                    {
+                        if (typeReference.GenericParameters[i].FullName == contextGenericParameters[i].FullName)
+                        {
+                            name += contextGenericParameterTypes[i].FullName;
+                            break;
+                        }
+                    }
+                }
+
+                name += ">";
+            }
+
+            return name;
+        }
+
        public static bool HasInterface(this TypeReference typeReference, string interfaceTypeFullName)
        {
            if (typeReference.IsArray)
--- a/Editor/CodeGen/INetworkMessageILPP.cs
+++ b/Editor/CodeGen/INetworkMessageILPP.cs
@@ -13,7 +13,6 @@ using MethodAttributes = Mono.Cecil.MethodAttributes;

 namespace Unity.Netcode.Editor.CodeGen
 {
-
    internal sealed class INetworkMessageILPP : ILPPInterface
    {
        public override ILPPInterface GetInstance() => this;
@@ -31,7 +30,6 @@ namespace Unity.Netcode.Editor.CodeGen
                return null;
            }

-
            m_Diagnostics.Clear();

            // read
@@ -95,27 +93,23 @@ namespace Unity.Netcode.Editor.CodeGen
        }


-        private TypeReference m_FastBufferReader_TypeRef;
-        private TypeReference m_NetworkContext_TypeRef;
+        private MethodReference m_MessagingSystem_ReceiveMessage_MethodRef;
        private TypeReference m_MessagingSystem_MessageWithHandler_TypeRef;
        private MethodReference m_MessagingSystem_MessageHandler_Constructor_TypeRef;
        private FieldReference m_ILPPMessageProvider___network_message_types_FieldRef;
        private FieldReference m_MessagingSystem_MessageWithHandler_MessageType_FieldRef;
        private FieldReference m_MessagingSystem_MessageWithHandler_Handler_FieldRef;
        private MethodReference m_Type_GetTypeFromHandle_MethodRef;
-
        private MethodReference m_List_Add_MethodRef;

+        private const string k_ReceiveMessageName = nameof(MessagingSystem.ReceiveMessage);
+
        private bool ImportReferences(ModuleDefinition moduleDefinition)
        {
-            m_FastBufferReader_TypeRef = moduleDefinition.ImportReference(typeof(FastBufferReader));
-            m_NetworkContext_TypeRef = moduleDefinition.ImportReference(typeof(NetworkContext));
-            m_MessagingSystem_MessageHandler_Constructor_TypeRef =
-                moduleDefinition.ImportReference(typeof(MessagingSystem.MessageHandler).GetConstructors()[0]);
+            m_MessagingSystem_MessageHandler_Constructor_TypeRef = moduleDefinition.ImportReference(typeof(MessagingSystem.MessageHandler).GetConstructors()[0]);

            var messageWithHandlerType = typeof(MessagingSystem.MessageWithHandler);
-            m_MessagingSystem_MessageWithHandler_TypeRef =
-                moduleDefinition.ImportReference(messageWithHandlerType);
+            m_MessagingSystem_MessageWithHandler_TypeRef = moduleDefinition.ImportReference(messageWithHandlerType);
            foreach (var fieldInfo in messageWithHandlerType.GetFields())
            {
                switch (fieldInfo.Name)
@@ -162,40 +156,20 @@ namespace Unity.Netcode.Editor.CodeGen
                }
            }

+            var messagingSystemType = typeof(MessagingSystem);
+            foreach (var methodInfo in messagingSystemType.GetMethods(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public))
+            {
+                switch (methodInfo.Name)
+                {
+                    case k_ReceiveMessageName:
+                        m_MessagingSystem_ReceiveMessage_MethodRef = moduleDefinition.ImportReference(methodInfo);
+                        break;
+                }
+            }

            return true;
        }

-        private MethodReference GetNetworkMessageRecieveHandler(TypeDefinition typeDefinition)
-        {
-            SequencePoint typeSequence = null;
-            foreach (var method in typeDefinition.Methods)
-            {
-                var resolved = method.Resolve();
-                var methodSequence = resolved.DebugInformation.SequencePoints.FirstOrDefault();
-                if (typeSequence == null || methodSequence.StartLine < typeSequence.StartLine)
-                {
-                    typeSequence = methodSequence;
-                }
-
-                if (resolved.IsStatic && resolved.IsPublic && resolved.Name == "Receive" && resolved.Parameters.Count == 2
-                    && !resolved.Parameters[0].IsIn
-                    && !resolved.Parameters[0].ParameterType.IsByReference
-                    && resolved.Parameters[0].ParameterType.Resolve() ==
-                        m_FastBufferReader_TypeRef.Resolve()
-                    && resolved.Parameters[1].IsIn
-                    && resolved.Parameters[1].ParameterType.IsByReference
-                    && resolved.Parameters[1].ParameterType.GetElementType().Resolve() == m_NetworkContext_TypeRef.Resolve()
-                    && resolved.ReturnType == resolved.Module.TypeSystem.Void)
-                {
-                    return method;
-                }
-            }
-
-            m_Diagnostics.AddError(typeSequence, $"Class {typeDefinition.FullName} does not implement required method: `public static void Receive(FastBufferReader, in NetworkContext)`");
-            return null;
-        }
-
        private MethodDefinition GetOrCreateStaticConstructor(TypeDefinition typeDefinition)
        {
            var staticCtorMethodDef = typeDefinition.GetStaticConstructor();
@@ -264,11 +238,8 @@ namespace Unity.Netcode.Editor.CodeGen

                    foreach (var type in networkMessageTypes)
                    {
-                        var receiveMethod = GetNetworkMessageRecieveHandler(type);
-                        if (receiveMethod == null)
-                        {
-                            continue;
-                        }
+                        var receiveMethod = new GenericInstanceMethod(m_MessagingSystem_ReceiveMessage_MethodRef);
+                        receiveMethod.GenericArguments.Add(type);
                        CreateInstructionsToRegisterType(processor, instructions, type, receiveMethod);
                    }

--- a/Editor/CodeGen/INetworkSerializableILPP.cs
+++ b/Editor/CodeGen/INetworkSerializableILPP.cs
@@ -2,14 +2,11 @@ using System;
 using System.IO;
 using System.Linq;
 using System.Collections.Generic;
-using System.Reflection;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
-using Mono.Cecil.Rocks;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
 using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor;
-using MethodAttributes = Mono.Cecil.MethodAttributes;

 namespace Unity.Netcode.Editor.CodeGen
 {
@@ -24,6 +21,30 @@ namespace Unity.Netcode.Editor.CodeGen

        private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();

+        private TypeReference ResolveGenericType(TypeReference type, List<TypeReference> typeStack)
+        {
+            var genericName = type.Name;
+            var lastType = (GenericInstanceType)typeStack[typeStack.Count - 1];
+            var resolvedType = lastType.Resolve();
+            typeStack.RemoveAt(typeStack.Count - 1);
+            for (var i = 0; i < resolvedType.GenericParameters.Count; ++i)
+            {
+                var parameter = resolvedType.GenericParameters[i];
+                if (parameter.Name == genericName)
+                {
+                    var underlyingType = lastType.GenericArguments[i];
+                    if (underlyingType.Resolve() == null)
+                    {
+                        return ResolveGenericType(underlyingType, typeStack);
+                    }
+
+                    return underlyingType;
+                }
+            }
+
+            return null;
+        }
+
        public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly)
        {
            if (!WillProcess(compiledAssembly))
@@ -31,7 +52,6 @@ namespace Unity.Netcode.Editor.CodeGen
                return null;
            }

-
            m_Diagnostics.Clear();

            // read
@@ -48,22 +68,26 @@ namespace Unity.Netcode.Editor.CodeGen
            {
                try
                {
-                    if (ImportReferences(mainModule))
-                    {
-                        var types = mainModule.GetTypes()
-                            .Where(t => t.Resolve().HasInterface(CodeGenHelpers.INetworkSerializable_FullName) && !t.Resolve().IsAbstract && t.Resolve().IsValueType)
+                    var structTypes = mainModule.GetTypes()
+                        .Where(t => t.Resolve().HasInterface(CodeGenHelpers.INetworkSerializeByMemcpy_FullName) && !t.Resolve().IsAbstract && !t.Resolve().HasGenericParameters && t.Resolve().IsValueType)
                        .ToList();
-                        // process `INetworkMessage` types
-                        if (types.Count == 0)
-                        {
-                            return null;
-                        }

-                        CreateModuleInitializer(assemblyDefinition, types);
-                    }
-                    else
+                    foreach (var type in structTypes)
                    {
-                        m_Diagnostics.AddError($"Cannot import references into main module: {mainModule.Name}");
+                        // We'll avoid some confusion by ensuring users only choose one of the two
+                        // serialization schemes - by method OR by memcpy, not both. We'll also do a cursory
+                        // check that INetworkSerializeByMemcpy types are unmanaged.
+                        if (type.HasInterface(CodeGenHelpers.INetworkSerializeByMemcpy_FullName))
+                        {
+                            if (type.HasInterface(CodeGenHelpers.INetworkSerializable_FullName))
+                            {
+                                m_Diagnostics.AddError($"{nameof(INetworkSerializeByMemcpy)} types may not implement {nameof(INetworkSerializable)} - choose one or the other.");
+                            }
+                            if (!type.IsValueType)
+                            {
+                                m_Diagnostics.AddError($"{nameof(INetworkSerializeByMemcpy)} types must be unmanaged types.");
+                            }
+                        }
                    }
                }
                catch (Exception e)
@@ -93,75 +117,5 @@ namespace Unity.Netcode.Editor.CodeGen

            return new ILPostProcessResult(new InMemoryAssembly(pe.ToArray(), pdb.ToArray()), m_Diagnostics);
        }
-
-        private MethodReference m_InitializeDelegates_MethodRef;
-
-        private const string k_InitializeMethodName = nameof(NetworkVariableHelper.InitializeDelegates);
-
-        private bool ImportReferences(ModuleDefinition moduleDefinition)
-        {
-
-            var helperType = typeof(NetworkVariableHelper);
-            foreach (var methodInfo in helperType.GetMethods(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public))
-            {
-                switch (methodInfo.Name)
-                {
-                    case k_InitializeMethodName:
-                        m_InitializeDelegates_MethodRef = moduleDefinition.ImportReference(methodInfo);
-                        break;
-                }
-            }
-            return true;
-        }
-
-        private MethodDefinition GetOrCreateStaticConstructor(TypeDefinition typeDefinition)
-        {
-            var staticCtorMethodDef = typeDefinition.GetStaticConstructor();
-            if (staticCtorMethodDef == null)
-            {
-                staticCtorMethodDef = new MethodDefinition(
-                    ".cctor", // Static Constructor (constant-constructor)
-                    MethodAttributes.HideBySig |
-                    MethodAttributes.SpecialName |
-                    MethodAttributes.RTSpecialName |
-                    MethodAttributes.Static,
-                    typeDefinition.Module.TypeSystem.Void);
-                staticCtorMethodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
-                typeDefinition.Methods.Add(staticCtorMethodDef);
-            }
-
-            return staticCtorMethodDef;
-        }
-
-        // Creates a static module constructor (which is executed when the module is loaded) that registers all the
-        // message types in the assembly with MessagingSystem.
-        // This is the same behavior as annotating a static method with [ModuleInitializer] in standardized
-        // C# (that attribute doesn't exist in Unity, but the static module constructor still works)
-        // https://docs.microsoft.com/en-us/dotnet/api/system.runtime.compilerservices.moduleinitializerattribute?view=net-5.0
-        // https://web.archive.org/web/20100212140402/http://blogs.msdn.com/junfeng/archive/2005/11/19/494914.aspx
-        private void CreateModuleInitializer(AssemblyDefinition assembly, List<TypeDefinition> networkSerializableTypes)
-        {
-            foreach (var typeDefinition in assembly.MainModule.Types)
-            {
-                if (typeDefinition.FullName == "<Module>")
-                {
-                    var staticCtorMethodDef = GetOrCreateStaticConstructor(typeDefinition);
-
-                    var processor = staticCtorMethodDef.Body.GetILProcessor();
-
-                    var instructions = new List<Instruction>();
-
-                    foreach (var type in networkSerializableTypes)
-                    {
-                        var method = new GenericInstanceMethod(m_InitializeDelegates_MethodRef);
-                        method.GenericArguments.Add(type);
-                        instructions.Add(processor.Create(OpCodes.Call, method));
-                    }
-
-                    instructions.ForEach(instruction => processor.Body.Instructions.Insert(processor.Body.Instructions.Count - 1, instruction));
-                    break;
-                }
-            }
-        }
    }
 }
--- a/Editor/CodeGen/NetworkBehaviourILPP.cs
+++ b/Editor/CodeGen/NetworkBehaviourILPP.cs
@@ -7,7 +7,6 @@ using System.Runtime.CompilerServices;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Mono.Cecil.Rocks;
-using Unity.Collections;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
 using UnityEngine;
@@ -17,7 +16,6 @@ using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostPr

 namespace Unity.Netcode.Editor.CodeGen
 {
-
    internal sealed class NetworkBehaviourILPP : ILPPInterface
    {
        private const string k_ReadValueMethodName = nameof(FastBufferReader.ReadValueSafe);
@@ -25,7 +23,8 @@ namespace Unity.Netcode.Editor.CodeGen

        public override ILPPInterface GetInstance() => this;

-        public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.References.Any(filePath => Path.GetFileNameWithoutExtension(filePath) == CodeGenHelpers.RuntimeAssemblyName);
+        public override bool WillProcess(ICompiledAssembly compiledAssembly) =>
+            compiledAssembly.References.Any(filePath => Path.GetFileNameWithoutExtension(filePath) == CodeGenHelpers.RuntimeAssemblyName);

        private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();

@@ -109,8 +108,10 @@ namespace Unity.Netcode.Editor.CodeGen
        private FieldReference m_NetworkManager_rpc_name_table_FieldRef;
        private MethodReference m_NetworkManager_rpc_name_table_Add_MethodRef;
        private TypeReference m_NetworkBehaviour_TypeRef;
-        private MethodReference m_NetworkBehaviour_SendServerRpc_MethodRef;
-        private MethodReference m_NetworkBehaviour_SendClientRpc_MethodRef;
+        private MethodReference m_NetworkBehaviour_beginSendServerRpc_MethodRef;
+        private MethodReference m_NetworkBehaviour_endSendServerRpc_MethodRef;
+        private MethodReference m_NetworkBehaviour_beginSendClientRpc_MethodRef;
+        private MethodReference m_NetworkBehaviour_endSendClientRpc_MethodRef;
        private FieldReference m_NetworkBehaviour_rpc_exec_stage_FieldRef;
        private MethodReference m_NetworkBehaviour_getNetworkManager_MethodRef;
        private MethodReference m_NetworkBehaviour_getOwnerClientId_MethodRef;
@@ -124,8 +125,6 @@ namespace Unity.Netcode.Editor.CodeGen
        private TypeReference m_ClientRpcParams_TypeRef;

        private TypeReference m_FastBufferWriter_TypeRef;
-        private MethodReference m_FastBufferWriter_Constructor;
-        private MethodReference m_FastBufferWriter_Dispose;
        private Dictionary<string, MethodReference> m_FastBufferWriter_WriteValue_MethodRefs = new Dictionary<string, MethodReference>();
        private List<MethodReference> m_FastBufferWriter_ExtensionMethodRefs = new List<MethodReference>();

@@ -144,8 +143,10 @@ namespace Unity.Netcode.Editor.CodeGen
        private const string k_NetworkManager_rpc_name_table = nameof(NetworkManager.__rpc_name_table);

        private const string k_NetworkBehaviour_rpc_exec_stage = nameof(NetworkBehaviour.__rpc_exec_stage);
-        private const string k_NetworkBehaviour_SendServerRpc = nameof(NetworkBehaviour.__sendServerRpc);
-        private const string k_NetworkBehaviour_SendClientRpc = nameof(NetworkBehaviour.__sendClientRpc);
+        private const string k_NetworkBehaviour_beginSendServerRpc = nameof(NetworkBehaviour.__beginSendServerRpc);
+        private const string k_NetworkBehaviour_endSendServerRpc = nameof(NetworkBehaviour.__endSendServerRpc);
+        private const string k_NetworkBehaviour_beginSendClientRpc = nameof(NetworkBehaviour.__beginSendClientRpc);
+        private const string k_NetworkBehaviour_endSendClientRpc = nameof(NetworkBehaviour.__endSendClientRpc);
        private const string k_NetworkBehaviour_NetworkManager = nameof(NetworkBehaviour.NetworkManager);
        private const string k_NetworkBehaviour_OwnerClientId = nameof(NetworkBehaviour.OwnerClientId);

@@ -234,11 +235,17 @@ namespace Unity.Netcode.Editor.CodeGen
            {
                switch (methodInfo.Name)
                {
-                    case k_NetworkBehaviour_SendServerRpc:
-                        m_NetworkBehaviour_SendServerRpc_MethodRef = moduleDefinition.ImportReference(methodInfo);
+                    case k_NetworkBehaviour_beginSendServerRpc:
+                        m_NetworkBehaviour_beginSendServerRpc_MethodRef = moduleDefinition.ImportReference(methodInfo);
                        break;
-                    case k_NetworkBehaviour_SendClientRpc:
-                        m_NetworkBehaviour_SendClientRpc_MethodRef = moduleDefinition.ImportReference(methodInfo);
+                    case k_NetworkBehaviour_endSendServerRpc:
+                        m_NetworkBehaviour_endSendServerRpc_MethodRef = moduleDefinition.ImportReference(methodInfo);
+                        break;
+                    case k_NetworkBehaviour_beginSendClientRpc:
+                        m_NetworkBehaviour_beginSendClientRpc_MethodRef = moduleDefinition.ImportReference(methodInfo);
+                        break;
+                    case k_NetworkBehaviour_endSendClientRpc:
+                        m_NetworkBehaviour_endSendClientRpc_MethodRef = moduleDefinition.ImportReference(methodInfo);
                        break;
                }
            }
@@ -299,17 +306,12 @@ namespace Unity.Netcode.Editor.CodeGen
            var fastBufferWriterType = typeof(FastBufferWriter);
            m_FastBufferWriter_TypeRef = moduleDefinition.ImportReference(fastBufferWriterType);

-            m_FastBufferWriter_Constructor = moduleDefinition.ImportReference(
-                fastBufferWriterType.GetConstructor(new[] { typeof(int), typeof(Allocator), typeof(int) }));
-            m_FastBufferWriter_Dispose = moduleDefinition.ImportReference(fastBufferWriterType.GetMethod("Dispose"));
-
            var fastBufferReaderType = typeof(FastBufferReader);
            m_FastBufferReader_TypeRef = moduleDefinition.ImportReference(fastBufferReaderType);

            // Find all extension methods for FastBufferReader and FastBufferWriter to enable user-implemented
            // methods to be called.
-            var assemblies = new List<AssemblyDefinition>();
-            assemblies.Add(m_MainModule.Assembly);
+            var assemblies = new List<AssemblyDefinition> { m_MainModule.Assembly };
            foreach (var reference in m_MainModule.AssemblyReferences)
            {
                var assembly = m_AssemblyResolver.Resolve(reference);
@@ -319,8 +321,7 @@ namespace Unity.Netcode.Editor.CodeGen
                }
            }

-            var extensionConstructor =
-                moduleDefinition.ImportReference(typeof(ExtensionAttribute).GetConstructor(new Type[] { }));
+            var extensionConstructor = moduleDefinition.ImportReference(typeof(ExtensionAttribute).GetConstructor(new Type[] { }));
            foreach (var assembly in assemblies)
            {
                foreach (var module in assembly.Modules)
@@ -332,6 +333,7 @@ namespace Unity.Netcode.Editor.CodeGen
                        {
                            continue;
                        }
+
                        foreach (var method in type.Methods)
                        {
                            if (!method.IsStatic)
@@ -356,13 +358,11 @@ namespace Unity.Netcode.Editor.CodeGen

                            var parameters = method.Parameters;

-                            if (parameters.Count == 2
-                                && parameters[0].ParameterType.Resolve() == m_FastBufferWriter_TypeRef.MakeByReferenceType().Resolve())
+                            if (parameters.Count == 2 && parameters[0].ParameterType.Resolve() == m_FastBufferWriter_TypeRef.MakeByReferenceType().Resolve())
                            {
                                m_FastBufferWriter_ExtensionMethodRefs.Add(m_MainModule.ImportReference(method));
                            }
-                            else if (parameters.Count == 2
-                                && parameters[0].ParameterType.Resolve() == m_FastBufferReader_TypeRef.MakeByReferenceType().Resolve())
+                            else if (parameters.Count == 2 && parameters[0].ParameterType.Resolve() == m_FastBufferReader_TypeRef.MakeByReferenceType().Resolve())
                            {
                                m_FastBufferReader_ExtensionMethodRefs.Add(m_MainModule.ImportReference(method));
                            }
@@ -395,9 +395,20 @@ namespace Unity.Netcode.Editor.CodeGen
                    continue;
                }

+                if (methodDefinition.HasCustomAttributes)
+                {
+                    foreach (var attribute in methodDefinition.CustomAttributes)
+                    {
+                        if (attribute.AttributeType.Name == nameof(AsyncStateMachineAttribute))
+                        {
+                            m_Diagnostics.AddError(methodDefinition, $"{methodDefinition.FullName}: RPCs cannot be 'async'");
+                        }
+                    }
+                }
+
                InjectWriteAndCallBlocks(methodDefinition, rpcAttribute, rpcMethodId);

-                rpcHandlers.Add((rpcMethodId, GenerateStaticHandler(methodDefinition, rpcAttribute)));
+                rpcHandlers.Add((rpcMethodId, GenerateStaticHandler(methodDefinition, rpcAttribute, rpcMethodId)));

                if (isEditorOrDevelopment)
                {
@@ -477,7 +488,6 @@ namespace Unity.Netcode.Editor.CodeGen
        private CustomAttribute CheckAndGetRpcAttribute(MethodDefinition methodDefinition)
        {
            CustomAttribute rpcAttribute = null;
-            bool isServerRpc = false;
            foreach (var customAttribute in methodDefinition.CustomAttributes)
            {
                var customAttributeType_FullName = customAttribute.AttributeType.FullName;
@@ -499,6 +509,12 @@ namespace Unity.Netcode.Editor.CodeGen
                        isValid = false;
                    }

+                    if (methodDefinition.HasGenericParameters)
+                    {
+                        m_Diagnostics.AddError(methodDefinition, "RPC method must not be generic!");
+                        isValid = false;
+                    }
+
                    if (methodDefinition.ReturnType != methodDefinition.Module.TypeSystem.Void)
                    {
                        m_Diagnostics.AddError(methodDefinition, "RPC method must return `void`!");
@@ -521,9 +537,12 @@ namespace Unity.Netcode.Editor.CodeGen

                    if (isValid)
                    {
-                        isServerRpc = customAttributeType_FullName == CodeGenHelpers.ServerRpcAttribute_FullName;
                        rpcAttribute = customAttribute;
                    }
+                    else
+                    {
+                        return null;
+                    }
                }
            }

@@ -566,15 +585,21 @@ namespace Unity.Netcode.Editor.CodeGen
                    var checkType = paramType.Resolve();
                    if (paramType.IsArray)
                    {
-                        checkType = paramType.GetElementType().Resolve();
+                        checkType = ((ArrayType)paramType).ElementType.Resolve();
                    }

-                    if (
-                        (parameters[0].ParameterType.Resolve() == checkType
-                        || (parameters[0].ParameterType.Resolve() == checkType.MakeByReferenceType().Resolve() && parameters[0].IsIn)))
+                    if ((parameters[0].ParameterType.Resolve() == checkType ||
+                         (parameters[0].ParameterType.Resolve() == checkType.MakeByReferenceType().Resolve() && parameters[0].IsIn)))
                    {
                        return method;
                    }
+
+                    if (parameters[0].ParameterType == paramType ||
+                        (parameters[0].ParameterType == paramType.MakeByReferenceType() && parameters[0].IsIn))
+                    {
+                        return method;
+                    }
+
                    if (method.HasGenericParameters && method.GenericParameters.Count == 1)
                    {
                        if (method.GenericParameters[0].HasConstraints)
@@ -582,23 +607,43 @@ namespace Unity.Netcode.Editor.CodeGen
                            var meetsConstraints = true;
                            foreach (var constraint in method.GenericParameters[0].Constraints)
                            {
+#if CECIL_CONSTRAINTS_ARE_TYPE_REFERENCES
                                var resolvedConstraint = constraint.Resolve();
+                                var constraintTypeRef = constraint;
+#else
+                                var resolvedConstraint = constraint.ConstraintType.Resolve();
+                                var constraintTypeRef = constraint.ConstraintType;
+#endif

-                                if (
-                                    (resolvedConstraint.IsInterface &&
-                                     !checkType.HasInterface(resolvedConstraint.FullName))
-                                    || (resolvedConstraint.IsClass &&
-                                        !checkType.Resolve().IsSubclassOf(resolvedConstraint.FullName))
-                                    || (resolvedConstraint.Name == "ValueType" && !checkType.IsValueType))
+                                var resolvedConstraintName = resolvedConstraint.FullNameWithGenericParameters(new[] { method.GenericParameters[0] }, new[] { checkType });
+                                if (constraintTypeRef.IsGenericInstance)
+                                {
+                                    var genericConstraint = (GenericInstanceType)constraintTypeRef;
+                                    if (genericConstraint.HasGenericArguments && genericConstraint.GenericArguments[0].Resolve() != null)
+                                    {
+                                        resolvedConstraintName = constraintTypeRef.FullName;
+                                    }
+                                }
+                                if ((resolvedConstraint.IsInterface && !checkType.HasInterface(resolvedConstraintName)) ||
+                                    (resolvedConstraint.IsClass && !checkType.Resolve().IsSubclassOf(resolvedConstraintName)) ||
+                                    (resolvedConstraint.Name == "ValueType" && !checkType.IsValueType))
                                {
                                    meetsConstraints = false;
                                    break;
                                }
                            }
+
                            if (meetsConstraints)
                            {
                                var instanceMethod = new GenericInstanceMethod(method);
-                                instanceMethod.GenericArguments.Add(checkType);
+                                if (paramType.IsArray)
+                                {
+                                    instanceMethod.GenericArguments.Add(((ArrayType)paramType).ElementType);
+                                }
+                                else
+                                {
+                                    instanceMethod.GenericArguments.Add(paramType);
+                                }
                                return instanceMethod;
                            }
                        }
@@ -624,8 +669,8 @@ namespace Unity.Netcode.Editor.CodeGen
                    {
                        if (parameters[1].IsIn)
                        {
-                            if (parameters[1].ParameterType.Resolve() == paramType.MakeByReferenceType().Resolve()
-                                && ((ByReferenceType)parameters[1].ParameterType).ElementType.IsArray == paramType.IsArray)
+                            if (parameters[1].ParameterType.Resolve() == paramType.MakeByReferenceType().Resolve() &&
+                                ((ByReferenceType)parameters[1].ParameterType).ElementType.IsArray == paramType.IsArray)
                            {
                                methodRef = method;
                                m_FastBufferWriter_WriteValue_MethodRefs[assemblyQualifiedName] = methodRef;
@@ -635,8 +680,8 @@ namespace Unity.Netcode.Editor.CodeGen
                        else
                        {

-                            if (parameters[1].ParameterType.Resolve() == paramType.Resolve()
-                                && parameters[1].ParameterType.IsArray == paramType.IsArray)
+                            if (parameters[1].ParameterType.Resolve() == paramType.Resolve() &&
+                                parameters[1].ParameterType.IsArray == paramType.IsArray)
                            {
                                methodRef = method;
                                m_FastBufferWriter_WriteValue_MethodRefs[assemblyQualifiedName] = methodRef;
@@ -646,13 +691,7 @@ namespace Unity.Netcode.Editor.CodeGen
                    }
                }

-                // Try NetworkSerializable first because INetworkSerializable may also be valid for WriteValueSafe
-                // and that would cause boxing if so.
-                var typeMethod = GetFastBufferWriterWriteMethod("WriteNetworkSerializable", paramType);
-                if (typeMethod == null)
-                {
-                    typeMethod = GetFastBufferWriterWriteMethod(k_WriteValueMethodName, paramType);
-                }
+                var typeMethod = GetFastBufferWriterWriteMethod(k_WriteValueMethodName, paramType);
                if (typeMethod != null)
                {
                    methodRef = m_MainModule.ImportReference(typeMethod);
@@ -692,31 +731,67 @@ namespace Unity.Netcode.Editor.CodeGen
                    var checkType = paramType.Resolve();
                    if (paramType.IsArray)
                    {
-                        checkType = paramType.GetElementType().Resolve();
+                        checkType = ((ArrayType)paramType).ElementType.Resolve();
                    }

                    if (methodParam.Resolve() == checkType.Resolve() || methodParam.Resolve() == checkType.MakeByReferenceType().Resolve())
                    {
                        return method;
                    }
+
+                    if (methodParam.Resolve() == paramType || methodParam.Resolve() == paramType.MakeByReferenceType().Resolve())
+                    {
+                        return method;
+                    }
+
                    if (method.HasGenericParameters && method.GenericParameters.Count == 1)
                    {
                        if (method.GenericParameters[0].HasConstraints)
                        {
+                            var meetsConstraints = true;
                            foreach (var constraint in method.GenericParameters[0].Constraints)
                            {
+#if CECIL_CONSTRAINTS_ARE_TYPE_REFERENCES
                                var resolvedConstraint = constraint.Resolve();
+                                var constraintTypeRef = constraint;
+#else
+                                var resolvedConstraint = constraint.ConstraintType.Resolve();
+                                var constraintTypeRef = constraint.ConstraintType;
+#endif

-                                if (
-                                    (resolvedConstraint.IsInterface &&
-                                     checkType.HasInterface(resolvedConstraint.FullName))
-                                    || (resolvedConstraint.IsClass &&
-                                        checkType.Resolve().IsSubclassOf(resolvedConstraint.FullName)))
+
+                                var resolvedConstraintName = resolvedConstraint.FullNameWithGenericParameters(new[] { method.GenericParameters[0] }, new[] { checkType });
+                                if (constraintTypeRef.IsGenericInstance)
+                                {
+                                    var genericConstraint = (GenericInstanceType)constraintTypeRef;
+                                    if (genericConstraint.HasGenericArguments && genericConstraint.GenericArguments[0].Resolve() != null)
+                                    {
+                                        resolvedConstraintName = constraintTypeRef.FullName;
+                                    }
+                                }
+
+                                if ((resolvedConstraint.IsInterface && !checkType.HasInterface(resolvedConstraintName)) ||
+                                    (resolvedConstraint.IsClass && !checkType.Resolve().IsSubclassOf(resolvedConstraintName)) ||
+                                    (resolvedConstraint.Name == "ValueType" && !checkType.IsValueType))
+                                {
+                                    meetsConstraints = false;
+                                    break;
+                                }
+                            }
+
+                            if (meetsConstraints)
                            {
                                var instanceMethod = new GenericInstanceMethod(method);
-                                    instanceMethod.GenericArguments.Add(checkType);
-                                    return instanceMethod;
+                                if (paramType.IsArray)
+                                {
+                                    instanceMethod.GenericArguments.Add(((ArrayType)paramType).ElementType);
                                }
+                                else
+                                {
+                                    instanceMethod.GenericArguments.Add(paramType);
+                                }
+
+                                return instanceMethod;
                            }
                        }
                    }
@@ -736,11 +811,10 @@ namespace Unity.Netcode.Editor.CodeGen
                foreach (var method in m_FastBufferReader_ExtensionMethodRefs)
                {
                    var parameters = method.Resolve().Parameters;
-                    if (
-                        method.Name == k_ReadValueMethodName
-                        && parameters[1].IsOut
-                        && parameters[1].ParameterType.Resolve() == paramType.MakeByReferenceType().Resolve()
-                        && ((ByReferenceType)parameters[1].ParameterType).ElementType.IsArray == paramType.IsArray)
+                    if (method.Name == k_ReadValueMethodName &&
+                        parameters[1].IsOut &&
+                        parameters[1].ParameterType.Resolve() == paramType.MakeByReferenceType().Resolve() &&
+                        ((ByReferenceType)parameters[1].ParameterType).ElementType.IsArray == paramType.IsArray)
                    {
                        methodRef = method;
                        m_FastBufferReader_ReadValue_MethodRefs[assemblyQualifiedName] = methodRef;
@@ -748,13 +822,7 @@ namespace Unity.Netcode.Editor.CodeGen
                    }
                }

-                // Try NetworkSerializable first because INetworkSerializable may also be valid for ReadValueSafe
-                // and that would cause boxing if so.
-                var typeMethod = GetFastBufferReaderReadMethod("ReadNetworkSerializable", paramType);
-                if (typeMethod == null)
-                {
-                    typeMethod = GetFastBufferReaderReadMethod(k_ReadValueMethodName, paramType);
-                }
+                var typeMethod = GetFastBufferReaderReadMethod(k_ReadValueMethodName, paramType);
                if (typeMethod != null)
                {
                    methodRef = m_MainModule.ImportReference(typeMethod);
@@ -772,8 +840,8 @@ namespace Unity.Netcode.Editor.CodeGen
            var instructions = new List<Instruction>();
            var processor = methodDefinition.Body.GetILProcessor();
            var isServerRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ServerRpcAttribute_FullName;
-            var requireOwnership = true; // default value MUST be = `ServerRpcAttribute.RequireOwnership`
-            var rpcDelivery = RpcDelivery.Reliable; // default value MUST be = `RpcAttribute.Delivery`
+            var requireOwnership = true; // default value MUST be == `ServerRpcAttribute.RequireOwnership`
+            var rpcDelivery = RpcDelivery.Reliable; // default value MUST be == `RpcAttribute.Delivery`
            foreach (var attrField in rpcAttribute.Fields)
            {
                switch (attrField.Name)
@@ -797,9 +865,9 @@ namespace Unity.Netcode.Editor.CodeGen
            // NetworkManager networkManager;
            methodDefinition.Body.Variables.Add(new VariableDefinition(m_NetworkManager_TypeRef));
            int netManLocIdx = methodDefinition.Body.Variables.Count - 1;
-            // NetworkSerializer serializer;
+            // FastBufferWriter bufferWriter;
            methodDefinition.Body.Variables.Add(new VariableDefinition(m_FastBufferWriter_TypeRef));
-            int serializerLocIdx = methodDefinition.Body.Variables.Count - 1;
+            int bufWriterLocIdx = methodDefinition.Body.Variables.Count - 1;

            // XXXRpcParams
            if (!hasRpcParams)
@@ -854,6 +922,8 @@ namespace Unity.Netcode.Editor.CodeGen

                instructions.Add(beginInstr);

+                // var bufferWriter = __beginSendServerRpc(rpcMethodId, serverRpcParams, rpcDelivery) -> ServerRpc
+                // var bufferWriter = __beginSendClientRpc(rpcMethodId, clientRpcParams, rpcDelivery) -> ClientRpc
                if (isServerRpc)
                {
                    // ServerRpc
@@ -867,8 +937,7 @@ namespace Unity.Netcode.Editor.CodeGen
                        instructions.Add(processor.Create(OpCodes.Ldarg_0));
                        instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_getOwnerClientId_MethodRef));
                        instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
-                        instructions.Add(
-                            processor.Create(OpCodes.Callvirt, m_NetworkManager_getLocalClientId_MethodRef));
+                        instructions.Add(processor.Create(OpCodes.Callvirt, m_NetworkManager_getLocalClientId_MethodRef));
                        instructions.Add(processor.Create(OpCodes.Ceq));
                        instructions.Add(processor.Create(OpCodes.Ldc_I4, 0));
                        instructions.Add(processor.Create(OpCodes.Ceq));
@@ -886,8 +955,7 @@ namespace Unity.Netcode.Editor.CodeGen
                        instructions.Add(processor.Create(OpCodes.Brfalse, logNextInstr));

                        // Debug.LogError(...);
-                        instructions.Add(processor.Create(OpCodes.Ldstr,
-                            "Only the owner can invoke a ServerRpc that requires ownership!"));
+                        instructions.Add(processor.Create(OpCodes.Ldstr, "Only the owner can invoke a ServerRpc that requires ownership!"));
                        instructions.Add(processor.Create(OpCodes.Call, m_Debug_LogError_MethodRef));

                        instructions.Add(logNextInstr);
@@ -895,31 +963,86 @@ namespace Unity.Netcode.Editor.CodeGen
                        instructions.Add(roReturnInstr);
                        instructions.Add(roLastInstr);
                    }
+
+                    // var bufferWriter = __beginSendServerRpc(rpcMethodId, serverRpcParams, rpcDelivery);
+                    instructions.Add(processor.Create(OpCodes.Ldarg_0));
+
+                    // rpcMethodId
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, unchecked((int)rpcMethodId)));
+
+                    // rpcParams
+                    instructions.Add(hasRpcParams ? processor.Create(OpCodes.Ldarg, paramCount) : processor.Create(OpCodes.Ldloc, rpcParamsIdx));
+
+                    // rpcDelivery
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)rpcDelivery));
+
+                    // __beginSendServerRpc
+                    instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_beginSendServerRpc_MethodRef));
+                    instructions.Add(processor.Create(OpCodes.Stloc, bufWriterLocIdx));
                }
+                else
+                {
+                    // ClientRpc

-                // var writer = new FastBufferWriter(1285, Allocator.Temp, 63985);
-                instructions.Add(processor.Create(OpCodes.Ldloca, serializerLocIdx));
-                instructions.Add(processor.Create(OpCodes.Ldc_I4, 1300 - sizeof(byte) - sizeof(ulong) - sizeof(uint) - sizeof(ushort)));
-                instructions.Add(processor.Create(OpCodes.Ldc_I4_2));
-                instructions.Add(processor.Create(OpCodes.Ldc_I4, 64000 - sizeof(byte) - sizeof(ulong) - sizeof(uint) - sizeof(ushort)));
-                instructions.Add(processor.Create(OpCodes.Call, m_FastBufferWriter_Constructor));
+                    // var bufferWriter = __beginSendClientRpc(rpcMethodId, clientRpcParams, rpcDelivery);
+                    instructions.Add(processor.Create(OpCodes.Ldarg_0));

-                var firstInstruction = processor.Create(OpCodes.Nop);
-                instructions.Add(firstInstruction);
+                    // rpcMethodId
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, unchecked((int)rpcMethodId)));
+
+                    // rpcParams
+                    instructions.Add(hasRpcParams ? processor.Create(OpCodes.Ldarg, paramCount) : processor.Create(OpCodes.Ldloc, rpcParamsIdx));
+
+                    // rpcDelivery
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)rpcDelivery));
+
+                    // __beginSendClientRpc
+                    instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_beginSendClientRpc_MethodRef));
+                    instructions.Add(processor.Create(OpCodes.Stloc, bufWriterLocIdx));
+                }

                // write method parameters into stream
                for (int paramIndex = 0; paramIndex < paramCount; ++paramIndex)
                {
                    var paramDef = methodDefinition.Parameters[paramIndex];
                    var paramType = paramDef.ParameterType;
-                    // ServerRpcParams
-                    if (paramType.FullName == CodeGenHelpers.ServerRpcParams_FullName && isServerRpc && paramIndex == paramCount - 1)
+                    if (paramType.FullName == CodeGenHelpers.ClientRpcSendParams_FullName ||
+                        paramType.FullName == CodeGenHelpers.ClientRpcReceiveParams_FullName)
                    {
+                        m_Diagnostics.AddError($"Rpcs may not accept {paramType.FullName} as a parameter. Use {nameof(ClientRpcParams)} instead.");
+                        continue;
+                    }
+
+                    if (paramType.FullName == CodeGenHelpers.ServerRpcSendParams_FullName ||
+                        paramType.FullName == CodeGenHelpers.ServerRpcReceiveParams_FullName)
+                    {
+                        m_Diagnostics.AddError($"Rpcs may not accept {paramType.FullName} as a parameter. Use {nameof(ServerRpcParams)} instead.");
+                        continue;
+                    }
+                    // ServerRpcParams
+                    if (paramType.FullName == CodeGenHelpers.ServerRpcParams_FullName)
+                    {
+                        if (paramIndex != paramCount - 1)
+                        {
+                            m_Diagnostics.AddError(methodDefinition, $"{nameof(ServerRpcParams)} must be the last parameter in a ServerRpc.");
+                        }
+                        if (!isServerRpc)
+                        {
+                            m_Diagnostics.AddError($"ClientRpcs may not accept {nameof(ServerRpcParams)} as a parameter.");
+                        }
                        continue;
                    }
                    // ClientRpcParams
-                    if (paramType.FullName == CodeGenHelpers.ClientRpcParams_FullName && !isServerRpc && paramIndex == paramCount - 1)
+                    if (paramType.FullName == CodeGenHelpers.ClientRpcParams_FullName)
                    {
+                        if (paramIndex != paramCount - 1)
+                        {
+                            m_Diagnostics.AddError(methodDefinition, $"{nameof(ClientRpcParams)} must be the last parameter in a ClientRpc.");
+                        }
+                        if (isServerRpc)
+                        {
+                            m_Diagnostics.AddError($"ServerRpcs may not accept {nameof(ClientRpcParams)} as a parameter.");
+                        }
                        continue;
                    }

@@ -942,9 +1065,20 @@ namespace Unity.Netcode.Editor.CodeGen
                        instructions.Add(processor.Create(OpCodes.Cgt_Un));
                        instructions.Add(processor.Create(OpCodes.Stloc, isSetLocalIndex));

-                        // writer.WriteValueSafe(isSet);
-                        instructions.Add(processor.Create(OpCodes.Ldloca, serializerLocIdx));
+                        // bufferWriter.WriteValueSafe(isSet);
+                        instructions.Add(processor.Create(OpCodes.Ldloca, bufWriterLocIdx));
                        instructions.Add(processor.Create(OpCodes.Ldloca, isSetLocalIndex));
+
+                        for (var i = 1; i < boolMethodRef.Parameters.Count; ++i)
+                        {
+                            var param = boolMethodRef.Parameters[i];
+                            methodDefinition.Body.Variables.Add(new VariableDefinition(param.ParameterType));
+                            int overloadParamLocalIdx = methodDefinition.Body.Variables.Count - 1;
+                            instructions.Add(processor.Create(OpCodes.Ldloca, overloadParamLocalIdx));
+                            instructions.Add(processor.Create(OpCodes.Initobj, param.ParameterType));
+                            instructions.Add(processor.Create(OpCodes.Ldloc, overloadParamLocalIdx));
+                        }
+
                        instructions.Add(processor.Create(OpCodes.Call, boolMethodRef));

                        // if(isSet) {
@@ -956,11 +1090,11 @@ namespace Unity.Netcode.Editor.CodeGen
                    var foundMethodRef = GetWriteMethodForParameter(paramType, out var methodRef);
                    if (foundMethodRef)
                    {
-                        // writer.WriteNetworkSerializable(param) for INetworkSerializable, OR
-                        // writer.WriteNetworkSerializable(param, -1, 0) for INetworkSerializable arrays, OR
-                        // writer.WriteValueSafe(param) for value types, OR
-                        // writer.WriteValueSafe(param, -1, 0) for arrays of value types, OR
-                        // writer.WriteValueSafe(param, false) for strings
+                        // bufferWriter.WriteNetworkSerializable(param) for INetworkSerializable, OR
+                        // bufferWriter.WriteNetworkSerializable(param, -1, 0) for INetworkSerializable arrays, OR
+                        // bufferWriter.WriteValueSafe(param) for value types, OR
+                        // bufferWriter.WriteValueSafe(param, -1, 0) for arrays of value types, OR
+                        // bufferWriter.WriteValueSafe(param, false) for strings
                        var method = methodRef.Resolve();
                        var checkParameter = method.Parameters[0];
                        var isExtensionMethod = false;
@@ -971,11 +1105,11 @@ namespace Unity.Netcode.Editor.CodeGen
                        }
                        if (!isExtensionMethod || method.Parameters[0].ParameterType.IsByReference)
                        {
-                            instructions.Add(processor.Create(OpCodes.Ldloca, serializerLocIdx));
+                            instructions.Add(processor.Create(OpCodes.Ldloca, bufWriterLocIdx));
                        }
                        else
                        {
-                            instructions.Add(processor.Create(OpCodes.Ldloc, serializerLocIdx));
+                            instructions.Add(processor.Create(OpCodes.Ldloc, bufWriterLocIdx));
                        }
                        if (checkParameter.IsIn || checkParameter.IsOut || checkParameter.ParameterType.IsByReference)
                        {
@@ -986,24 +1120,49 @@ namespace Unity.Netcode.Editor.CodeGen
                            instructions.Add(processor.Create(OpCodes.Ldarg, paramIndex + 1));
                        }
                        // Special handling for WriteValue() on arrays and strings since they have additional arguments.
-                        if (paramType.IsArray
-                            && ((!isExtensionMethod && methodRef.Parameters.Count == 3)
-                                || (isExtensionMethod && methodRef.Parameters.Count == 4)))
+                        if (paramType.IsArray && ((!isExtensionMethod && methodRef.Parameters.Count == 3) ||
+                            (isExtensionMethod && methodRef.Parameters.Count == 4)))
                        {
                            instructions.Add(processor.Create(OpCodes.Ldc_I4_M1));
                            instructions.Add(processor.Create(OpCodes.Ldc_I4_0));
                        }
-                        else if (paramType == typeSystem.String
-                             && ((!isExtensionMethod && methodRef.Parameters.Count == 2)
-                                 || (isExtensionMethod && methodRef.Parameters.Count == 3)))
+                        else if (paramType == typeSystem.String && ((!isExtensionMethod && methodRef.Parameters.Count == 2) ||
+                            (isExtensionMethod && methodRef.Parameters.Count == 3)))
                        {
                            instructions.Add(processor.Create(OpCodes.Ldc_I4_0));
                        }
+                        else
+                        {
+                            if (isExtensionMethod && methodRef.Parameters.Count > 2)
+                            {
+                                for (var i = 2; i < methodRef.Parameters.Count; ++i)
+                                {
+                                    var param = methodRef.Parameters[i];
+                                    methodDefinition.Body.Variables.Add(new VariableDefinition(param.ParameterType));
+                                    int overloadParamLocalIdx = methodDefinition.Body.Variables.Count - 1;
+                                    instructions.Add(processor.Create(OpCodes.Ldloca, overloadParamLocalIdx));
+                                    instructions.Add(processor.Create(OpCodes.Initobj, param.ParameterType));
+                                    instructions.Add(processor.Create(OpCodes.Ldloc, overloadParamLocalIdx));
+                                }
+                            }
+                            else if (!isExtensionMethod && methodRef.Parameters.Count > 1)
+                            {
+                                for (var i = 1; i < methodRef.Parameters.Count; ++i)
+                                {
+                                    var param = methodRef.Parameters[i];
+                                    methodDefinition.Body.Variables.Add(new VariableDefinition(param.ParameterType));
+                                    int overloadParamLocalIdx = methodDefinition.Body.Variables.Count - 1;
+                                    instructions.Add(processor.Create(OpCodes.Ldloca, overloadParamLocalIdx));
+                                    instructions.Add(processor.Create(OpCodes.Initobj, param.ParameterType));
+                                    instructions.Add(processor.Create(OpCodes.Ldloc, overloadParamLocalIdx));
+                                }
+                            }
+                        }
                        instructions.Add(processor.Create(OpCodes.Call, methodRef));
                    }
                    else
                    {
-                        m_Diagnostics.AddError(methodDefinition, $"Don't know how to serialize {paramType.Name} - implement {nameof(INetworkSerializable)} or add an extension method for {nameof(FastBufferWriter)}.{k_WriteValueMethodName} to define serialization.");
+                        m_Diagnostics.AddError(methodDefinition, $"{methodDefinition.Name} - Don't know how to serialize {paramType.Name}. RPC parameter types must either implement {nameof(INetworkSerializeByMemcpy)} or {nameof(INetworkSerializable)}. If this type is external and you are sure its memory layout makes it serializable by memcpy, you can replace {paramType} with {typeof(ForceNetworkSerializeByMemcpy<>).Name}<{paramType}>, or you can create extension methods for {nameof(FastBufferReader)}.{nameof(FastBufferReader.ReadValueSafe)}(this {nameof(FastBufferReader)}, out {paramType}) and {nameof(FastBufferWriter)}.{nameof(FastBufferWriter.WriteValueSafe)}(this {nameof(FastBufferWriter)}, in {paramType}) to define serialization for this type.");
                        continue;
                    }

@@ -1015,20 +1174,20 @@ namespace Unity.Netcode.Editor.CodeGen

                instructions.Add(endInstr);

-                // __sendServerRpc(ref serializer, rpcMethodId, serverRpcParams, rpcDelivery) -> ServerRpc
-                // __sendClientRpc(ref serializer, rpcMethodId, clientRpcParams, rpcDelivery) -> ClientRpc
+                // __endSendServerRpc(ref bufferWriter, rpcMethodId, serverRpcParams, rpcDelivery) -> ServerRpc
+                // __endSendClientRpc(ref bufferWriter, rpcMethodId, clientRpcParams, rpcDelivery) -> ClientRpc
                if (isServerRpc)
                {
                    // ServerRpc
-                    // __sendServerRpc(ref serializer, rpcMethodId, serverRpcParams, rpcDelivery);
+
+                    // __endSendServerRpc(ref bufferWriter, rpcMethodId, serverRpcParams, rpcDelivery);
                    instructions.Add(processor.Create(OpCodes.Ldarg_0));

-                    // serializer
-                    instructions.Add(processor.Create(OpCodes.Ldloc, serializerLocIdx));
+                    // bufferWriter
+                    instructions.Add(processor.Create(OpCodes.Ldloca, bufWriterLocIdx));

                    // rpcMethodId
                    instructions.Add(processor.Create(OpCodes.Ldc_I4, unchecked((int)rpcMethodId)));
-
                    if (hasRpcParams)
                    {
                        // rpcParams
@@ -1039,25 +1198,24 @@ namespace Unity.Netcode.Editor.CodeGen
                        // default
                        instructions.Add(processor.Create(OpCodes.Ldloc, rpcParamsIdx));
                    }
-
                    // rpcDelivery
                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)rpcDelivery));

-                    // EndSendServerRpc
-                    instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_SendServerRpc_MethodRef));
+                    // __endSendServerRpc
+                    instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_endSendServerRpc_MethodRef));
                }
                else
                {
                    // ClientRpc
-                    // __sendClientRpc(ref serializer, rpcMethodId, clientRpcParams, rpcDelivery);
+
+                    // __endSendClientRpc(ref bufferWriter, rpcMethodId, clientRpcParams, rpcDelivery);
                    instructions.Add(processor.Create(OpCodes.Ldarg_0));

-                    // serializer
-                    instructions.Add(processor.Create(OpCodes.Ldloc, serializerLocIdx));
+                    // bufferWriter
+                    instructions.Add(processor.Create(OpCodes.Ldloca, bufWriterLocIdx));

                    // rpcMethodId
                    instructions.Add(processor.Create(OpCodes.Ldc_I4, unchecked((int)rpcMethodId)));
-
                    if (hasRpcParams)
                    {
                        // rpcParams
@@ -1068,36 +1226,11 @@ namespace Unity.Netcode.Editor.CodeGen
                        // default
                        instructions.Add(processor.Create(OpCodes.Ldloc, rpcParamsIdx));
                    }
-
                    // rpcDelivery
                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)rpcDelivery));

-                    // EndSendClientRpc
-                    instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_SendClientRpc_MethodRef));
-                }
-
-                {
-                    // TODO: Figure out why try/catch here cause the try block not to execute at all.
-                    // End try block
-                    //instructions.Add(processor.Create(OpCodes.Leave, lastInstr));
-
-                    // writer.Dispose();
-                    var handlerFirst = processor.Create(OpCodes.Ldloca, serializerLocIdx);
-                    instructions.Add(handlerFirst);
-                    instructions.Add(processor.Create(OpCodes.Call, m_FastBufferWriter_Dispose));
-
-                    // End finally block
-                    //instructions.Add(processor.Create(OpCodes.Endfinally));
-
-                    // try { ... serialization code ... } finally { writer.Dispose(); }
-                    /*var handler = new ExceptionHandler(ExceptionHandlerType.Finally)
-                    {
-                        TryStart = firstInstruction,
-                        TryEnd = handlerFirst,
-                        HandlerStart = handlerFirst,
-                        HandlerEnd = lastInstr
-                    };
-                    processor.Body.ExceptionHandlers.Add(handler);*/
+                    // __endSendClientRpc
+                    instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_endSendClientRpc_MethodRef));
                }

                instructions.Add(lastInstr);
@@ -1132,25 +1265,21 @@ namespace Unity.Netcode.Editor.CodeGen
            instructions.ForEach(instruction => processor.Body.Instructions.Insert(0, instruction));
        }

-        private MethodDefinition GenerateStaticHandler(MethodDefinition methodDefinition, CustomAttribute rpcAttribute)
+        private MethodDefinition GenerateStaticHandler(MethodDefinition methodDefinition, CustomAttribute rpcAttribute, uint rpcMethodId)
        {
            var typeSystem = methodDefinition.Module.TypeSystem;
-            var nhandler = new MethodDefinition(
-                $"{methodDefinition.Name}__nhandler",
+            var rpcHandler = new MethodDefinition(
+                $"__rpc_handler_{rpcMethodId}",
                MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.HideBySig,
                methodDefinition.Module.TypeSystem.Void);
-            nhandler.Parameters.Add(new ParameterDefinition("target", ParameterAttributes.None, m_NetworkBehaviour_TypeRef));
-            nhandler.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, m_FastBufferReader_TypeRef));
-            nhandler.Parameters.Add(new ParameterDefinition("rpcParams", ParameterAttributes.None, m_RpcParams_TypeRef));
+            rpcHandler.Parameters.Add(new ParameterDefinition("target", ParameterAttributes.None, m_NetworkBehaviour_TypeRef));
+            rpcHandler.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, m_FastBufferReader_TypeRef));
+            rpcHandler.Parameters.Add(new ParameterDefinition("rpcParams", ParameterAttributes.None, m_RpcParams_TypeRef));

-            var processor = nhandler.Body.GetILProcessor();
-
-            // begin Try/Catch
-            var tryStart = processor.Create(OpCodes.Nop);
-            processor.Append(tryStart);
+            var processor = rpcHandler.Body.GetILProcessor();

            var isServerRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ServerRpcAttribute_FullName;
-            var requireOwnership = true; // default value MUST be = `ServerRpcAttribute.RequireOwnership`
+            var requireOwnership = true; // default value MUST be == `ServerRpcAttribute.RequireOwnership`
            foreach (var attrField in rpcAttribute.Fields)
            {
                switch (attrField.Name)
@@ -1161,10 +1290,10 @@ namespace Unity.Netcode.Editor.CodeGen
                }
            }

-            nhandler.Body.InitLocals = true;
+            rpcHandler.Body.InitLocals = true;
            // NetworkManager networkManager;
-            nhandler.Body.Variables.Add(new VariableDefinition(m_NetworkManager_TypeRef));
-            int netManLocIdx = nhandler.Body.Variables.Count - 1;
+            rpcHandler.Body.Variables.Add(new VariableDefinition(m_NetworkManager_TypeRef));
+            int netManLocIdx = rpcHandler.Body.Variables.Count - 1;

            {
                var returnInstr = processor.Create(OpCodes.Ret);
@@ -1233,8 +1362,8 @@ namespace Unity.Netcode.Editor.CodeGen
                var paramType = paramDef.ParameterType;

                // local variable
-                nhandler.Body.Variables.Add(new VariableDefinition(paramType));
-                int localIndex = nhandler.Body.Variables.Count - 1;
+                rpcHandler.Body.Variables.Add(new VariableDefinition(paramType));
+                int localIndex = rpcHandler.Body.Variables.Count - 1;
                paramLocalMap[paramIndex] = localIndex;

                // ServerRpcParams, ClientRpcParams
@@ -1268,10 +1397,21 @@ namespace Unity.Netcode.Editor.CodeGen
                    }

                    // reader.ReadValueSafe(out bool isSet)
-                    nhandler.Body.Variables.Add(new VariableDefinition(typeSystem.Boolean));
-                    int isSetLocalIndex = nhandler.Body.Variables.Count - 1;
+                    rpcHandler.Body.Variables.Add(new VariableDefinition(typeSystem.Boolean));
+                    int isSetLocalIndex = rpcHandler.Body.Variables.Count - 1;
                    processor.Emit(OpCodes.Ldarga, 1);
                    processor.Emit(OpCodes.Ldloca, isSetLocalIndex);
+
+                    for (var i = 1; i < boolMethodRef.Parameters.Count; ++i)
+                    {
+                        var param = boolMethodRef.Parameters[i];
+                        rpcHandler.Body.Variables.Add(new VariableDefinition(param.ParameterType));
+                        int overloadParamLocalIdx = rpcHandler.Body.Variables.Count - 1;
+                        processor.Emit(OpCodes.Ldloca, overloadParamLocalIdx);
+                        processor.Emit(OpCodes.Initobj, param.ParameterType);
+                        processor.Emit(OpCodes.Ldloc, overloadParamLocalIdx);
+                    }
+
                    processor.Emit(OpCodes.Call, boolMethodRef);

                    // paramType param = null;
@@ -1305,11 +1445,38 @@ namespace Unity.Netcode.Editor.CodeGen
                    {
                        processor.Emit(OpCodes.Ldc_I4_0);
                    }
+                    else
+                    {
+                        if (isExtensionMethod && methodRef.Parameters.Count > 2)
+                        {
+                            for (var i = 2; i < methodRef.Parameters.Count; ++i)
+                            {
+                                var param = methodRef.Parameters[i];
+                                rpcHandler.Body.Variables.Add(new VariableDefinition(param.ParameterType));
+                                int overloadParamLocalIdx = rpcHandler.Body.Variables.Count - 1;
+                                processor.Emit(OpCodes.Ldloca, overloadParamLocalIdx);
+                                processor.Emit(OpCodes.Initobj, param.ParameterType);
+                                processor.Emit(OpCodes.Ldloc, overloadParamLocalIdx);
+                            }
+                        }
+                        else if (!isExtensionMethod && methodRef.Parameters.Count > 1)
+                        {
+                            for (var i = 1; i < methodRef.Parameters.Count; ++i)
+                            {
+                                var param = methodRef.Parameters[i];
+                                rpcHandler.Body.Variables.Add(new VariableDefinition(param.ParameterType));
+                                int overloadParamLocalIdx = rpcHandler.Body.Variables.Count - 1;
+                                processor.Emit(OpCodes.Ldloca, overloadParamLocalIdx);
+                                processor.Emit(OpCodes.Initobj, param.ParameterType);
+                                processor.Emit(OpCodes.Ldloc, overloadParamLocalIdx);
+                            }
+                        }
+                    }
                    processor.Emit(OpCodes.Call, methodRef);
                }
                else
                {
-                    m_Diagnostics.AddError(methodDefinition, $"Don't know how to deserialize {paramType.Name} - implement {nameof(INetworkSerializable)} or add an extension method for {nameof(FastBufferReader)}.{k_ReadValueMethodName} to define serialization.");
+                    m_Diagnostics.AddError(methodDefinition, $"{methodDefinition.Name} - Don't know how to serialize {paramType.Name}. RPC parameter types must either implement {nameof(INetworkSerializeByMemcpy)} or {nameof(INetworkSerializable)}. If this type is external and you are sure its memory layout makes it serializable by memcpy, you can replace {paramType} with {typeof(ForceNetworkSerializeByMemcpy<>).Name}<{paramType}>, or you can create extension methods for {nameof(FastBufferReader)}.{nameof(FastBufferReader.ReadValueSafe)}(this {nameof(FastBufferReader)}, out {paramType}) and {nameof(FastBufferWriter)}.{nameof(FastBufferWriter.WriteValueSafe)}(this {nameof(FastBufferWriter)}, in {paramType}) to define serialization for this type.");
                    continue;
                }

@@ -1336,55 +1503,8 @@ namespace Unity.Netcode.Editor.CodeGen
            processor.Emit(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.None);
            processor.Emit(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef);

-            // pull in the Exception Module
-            var exception = m_MainModule.ImportReference(typeof(Exception));
-
-            // Get Exception.ToString()
-            var exp = m_MainModule.ImportReference(typeof(Exception).GetMethod("ToString", new Type[] { }));
-
-            // Get String.Format (This is equivalent to an interpolated string)
-            var stringFormat = m_MainModule.ImportReference(typeof(string).GetMethod("Format", new Type[] { typeof(string), typeof(object) }));
-
-            nhandler.Body.Variables.Add(new VariableDefinition(exception));
-            int exceptionVariableIndex = nhandler.Body.Variables.Count - 1;
-
-            //try ends/catch begins
-            var catchEnds = processor.Create(OpCodes.Nop);
-            processor.Emit(OpCodes.Leave, catchEnds);
-
-            // Load the Exception onto the stack
-            var catchStarts = processor.Create(OpCodes.Stloc, exceptionVariableIndex);
-            processor.Append(catchStarts);
-
-            // Load string for the error log that will be shown
-            processor.Emit(OpCodes.Ldstr, $"Unhandled RPC Exception:\n {{0}}");
-            processor.Emit(OpCodes.Ldloc, exceptionVariableIndex);
-            processor.Emit(OpCodes.Callvirt, exp);
-            processor.Emit(OpCodes.Call, stringFormat);
-
-            // Call Debug.LogError
-            processor.Emit(OpCodes.Call, m_Debug_LogError_MethodRef);
-
-            // reset NetworkBehaviour.__rpc_exec_stage = __RpcExecStage.None;
-            processor.Emit(OpCodes.Ldarg_0);
-            processor.Emit(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.None);
-            processor.Emit(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef);
-
-            // catch ends
-            processor.Append(catchEnds);
-
-            processor.Body.ExceptionHandlers.Add(new ExceptionHandler(ExceptionHandlerType.Catch)
-            {
-                CatchType = exception,
-                TryStart = tryStart,
-                TryEnd = catchStarts,
-                HandlerStart = catchStarts,
-                HandlerEnd = catchEnds
-            });
-
            processor.Emit(OpCodes.Ret);
-
-            return nhandler;
+            return rpcHandler;
        }
    }
 }
--- a/Editor/CodeGen/RuntimeAccessModifiersILPP.cs
+++ b/Editor/CodeGen/RuntimeAccessModifiersILPP.cs
@@ -52,9 +52,6 @@ namespace Unity.Netcode.Editor.CodeGen
                        case nameof(NetworkBehaviour):
                            ProcessNetworkBehaviour(typeDefinition);
                            break;
-                        case nameof(NetworkVariableHelper):
-                            ProcessNetworkVariableHelper(typeDefinition);
-                            break;
                        case nameof(__RpcParams):
                            typeDefinition.IsPublic = true;
                            break;
@@ -103,17 +100,6 @@ namespace Unity.Netcode.Editor.CodeGen
            }
        }

-        private void ProcessNetworkVariableHelper(TypeDefinition typeDefinition)
-        {
-            foreach (var methodDefinition in typeDefinition.Methods)
-            {
-                if (methodDefinition.Name == nameof(NetworkVariableHelper.InitializeDelegates))
-                {
-                    methodDefinition.IsPublic = true;
-                }
-            }
-        }
-
        private void ProcessNetworkBehaviour(TypeDefinition typeDefinition)
        {
            foreach (var nestedType in typeDefinition.NestedTypes)
@@ -134,8 +120,10 @@ namespace Unity.Netcode.Editor.CodeGen

            foreach (var methodDefinition in typeDefinition.Methods)
            {
-                if (methodDefinition.Name == nameof(NetworkBehaviour.__sendServerRpc)
-                    || methodDefinition.Name == nameof(NetworkBehaviour.__sendClientRpc))
+                if (methodDefinition.Name == nameof(NetworkBehaviour.__beginSendServerRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__endSendServerRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__beginSendClientRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__endSendClientRpc))
                {
                    methodDefinition.IsFamily = true;
                }
--- a/Editor/CodeGen/com.unity.netcode.editor.codegen.asmdef
+++ b/Editor/CodeGen/com.unity.netcode.editor.codegen.asmdef
@@ -2,11 +2,13 @@
    "name": "Unity.Netcode.Editor.CodeGen",
    "rootNamespace": "Unity.Netcode.Editor.CodeGen",
    "references": [
-        "Unity.Netcode.Runtime"
+        "Unity.Netcode.Runtime",
+        "Unity.Collections"
    ],
    "includePlatforms": [
        "Editor"
    ],
+    "excludePlatforms": [],
    "allowUnsafeCode": true,
    "overrideReferences": true,
    "precompiledReferences": [
@@ -15,5 +17,14 @@
        "Mono.Cecil.Pdb.dll",
        "Mono.Cecil.Rocks.dll"
    ],
-    "autoReferenced": false
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.nuget.mono-cecil",
+            "expression": "(0,1.11.4)",
+            "define": "CECIL_CONSTRAINTS_ARE_TYPE_REFERENCES"
+        }
+    ],
+    "noEngineReferences": false
 }
--- a/Editor/DontShowInTransportDropdownAttribute.cs
+++ b/Editor/DontShowInTransportDropdownAttribute.cs
@@ -1,8 +0,0 @@
-using System;
-
-namespace Unity.Netcode.Editor
-{
-    public class DontShowInTransportDropdownAttribute : Attribute
-    {
-    }
-}
--- a/Editor/DontShowInTransportDropdownAttribute.cs.meta
+++ b/Editor/DontShowInTransportDropdownAttribute.cs.meta
@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: 5f097067d4254dc7ad018d7ad90df7c3
-timeCreated: 1620386886
--- a/Editor/NetworkAnimatorEditor.cs
+++ b/Editor/NetworkAnimatorEditor.cs
@@ -1,103 +0,0 @@
-using System;
-using Unity.Netcode.Components;
-using UnityEditor;
-using UnityEditor.Animations;
-using UnityEngine;
-
-namespace Unity.Netcode.Editor
-{
-    public static class TextUtility
-    {
-        public static GUIContent TextContent(string name, string tooltip)
-        {
-            var newContent = new GUIContent(name);
-            newContent.tooltip = tooltip;
-            return newContent;
-        }
-
-        public static GUIContent TextContent(string name)
-        {
-            return new GUIContent(name);
-        }
-    }
-
-    [CustomEditor(typeof(NetworkAnimator), true)]
-    [CanEditMultipleObjects]
-    public class NetworkAnimatorEditor : UnityEditor.Editor
-    {
-        private NetworkAnimator m_AnimSync;
-        [NonSerialized] private bool m_Initialized;
-        private SerializedProperty m_AnimatorProperty;
-        private GUIContent m_AnimatorLabel;
-
-        private void Init()
-        {
-            if (m_Initialized)
-            {
-                return;
-            }
-
-            m_Initialized = true;
-            m_AnimSync = target as NetworkAnimator;
-
-            m_AnimatorProperty = serializedObject.FindProperty("m_Animator");
-            m_AnimatorLabel = TextUtility.TextContent("Animator", "The Animator component to synchronize.");
-        }
-
-        public override void OnInspectorGUI()
-        {
-            Init();
-            serializedObject.Update();
-            DrawControls();
-            serializedObject.ApplyModifiedProperties();
-        }
-
-        private void DrawControls()
-        {
-            EditorGUI.BeginChangeCheck();
-            EditorGUILayout.PropertyField(m_AnimatorProperty, m_AnimatorLabel);
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_AnimSync.ResetParameterOptions();
-            }
-
-            if (m_AnimSync.Animator == null)
-            {
-                return;
-            }
-
-            var controller = m_AnimSync.Animator.runtimeAnimatorController as AnimatorController;
-            if (controller != null)
-            {
-                var showWarning = false;
-                EditorGUI.indentLevel += 1;
-                int i = 0;
-
-                foreach (var p in controller.parameters)
-                {
-                    if (i >= NetworkAnimator.K_MaxAnimationParams)
-                    {
-                        showWarning = true;
-                        break;
-                    }
-
-                    bool oldSend = m_AnimSync.GetParameterAutoSend(i);
-                    bool send = EditorGUILayout.Toggle(p.name, oldSend);
-                    if (send != oldSend)
-                    {
-                        m_AnimSync.SetParameterAutoSend(i, send);
-                        EditorUtility.SetDirty(target);
-                    }
-                    i += 1;
-                }
-
-                if (showWarning)
-                {
-                    EditorGUILayout.HelpBox($"NetworkAnimator can only select between the first {NetworkAnimator.K_MaxAnimationParams} parameters in a mecanim controller", MessageType.Warning);
-                }
-
-                EditorGUI.indentLevel -= 1;
-            }
-        }
-    }
-}
--- a/Editor/NetworkBehaviourEditor.cs
+++ b/Editor/NetworkBehaviourEditor.cs
@@ -211,5 +211,129 @@ namespace Unity.Netcode.Editor
            serializedObject.ApplyModifiedProperties();
            EditorGUI.EndChangeCheck();
        }
+
+        /// <summary>
+        /// Invoked once when a NetworkBehaviour component is
+        /// displayed in the inspector view.
+        /// </summary>
+        private void OnEnable()
+        {
+            // This can be null and throw an exception when running test runner in the editor
+            if (target == null)
+            {
+                return;
+            }
+            // When we first add a NetworkBehaviour this editor will be enabled
+            // so we go ahead and check for an already existing NetworkObject here
+            CheckForNetworkObject((target as NetworkBehaviour).gameObject);
+        }
+
+        internal const string AutoAddNetworkObjectIfNoneExists = "AutoAdd-NetworkObject-When-None-Exist";
+
+        public static Transform GetRootParentTransform(Transform transform)
+        {
+            if (transform.parent == null || transform.parent == transform)
+            {
+                return transform;
+            }
+            return GetRootParentTransform(transform.parent);
+        }
+
+        /// <summary>
+        /// Used to determine if a GameObject has one or more NetworkBehaviours but
+        /// does not already have a NetworkObject component.  If not it will notify
+        /// the user that NetworkBehaviours require a NetworkObject.
+        /// </summary>
+        public static void CheckForNetworkObject(GameObject gameObject, bool networkObjectRemoved = false)
+        {
+            // If there are no NetworkBehaviours or no gameObject, then exit early
+            if (gameObject == null || (gameObject.GetComponent<NetworkBehaviour>() == null && gameObject.GetComponentInChildren<NetworkBehaviour>() == null))
+            {
+                return;
+            }
+
+            // Now get the root parent transform to the current GameObject (or itself)
+            var rootTransform = GetRootParentTransform(gameObject.transform);
+            var networkManager = rootTransform.GetComponent<NetworkManager>();
+            if (networkManager == null)
+            {
+                networkManager = rootTransform.GetComponentInChildren<NetworkManager>();
+            }
+
+            // If there is a NetworkManager, then notify the user that a NetworkManager cannot have NetworkBehaviour components
+            if (networkManager != null)
+            {
+                var networkBehaviours = networkManager.gameObject.GetComponents<NetworkBehaviour>();
+                var networkBehavioursChildren = networkManager.gameObject.GetComponentsInChildren<NetworkBehaviour>();
+                if (networkBehaviours.Length > 0 || networkBehavioursChildren.Length > 0)
+                {
+                    if (EditorUtility.DisplayDialog("NetworkBehaviour or NetworkManager Cannot Be Added", $"{nameof(NetworkManager)}s cannot have {nameof(NetworkBehaviour)} components added to the root parent or any of its children." +
+                        $" Would you like to remove the NetworkManager or NetworkBehaviour?", "NetworkManager", "NetworkBehaviour"))
+                    {
+                        DestroyImmediate(networkManager);
+                    }
+                    else
+                    {
+                        foreach (var networkBehaviour in networkBehaviours)
+                        {
+                            DestroyImmediate(networkBehaviour);
+                        }
+
+                        foreach (var networkBehaviour in networkBehaviours)
+                        {
+                            DestroyImmediate(networkBehaviour);
+                        }
+                    }
+                    return;
+                }
+            }
+
+            // Otherwise, check to see if there is any NetworkObject from the root GameObject down to all children.
+            // If not, notify the user that NetworkBehaviours require that the relative GameObject has a NetworkObject component.
+            var networkObject = rootTransform.GetComponent<NetworkObject>();
+            if (networkObject == null)
+            {
+                networkObject = rootTransform.GetComponentInChildren<NetworkObject>();
+
+                if (networkObject == null)
+                {
+                    // If we are removing a NetworkObject but there is still one or more NetworkBehaviour components
+                    // and the user has already turned "Auto-Add NetworkObject" on when first notified about the requirement
+                    // then just send a reminder to the user why the NetworkObject they just deleted seemingly "re-appeared"
+                    // again.
+                    if (networkObjectRemoved && EditorPrefs.HasKey(AutoAddNetworkObjectIfNoneExists) && EditorPrefs.GetBool(AutoAddNetworkObjectIfNoneExists))
+                    {
+                        Debug.LogWarning($"{gameObject.name} still has {nameof(NetworkBehaviour)}s and Auto-Add NetworkObjects is enabled. A NetworkObject is being added back to {gameObject.name}.");
+                        Debug.Log($"To reset Auto-Add NetworkObjects: Select the Netcode->General->Reset Auto-Add NetworkObject menu item.");
+                    }
+
+                    // Notify and provide the option to add it one time, always add a NetworkObject, or do nothing and let the user manually add it
+                    if (EditorUtility.DisplayDialog($"{nameof(NetworkBehaviour)}s require a {nameof(NetworkObject)}",
+                    $"{gameObject.name} does not have a {nameof(NetworkObject)} component.  Would you like to add one now?", "Yes", "No (manually add it)",
+                    DialogOptOutDecisionType.ForThisMachine, AutoAddNetworkObjectIfNoneExists))
+                    {
+                        gameObject.AddComponent<NetworkObject>();
+                        var activeScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
+                        UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(activeScene);
+                        UnityEditor.SceneManagement.EditorSceneManager.SaveScene(activeScene);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// This allows users to reset the Auto-Add NetworkObject preference
+        /// so the next time they add a NetworkBehaviour to a GameObject without
+        /// a NetworkObject it will display the dialog box again and not
+        /// automatically add a NetworkObject.
+        /// </summary>
+        [MenuItem("Netcode/General/Reset Auto-Add NetworkObject", false, 1)]
+        private static void ResetMultiplayerToolsTipStatus()
+        {
+            if (EditorPrefs.HasKey(AutoAddNetworkObjectIfNoneExists))
+            {
+                EditorPrefs.SetBool(AutoAddNetworkObjectIfNoneExists, false);
+            }
+        }
    }
 }
--- a/Editor/NetworkManagerEditor.cs
+++ b/Editor/NetworkManagerEditor.cs
@@ -57,7 +57,7 @@ namespace Unity.Netcode.Editor

                foreach (var type in types)
                {
-                    if (type.IsSubclassOf(typeof(NetworkTransport)) && type.GetCustomAttributes(typeof(DontShowInTransportDropdownAttribute), true).Length == 0)
+                    if (type.IsSubclassOf(typeof(NetworkTransport)) && !type.IsSubclassOf(typeof(TestingNetworkTransport)) && type != typeof(TestingNetworkTransport))
                    {
                        m_TransportTypes.Add(type);
                    }
@@ -134,10 +134,14 @@ namespace Unity.Netcode.Editor
        {
            m_NetworkPrefabsList = new ReorderableList(serializedObject, serializedObject.FindProperty(nameof(NetworkManager.NetworkConfig)).FindPropertyRelative(nameof(NetworkConfig.NetworkPrefabs)), true, true, true, true);
            m_NetworkPrefabsList.elementHeightCallback = index =>
+            {
+                var networkOverrideInt = 0;
+                if (m_NetworkPrefabsList.count > 0)
                {
                    var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
                    var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
-                var networkOverrideInt = networkOverrideProp.enumValueIndex;
+                    networkOverrideInt = networkOverrideProp.enumValueIndex;
+                }

                return 8 + (networkOverrideInt == 0 ? EditorGUIUtility.singleLineHeight : (EditorGUIUtility.singleLineHeight * 2) + 5);
            };
@@ -359,7 +363,7 @@ namespace Unity.Netcode.Editor
            const string getToolsText = "Access additional tools for multiplayer development by installing the Multiplayer Tools package in the Package Manager.";
            const string openDocsButtonText = "Open Docs";
            const string dismissButtonText = "Dismiss";
-            const string targetUrl = "https://docs-multiplayer.unity3d.com/docs/tools/install-tools";
+            const string targetUrl = "https://docs-multiplayer.unity3d.com/netcode/current/tools/install-tools";
            const string infoIconName = "console.infoicon";

            if (PlayerPrefs.GetInt(InstallMultiplayerToolsTipDismissedPlayerPrefKey, 0) != 0)
--- a/Editor/NetworkManagerHelper.cs
+++ b/Editor/NetworkManagerHelper.cs
@@ -1,5 +1,7 @@
 using System.Collections.Generic;
+using System.Linq;
 using UnityEngine;
+using UnityEngine.SceneManagement;
 using UnityEditor;

 namespace Unity.Netcode.Editor
@@ -12,7 +14,7 @@ namespace Unity.Netcode.Editor
    {
        internal static NetworkManagerHelper Singleton;

-        // This is primarily to handle multiInstance scenarios where more than 1 NetworkManager could exist
+        // This is primarily to handle IntegrationTest scenarios where more than 1 NetworkManager could exist
        private static Dictionary<NetworkManager, Transform> s_LastKnownNetworkManagerParents = new Dictionary<NetworkManager, Transform>();

        /// <summary>
@@ -25,7 +27,6 @@ namespace Unity.Netcode.Editor
        {
            Singleton = new NetworkManagerHelper();
            NetworkManager.NetworkManagerHelper = Singleton;
-
            EditorApplication.playModeStateChanged -= EditorApplication_playModeStateChanged;
            EditorApplication.hierarchyChanged -= EditorApplication_hierarchyChanged;

@@ -40,19 +41,105 @@ namespace Unity.Netcode.Editor
                case PlayModeStateChange.ExitingEditMode:
                    {
                        s_LastKnownNetworkManagerParents.Clear();
+                        ScenesInBuildActiveSceneCheck();
                        break;
                    }
            }
        }

+        /// <summary>
+        /// Detects if a user is trying to enter into play mode when both conditions are true:
+        /// - the currently active and open scene is not added to the scenes in build list
+        /// - an instance of a NetworkManager with scene management enabled can be found
+        /// If both conditions are met then the user is presented with a dialog box that
+        /// provides the user with the option to add the scene to the scenes in build list
+        /// before entering into play mode or the user can continue under those conditions.
+        ///
+        /// ** When scene management is enabled the user should treat all scenes that need to
+        /// be synchronized using network scene management as if they were preparing for a build.
+        /// Any scene that needs to be loaded at run time has to be included in the scenes in
+        /// build list. **
+        /// </summary>
+        private static void ScenesInBuildActiveSceneCheck()
+        {
+            var scenesList = EditorBuildSettings.scenes.ToList();
+            var activeScene = SceneManager.GetActiveScene();
+            var isSceneInBuildSettings = scenesList.Where((c) => c.path == activeScene.path).Count() == 1;
+            var networkManager = Object.FindObjectOfType<NetworkManager>();
+            if (!isSceneInBuildSettings && networkManager != null)
+            {
+                if (networkManager.NetworkConfig != null && networkManager.NetworkConfig.EnableSceneManagement)
+                {
+                    if (EditorUtility.DisplayDialog("Add Scene to Scenes in Build", $"The current scene was not found in the scenes" +
+                        $" in build and a {nameof(NetworkManager)} instance was found with scene management enabled! Clients will not be able " +
+                        $"to synchronize to this scene unless it is added to the scenes in build list.\n\nWould you like to add it now?",
+                        "Yes", "No - Continue"))
+                    {
+                        scenesList.Add(new EditorBuildSettingsScene(activeScene.path, true));
+                        EditorBuildSettings.scenes = scenesList.ToArray();
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Invoked only when the hierarchy changes
+        /// </summary>
        private static void EditorApplication_hierarchyChanged()
        {
            var allNetworkManagers = Resources.FindObjectsOfTypeAll<NetworkManager>();
            foreach (var networkManager in allNetworkManagers)
            {
-                networkManager.NetworkManagerCheckForParent();
+                if (!networkManager.NetworkManagerCheckForParent())
+                {
+                    Singleton.CheckAndNotifyUserNetworkObjectRemoved(networkManager);
                }
            }
+        }
+
+        /// <summary>
+        /// Handles notifying users that they cannot add a NetworkObject component
+        /// to a GameObject that also has a NetworkManager component. The NetworkObject
+        /// will always be removed.
+        /// GameObject + NetworkObject then NetworkManager = NetworkObject removed
+        /// GameObject + NetworkManager then NetworkObject = NetworkObject removed
+        /// Note: Since this is always invoked after <see cref="NetworkManagerCheckForParent"/>
+        /// we do not need to check for parent when searching for a NetworkObject component
+        /// </summary>
+        public void CheckAndNotifyUserNetworkObjectRemoved(NetworkManager networkManager, bool editorTest = false)
+        {
+            // Check for any NetworkObject at the same gameObject relative layer
+            var networkObject = networkManager.gameObject.GetComponent<NetworkObject>();
+
+            if (networkObject == null)
+            {
+                // if none is found, check to see if any children have a NetworkObject
+                networkObject = networkManager.gameObject.GetComponentInChildren<NetworkObject>();
+                if (networkObject == null)
+                {
+                    return;
+                }
+            }
+
+            if (!EditorApplication.isUpdating)
+            {
+                Object.DestroyImmediate(networkObject);
+
+                if (!EditorApplication.isPlaying && !editorTest)
+                {
+                    EditorUtility.DisplayDialog($"Removing {nameof(NetworkObject)}", NetworkManagerAndNetworkObjectNotAllowedMessage(), "OK");
+                }
+                else
+                {
+                    Debug.LogError(NetworkManagerAndNetworkObjectNotAllowedMessage());
+                }
+            }
+        }
+
+        public string NetworkManagerAndNetworkObjectNotAllowedMessage()
+        {
+            return $"A {nameof(GameObject)} cannot have both a {nameof(NetworkManager)} and {nameof(NetworkObject)} assigned to it or any children under it.";
+        }

        /// <summary>
        /// Handles notifying the user, via display dialog window, that they have nested a NetworkManager.
--- a/Editor/NetworkObjectEditor.cs
+++ b/Editor/NetworkObjectEditor.cs
@@ -100,5 +100,32 @@ namespace Unity.Netcode.Editor
                GUI.enabled = guiEnabled;
            }
        }
+
+        // Saved for use in OnDestroy
+        private GameObject m_GameObject;
+
+        /// <summary>
+        /// Invoked once when a NetworkObject component is
+        /// displayed in the inspector view.
+        /// </summary>
+        private void OnEnable()
+        {
+            // We set the GameObject upon being enabled because when the
+            // NetworkObject component is removed (i.e. when OnDestroy is invoked)
+            // it is no longer valid/available.
+            m_GameObject = (target as NetworkObject).gameObject;
+        }
+
+        /// <summary>
+        /// Invoked once when a NetworkObject component is
+        /// no longer displayed in the inspector view.
+        /// </summary>
+        private void OnDestroy()
+        {
+            // Since this is also invoked when a NetworkObject component is removed
+            // from a GameObject, we go ahead and check for a NetworkObject when
+            // this custom editor is destroyed.
+            NetworkBehaviourEditor.CheckForNetworkObject(m_GameObject, true);
+        }
    }
 }
--- a/Editor/NetworkTransformEditor.cs
+++ b/Editor/NetworkTransformEditor.cs
@@ -4,7 +4,7 @@ using Unity.Netcode.Components;

 namespace Unity.Netcode.Editor
 {
-    [CustomEditor(typeof(NetworkTransform))]
+    [CustomEditor(typeof(NetworkTransform), true)]
    public class NetworkTransformEditor : UnityEditor.Editor
    {
        private SerializedProperty m_SyncPositionXProperty;
@@ -112,6 +112,7 @@ namespace Unity.Netcode.Editor
            EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
            EditorGUILayout.PropertyField(m_InterpolateProperty);

+#if COM_UNITY_MODULES_PHYSICS
            // if rigidbody is present but network rigidbody is not present
            var go = ((NetworkTransform)target).gameObject;
            if (go.TryGetComponent<Rigidbody>(out _) && go.TryGetComponent<NetworkRigidbody>(out _) == false)
@@ -119,12 +120,15 @@ namespace Unity.Netcode.Editor
                EditorGUILayout.HelpBox("This GameObject contains a Rigidbody but no NetworkRigidbody.\n" +
                    "Add a NetworkRigidbody component to improve Rigidbody synchronization.", MessageType.Warning);
            }
+#endif // COM_UNITY_MODULES_PHYSICS

+#if COM_UNITY_MODULES_PHYSICS2D
            if (go.TryGetComponent<Rigidbody2D>(out _) && go.TryGetComponent<NetworkRigidbody2D>(out _) == false)
            {
                EditorGUILayout.HelpBox("This GameObject contains a Rigidbody2D but no NetworkRigidbody2D.\n" +
                    "Add a NetworkRigidbody2D component to improve Rigidbody2D synchronization.", MessageType.Warning);
            }
+#endif // COM_UNITY_MODULES_PHYSICS2D

            serializedObject.ApplyModifiedProperties();
        }
--- a/Samples~/ClientNetworkTransform.meta
+++ b/Samples~/ClientNetworkTransform.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 3106ae882c6ec416d855a44c97eeaeef
+guid: a325130169714440ba1b4878082e8956
 folderAsset: yes
 DefaultImporter:
  externalObjects: {}
--- a/Editor/PackageChecker/UTPAdapterChecker.cs
+++ b/Editor/PackageChecker/UTPAdapterChecker.cs
@@ -0,0 +1,53 @@
+#if COM_UNITY_NETCODE_ADAPTER_UTP
+using System.Linq;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.PackageManager;
+using UnityEditor.PackageManager.Requests;
+
+namespace Unity.Netcode.Editor.PackageChecker
+{
+    [InitializeOnLoad]
+    internal class UTPAdapterChecker
+    {
+        private const string k_UTPAdapterPackageName = "com.unity.netcode.adapter.utp";
+
+        private static ListRequest s_ListRequest = null;
+
+        static UTPAdapterChecker()
+        {
+            if (s_ListRequest == null)
+            {
+                s_ListRequest = Client.List();
+                EditorApplication.update += EditorUpdate;
+            }
+        }
+
+        private static void EditorUpdate()
+        {
+            if (!s_ListRequest.IsCompleted)
+            {
+                return;
+            }
+
+            EditorApplication.update -= EditorUpdate;
+
+            if (s_ListRequest.Status == StatusCode.Success)
+            {
+                if (s_ListRequest.Result.Any(p => p.name == k_UTPAdapterPackageName))
+                {
+                    Debug.Log($"({nameof(UTPAdapterChecker)}) Found UTP Adapter package, it is no longer needed, `UnityTransport` is now directly integrated into the SDK therefore removing it from the project.");
+                    Client.Remove(k_UTPAdapterPackageName);
+                }
+            }
+            else
+            {
+                var error = s_ListRequest.Error;
+                Debug.LogError($"({nameof(UTPAdapterChecker)}) Cannot check the list of packages -> error #{error.errorCode}: {error.message}");
+            }
+
+            s_ListRequest = null;
+        }
+    }
+}
+#endif // COM_UNITY_NETCODE_ADAPTER_UTP
--- a/Editor/PackageChecker/UTPAdapterChecker.cs.meta
+++ b/Editor/PackageChecker/UTPAdapterChecker.cs.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: a32aeecf69a2542469927066f5b88005
+guid: df5ed97df956b4aad91a221ba59fa304
 MonoImporter:
  externalObjects: {}
  serializedVersion: 2
--- a/Editor/PackageChecker/com.unity.netcode.editor.packagechecker.asmdef
+++ b/Editor/PackageChecker/com.unity.netcode.editor.packagechecker.asmdef
@@ -0,0 +1,14 @@
+{
+    "name": "Unity.Netcode.Editor.PackageChecker",
+    "rootNamespace": "Unity.Netcode.Editor.PackageChecker",
+    "includePlatforms": [
+        "Editor"
+    ],
+    "versionDefines": [
+        {
+            "name": "com.unity.netcode.adapter.utp",
+            "expression": "",
+            "define": "COM_UNITY_NETCODE_ADAPTER_UTP"
+        }
+    ]
+}
--- a/Samples~/ClientNetworkTransform/Scripts/ClientNetworkTransform.asmdef.meta
+++ b/Samples~/ClientNetworkTransform/Scripts/ClientNetworkTransform.asmdef.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 78ac2a8d1365141f68da5d0a9e10dbc6
+guid: de64d7f9ca85d4bf59c8c24738bc1057
 AssemblyDefinitionImporter:
  externalObjects: {}
  userData: 
--- a/Editor/com.unity.netcode.editor.asmdef
+++ b/Editor/com.unity.netcode.editor.asmdef
@@ -8,18 +8,11 @@
    "includePlatforms": [
        "Editor"
    ],
-    "excludePlatforms": [],
-    "allowUnsafeCode": false,
-    "overrideReferences": false,
-    "precompiledReferences": [],
-    "autoReferenced": true,
-    "defineConstraints": [],
    "versionDefines": [
        {
            "name": "com.unity.multiplayer.tools",
            "expression": "",
            "define": "MULTIPLAYER_TOOLS"
        }
-    ],
-    "noEngineReferences": false
+    ]
 }
--- a/README.md
+++ b/README.md
@@ -1,10 +1,16 @@
-[![Forums](https://img.shields.io/badge/unity--forums-multiplayer-blue)](https://forum.unity.com/forums/multiplayer.26/) [![Discord](https://img.shields.io/discord/449263083769036810.svg?label=discord&logo=discord&color=informational)](https://discord.gg/FM8SE9E)
-[![Website](https://img.shields.io/badge/docs-website-informational.svg)](https://docs-multiplayer.unity3d.com/) [![Api](https://img.shields.io/badge/docs-api-informational.svg)](https://docs-multiplayer.unity3d.com/docs/mlapi-api/introduction)
+# Netcode for GameObjects

-Netcode for GameObjects provides networking capabilities to GameObject & MonoBehaviour Unity workflows. The framework is interoperable with many low-level transports, including the official [Unity Transport Package](https://docs-multiplayer.unity3d.com/transport/1.0.0/introduction).
+[![Forums](https://img.shields.io/badge/unity--forums-multiplayer-blue)](https://forum.unity.com/forums/multiplayer.26/) [![Discord](https://img.shields.io/discord/449263083769036810.svg?label=discord&logo=discord&color=informational)](https://discord.gg/FM8SE9E)
+[![Manual](https://img.shields.io/badge/docs-manual-informational.svg)](https://docs-multiplayer.unity3d.com/netcode/current/about) [![API](https://img.shields.io/badge/docs-api-informational.svg)](https://docs-multiplayer.unity3d.com/netcode/current/api/introduction)
+
+Netcode for GameObjects is a Unity package that provides networking capabilities to GameObject & MonoBehaviour workflows. The framework is interoperable with many low-level transports, including the official [Unity Transport Package](https://docs-multiplayer.unity3d.com/transport/current/about).

 ### Getting Started
+
 Visit the [Multiplayer Docs Site](https://docs-multiplayer.unity3d.com/) for package & API documentation, as well as information about several samples which leverage the Netcode for GameObjects package.

+You can also jump right into our [Hello World](https://docs-multiplayer.unity3d.com/netcode/current/tutorials/helloworld/helloworldintro) guide for a taste of how to use the framework for basic networked tasks.
+
 ### Community and Feedback
+
 For general questions, networking advice or discussions about Netcode for GameObjects, please join our [Discord Community](https://discord.gg/FM8SE9E) or create a post in the [Unity Multiplayer Forum](https://forum.unity.com/forums/multiplayer.26/).
--- a/Runtime/AssemblyInfo.cs
+++ b/Runtime/AssemblyInfo.cs
@@ -5,8 +5,10 @@ using System.Runtime.CompilerServices;
 [assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
 [assembly: InternalsVisibleTo("Unity.Netcode.Editor")]
 [assembly: InternalsVisibleTo("TestProject.EditorTests")]
-[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
-[assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")]
+[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
 #endif
+[assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")]
+[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
 [assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")]
-
+[assembly: InternalsVisibleTo("Unity.Netcode.TestHelpers.Runtime")]
+[assembly: InternalsVisibleTo("Unity.Netcode.Adapter.UTP")]
--- a/Runtime/Configuration/NetworkConfig.cs
+++ b/Runtime/Configuration/NetworkConfig.cs
@@ -53,9 +53,21 @@ namespace Unity.Netcode
        public uint TickRate = 30;

        /// <summary>
-        /// The amount of seconds to wait for handshake to complete before timing out a client
+        /// The amount of seconds for the server to wait for the connection approval handshake to complete before the client is disconnected.
+        ///
+        /// If the timeout is reached before approval is completed the client will be disconnected.
        /// </summary>
-        [Tooltip("The amount of seconds to wait for the handshake to complete before the client times out")]
+        /// <remarks>
+        /// The period begins after the <see cref="NetworkEvent.Connect"/> is received on the server.
+        /// The period ends once the server finishes processing a <see cref="ConnectionRequestMessage"/> from the client.
+        ///
+        /// This setting is independent of any Transport-level timeouts that may be in effect. It covers the time between
+        /// the connection being established on the Transport layer, the client sending a
+        /// <see cref="ConnectionRequestMessage"/>, and the server processing that message through <see cref="ConnectionApproval"/>.
+        ///
+        /// This setting is server-side only.
+        /// </remarks>
+        [Tooltip("The amount of seconds for the server to wait for the connection approval handshake to complete before the client is disconnected")]
        public int ClientConnectionBufferTimeout = 10;

        /// <summary>
@@ -128,29 +140,16 @@ namespace Unity.Netcode
        public int LoadSceneTimeOut = 120;

        /// <summary>
-        /// The amount of time a message should be buffered for without being consumed. If it is not consumed within this time, it will be dropped.
+        /// The amount of time a message should be buffered if the asset or object needed to process it doesn't exist yet. If the asset is not added/object is not spawned within this time, it will be dropped.
        /// </summary>
-        [Tooltip("The amount of time a message should be buffered for without being consumed. If it is not consumed within this time, it will be dropped")]
-        public float MessageBufferTimeout = 20f;
+        [Tooltip("The amount of time a message should be buffered if the asset or object needed to process it doesn't exist yet. If the asset is not added/object is not spawned within this time, it will be dropped")]
+        public float SpawnTimeout = 1f;

        /// <summary>
        /// Whether or not to enable network logs.
        /// </summary>
        public bool EnableNetworkLogs = true;

-        /// <summary>
-        /// Whether or not to enable Snapshot System for variable updates. Not supported in this version.
-        /// </summary>
-        public bool UseSnapshotDelta { get; internal set; } = false;
-        /// <summary>
-        /// Whether or not to enable Snapshot System for spawn and despawn commands. Not supported in this version.
-        /// </summary>
-        public bool UseSnapshotSpawn { get; internal set; } = false;
-        /// <summary>
-        /// When Snapshot System spawn is enabled: max size of Snapshot Messages. Meant to fit MTU.
-        /// </summary>
-        public int SnapshotMaxSpawnUsage { get; } = 1000;
-
        public const int RttAverageSamples = 5; // number of RTT to keep an average of (plus one)
        public const int RttWindowSize = 64; // number of slots to use for RTT computations (max number of in-flight packets)
        /// <summary>
@@ -239,6 +238,8 @@ namespace Unity.Netcode
                        writer.WriteValueSafe(sortedEntry.Key);
                    }
                }
+
+                writer.WriteValueSafe(TickRate);
                writer.WriteValueSafe(ConnectionApproval);
                writer.WriteValueSafe(ForceSamePrefabs);
                writer.WriteValueSafe(EnableSceneManagement);
--- a/Runtime/Connection/NetworkClient.cs
+++ b/Runtime/Connection/NetworkClient.cs
@@ -20,6 +20,17 @@ namespace Unity.Netcode
        /// <summary>
        /// The NetworkObject's owned by this Client
        /// </summary>
-        public readonly List<NetworkObject> OwnedObjects = new List<NetworkObject>();
+        public List<NetworkObject> OwnedObjects
+        {
+            get
+            {
+                if (PlayerObject != null && PlayerObject.NetworkManager != null && PlayerObject.NetworkManager.IsListening)
+                {
+                    return PlayerObject.NetworkManager.SpawnManager.GetClientOwnedObjects(ClientId);
+                }
+
+                return new List<NetworkObject>();
+            }
+        }
    }
 }
--- a/Runtime/Core/ComponentFactory.cs
+++ b/Runtime/Core/ComponentFactory.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This class is used to support testable code by allowing any supported component used by NetworkManager to be replaced
+    /// with a mock component or a test version that overloads certain methods to change or record their behavior.
+    /// Components currently supported by ComponentFactory:
+    /// - IDeferredMessageManager
+    /// </summary>
+    internal static class ComponentFactory
+    {
+        internal delegate object CreateObjectDelegate(NetworkManager networkManager);
+
+        private static Dictionary<Type, CreateObjectDelegate> s_Delegates = new Dictionary<Type, CreateObjectDelegate>();
+
+        /// <summary>
+        /// Instantiates an instance of a given interface
+        /// </summary>
+        /// <param name="networkManager">The network manager</param>
+        /// <typeparam name="T">The interface to instantiate it with</typeparam>
+        /// <returns></returns>
+        public static T Create<T>(NetworkManager networkManager)
+        {
+            return (T)s_Delegates[typeof(T)](networkManager);
+        }
+
+        /// <summary>
+        /// Overrides the default creation logic for a given interface type
+        /// </summary>
+        /// <param name="creator">The factory delegate to create the instance</param>
+        /// <typeparam name="T">The interface type to override</typeparam>
+        public static void Register<T>(CreateObjectDelegate creator)
+        {
+            s_Delegates[typeof(T)] = creator;
+        }
+
+        /// <summary>
+        /// Reverts the creation logic for a given interface type to the default logic
+        /// </summary>
+        /// <typeparam name="T">The interface type to revert</typeparam>
+        public static void Deregister<T>()
+        {
+            s_Delegates.Remove(typeof(T));
+            SetDefaults();
+        }
+
+        /// <summary>
+        /// Initializes the default creation logic for all supported component types
+        /// </summary>
+        public static void SetDefaults()
+        {
+            SetDefault<IDeferredMessageManager>(networkManager => new DeferredMessageManager(networkManager));
+        }
+
+        private static void SetDefault<T>(CreateObjectDelegate creator)
+        {
+            if (!s_Delegates.ContainsKey(typeof(T)))
+            {
+                s_Delegates[typeof(T)] = creator;
+            }
+        }
+    }
+}
--- a/Runtime/Core/ComponentFactory.cs.meta
+++ b/Runtime/Core/ComponentFactory.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: fda4c0eb89644fcea5416bbf98ea0ba0
+timeCreated: 1649966562
--- a/Runtime/Core/IndexAllocator.cs
+++ b/Runtime/Core/IndexAllocator.cs
@@ -1,388 +0,0 @@
-using UnityEngine;
-
-namespace Unity.Netcode
-{
-    internal struct IndexAllocatorEntry
-    {
-        internal int Pos; // Position where the memory of this slot is
-        internal int Length; // Length of the memory allocated to this slot
-        internal int Next; // Next and Prev define the order of the slots in the buffer
-        internal int Prev;
-        internal bool Free;  // Whether this is a free slot
-    }
-
-    internal class IndexAllocator
-    {
-        private const int k_NotSet = -1;
-        private readonly int m_MaxSlot; // Maximum number of sections (free or not) in the buffer
-        private readonly int m_BufferSize; // Size of the buffer we allocated into
-        private int m_LastSlot = 0; // Last allocated slot
-        private IndexAllocatorEntry[] m_Slots; // Array of slots
-        private int[] m_IndexToSlot; // Mapping from the client's index to the slot index
-
-        internal IndexAllocator(int bufferSize, int maxSlot)
-        {
-            m_MaxSlot = maxSlot;
-            m_BufferSize = bufferSize;
-            m_Slots = new IndexAllocatorEntry[m_MaxSlot];
-            m_IndexToSlot = new int[m_MaxSlot];
-            Reset();
-        }
-
-        /// <summary>
-        /// Reset this IndexAllocator to an empty one, with the same sized buffer and slots
-        /// </summary>
-        internal void Reset()
-        {
-            // todo: could be made faster, for example by having a last index
-            // and not needing valid stuff past it
-            for (int i = 0; i < m_MaxSlot; i++)
-            {
-                m_Slots[i].Free = true;
-                m_Slots[i].Next = i + 1;
-                m_Slots[i].Prev = i - 1;
-                m_Slots[i].Pos = m_BufferSize;
-                m_Slots[i].Length = 0;
-
-                m_IndexToSlot[i] = k_NotSet;
-            }
-
-            m_Slots[0].Pos = 0;
-            m_Slots[0].Length = m_BufferSize;
-            m_Slots[0].Prev = k_NotSet;
-            m_Slots[m_MaxSlot - 1].Next = k_NotSet;
-        }
-
-        /// <summary>
-        /// Returns the amount of memory used
-        /// </summary>
-        /// <returns>
-        /// Returns the amount of memory used, starting at 0, ending after the last used slot
-        /// </returns>
-        internal int Range
-        {
-            get
-            {
-                // when the whole buffer is free, m_LastSlot points to an empty slot
-                if (m_Slots[m_LastSlot].Free)
-                {
-                    return 0;
-                }
-                // otherwise return the end of the last slot used
-                return m_Slots[m_LastSlot].Pos + m_Slots[m_LastSlot].Length;
-            }
-        }
-
-        /// <summary>
-        /// Allocate a slot with "size" position, for index "index"
-        /// </summary>
-        /// <param name="index">The client index to identify this. Used in Deallocate to identify which slot</param>
-        /// <param name="size">The size required. </param>
-        /// <param name="pos">Returns the position to use in the buffer </param>
-        /// <returns>
-        /// true if successful, false is there isn't enough memory available or no slots are large enough
-        /// </returns>
-        internal bool Allocate(int index, int size, out int pos)
-        {
-            pos = 0;
-            // size must be positive, index must be within range
-            if (size < 0 || index < 0 || index >= m_MaxSlot)
-            {
-                return false;
-            }
-
-            // refuse allocation if the index is already in use
-            if (m_IndexToSlot[index] != k_NotSet)
-            {
-                return false;
-            }
-
-            // todo: this is the slowest part
-            // improvement 1: list of free blocks (minor)
-            // improvement 2: heap of free blocks
-            for (int i = 0; i < m_MaxSlot; i++)
-            {
-                if (m_Slots[i].Free && m_Slots[i].Length >= size)
-                {
-                    m_IndexToSlot[index] = i;
-
-                    int leftOver = m_Slots[i].Length - size;
-                    int next = m_Slots[i].Next;
-                    if (m_Slots[next].Free)
-                    {
-                        m_Slots[next].Pos -= leftOver;
-                        m_Slots[next].Length += leftOver;
-                    }
-                    else
-                    {
-                        int add = MoveSlotAfter(i);
-
-                        m_Slots[add].Pos = m_Slots[i].Pos + size;
-                        m_Slots[add].Length = m_Slots[i].Length - size;
-                    }
-
-                    m_Slots[i].Free = false;
-                    m_Slots[i].Length = size;
-
-                    pos = m_Slots[i].Pos;
-
-                    // if we allocate past the current range, we are the last slot
-                    if (m_Slots[i].Pos + m_Slots[i].Length > Range)
-                    {
-                        m_LastSlot = i;
-                    }
-
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Deallocate a slot
-        /// </summary>
-        /// <param name="index">The client index to identify this. Same index used in Allocate </param>
-        /// <returns>
-        /// true if successful, false is there isn't an allocated slot at this index
-        /// </returns>
-        internal bool Deallocate(int index)
-        {
-            // size must be positive, index must be within range
-            if (index < 0 || index >= m_MaxSlot)
-            {
-                return false;
-            }
-
-            int slot = m_IndexToSlot[index];
-
-            if (slot == k_NotSet)
-            {
-                return false;
-            }
-
-            if (m_Slots[slot].Free)
-            {
-                return false;
-            }
-
-            m_Slots[slot].Free = true;
-
-            int prev = m_Slots[slot].Prev;
-            int next = m_Slots[slot].Next;
-
-            // if previous slot was free, merge and grow
-            if (prev != k_NotSet && m_Slots[prev].Free)
-            {
-                m_Slots[prev].Length += m_Slots[slot].Length;
-                m_Slots[slot].Length = 0;
-
-                // if the slot we're merging was the last one, the last one is now the one we merged with
-                if (slot == m_LastSlot)
-                {
-                    m_LastSlot = prev;
-                }
-
-                // todo: verify what this does on full or nearly full cases
-                MoveSlotToEnd(slot);
-                slot = prev;
-            }
-
-            next = m_Slots[slot].Next;
-
-            // merge with next slot if it is free
-            if (next != k_NotSet && m_Slots[next].Free)
-            {
-                m_Slots[slot].Length += m_Slots[next].Length;
-                m_Slots[next].Length = 0;
-                MoveSlotToEnd(next);
-            }
-
-            // if we just deallocate the last one, we need to move last back
-            if (slot == m_LastSlot)
-            {
-                m_LastSlot = m_Slots[m_LastSlot].Prev;
-                // if there's nothing allocated anymore, use 0
-                if (m_LastSlot == k_NotSet)
-                {
-                    m_LastSlot = 0;
-                }
-            }
-
-            // mark the index as available
-            m_IndexToSlot[index] = k_NotSet;
-
-            return true;
-        }
-
-        // Take a slot at the end and link it to go just after "slot".
-        // Used when allocating part of a slot and we need an entry for the rest
-        // Returns the slot that was picked
-        private int MoveSlotAfter(int slot)
-        {
-            int ret = m_Slots[m_MaxSlot - 1].Prev;
-            int p0 = m_Slots[ret].Prev;
-
-            m_Slots[p0].Next = m_MaxSlot - 1;
-            m_Slots[m_MaxSlot - 1].Prev = p0;
-
-            int p1 = m_Slots[slot].Next;
-            m_Slots[slot].Next = ret;
-            m_Slots[p1].Prev = ret;
-
-            m_Slots[ret].Prev = slot;
-            m_Slots[ret].Next = p1;
-
-            return ret;
-        }
-
-        // Move the slot "slot" to the end of the list.
-        // Used when merging two slots, that gives us an extra entry at the end
-        private void MoveSlotToEnd(int slot)
-        {
-            // if we're already there
-            if (m_Slots[slot].Next == k_NotSet)
-            {
-                return;
-            }
-
-            int prev = m_Slots[slot].Prev;
-            int next = m_Slots[slot].Next;
-
-            m_Slots[prev].Next = next;
-            if (next != k_NotSet)
-            {
-                m_Slots[next].Prev = prev;
-            }
-
-            int p0 = m_Slots[m_MaxSlot - 1].Prev;
-
-            m_Slots[p0].Next = slot;
-            m_Slots[slot].Next = m_MaxSlot - 1;
-
-            m_Slots[m_MaxSlot - 1].Prev = slot;
-            m_Slots[slot].Prev = p0;
-
-            m_Slots[slot].Pos = m_BufferSize;
-        }
-
-        // runs a bunch of consistency check on the Allocator
-        internal bool Verify()
-        {
-            int pos = k_NotSet;
-            int count = 0;
-            int total = 0;
-            int endPos = 0;
-
-            do
-            {
-                int prev = pos;
-                if (pos != k_NotSet)
-                {
-                    pos = m_Slots[pos].Next;
-                    if (pos == k_NotSet)
-                    {
-                        break;
-                    }
-                }
-                else
-                {
-                    pos = 0;
-                }
-
-                if (m_Slots[pos].Prev != prev)
-                {
-                    // the previous is not correct
-                    return false;
-                }
-
-                if (m_Slots[pos].Length < 0)
-                {
-                    // Length should be positive
-                    return false;
-                }
-
-                if (prev != k_NotSet && m_Slots[prev].Free && m_Slots[pos].Free && m_Slots[pos].Length > 0)
-                {
-                    // should not have two consecutive free slots
-                    return false;
-                }
-
-                if (m_Slots[pos].Pos != total)
-                {
-                    // slots should all line up nicely
-                    return false;
-                }
-
-                if (!m_Slots[pos].Free)
-                {
-                    endPos = m_Slots[pos].Pos + m_Slots[pos].Length;
-                }
-
-                total += m_Slots[pos].Length;
-                count++;
-
-            } while (pos != k_NotSet);
-
-            if (count != m_MaxSlot)
-            {
-                // some slots were lost
-                return false;
-            }
-
-            if (total != m_BufferSize)
-            {
-                // total buffer should be accounted for
-                return false;
-            }
-
-            if (endPos != Range)
-            {
-                // end position should match reported end position
-                return false;
-            }
-
-            return true;
-        }
-
-        // Debug display the allocator structure
-        internal void DebugDisplay()
-        {
-            string logMessage = "IndexAllocator structure\n";
-
-            bool[] seen = new bool[m_MaxSlot];
-
-            int pos = 0;
-            int count = 0;
-            bool prevEmpty = false;
-            do
-            {
-                seen[pos] = true;
-                count++;
-                if (m_Slots[pos].Length == 0 && prevEmpty)
-                {
-                    // don't display repetitive empty slots
-                }
-                else
-                {
-                    logMessage += string.Format("{0}:{1}, {2} ({3}) \n", m_Slots[pos].Pos, m_Slots[pos].Length,
-                        m_Slots[pos].Free ? "Free" : "Used", pos);
-                    if (m_Slots[pos].Length == 0)
-                    {
-                        prevEmpty = true;
-                    }
-                    else
-                    {
-                        prevEmpty = false;
-                    }
-                }
-
-                pos = m_Slots[pos].Next;
-            } while (pos != k_NotSet && !seen[pos]);
-
-            logMessage += string.Format("{0} Total entries\n", count);
-
-            Debug.Log(logMessage);
-        }
-    }
-}
--- a/Runtime/Core/NetworkBehaviour.cs
+++ b/Runtime/Core/NetworkBehaviour.cs
@@ -15,41 +15,56 @@ namespace Unity.Netcode
 #pragma warning disable IDE1006 // disable naming rule violation check
        // RuntimeAccessModifiersILPP will make this `protected`
        internal enum __RpcExecStage
-#pragma warning restore IDE1006 // restore naming rule violation check
        {
            None = 0,
            Server = 1,
            Client = 2
        }

-#pragma warning disable IDE1006 // disable naming rule violation check
        // NetworkBehaviourILPP will override this in derived classes to return the name of the concrete type
        internal virtual string __getTypeName() => nameof(NetworkBehaviour);
-#pragma warning restore IDE1006 // restore naming rule violation check

-#pragma warning disable 414 // disable assigned but its value is never used
-#pragma warning disable IDE1006 // disable naming rule violation check
        [NonSerialized]
        // RuntimeAccessModifiersILPP will make this `protected`
        internal __RpcExecStage __rpc_exec_stage = __RpcExecStage.None;
-#pragma warning restore 414 // restore assigned but its value is never used
 #pragma warning restore IDE1006 // restore naming rule violation check

-#pragma warning disable 414 // disable assigned but its value is never used
+        private const int k_RpcMessageDefaultSize = 1024; // 1k
+        private const int k_RpcMessageMaximumSize = 1024 * 64; // 64k
+
 #pragma warning disable IDE1006 // disable naming rule violation check
        // RuntimeAccessModifiersILPP will make this `protected`
-        internal void __sendServerRpc(FastBufferWriter writer, uint rpcMethodId, ServerRpcParams rpcParams, RpcDelivery delivery)
-#pragma warning restore 414 // restore assigned but its value is never used
+        internal FastBufferWriter __beginSendServerRpc(uint rpcMethodId, ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery)
 #pragma warning restore IDE1006 // restore naming rule violation check
        {
-            NetworkDelivery networkDelivery = NetworkDelivery.Reliable;
-            switch (delivery)
+            return new FastBufferWriter(k_RpcMessageDefaultSize, Allocator.Temp, k_RpcMessageMaximumSize);
+        }
+
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal void __endSendServerRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery)
+#pragma warning restore IDE1006 // restore naming rule violation check
        {
+            var serverRpcMessage = new ServerRpcMessage
+            {
+                Metadata = new RpcMetadata
+                {
+                    NetworkObjectId = NetworkObjectId,
+                    NetworkBehaviourId = NetworkBehaviourId,
+                    NetworkRpcMethodId = rpcMethodId,
+                },
+                WriteBuffer = bufferWriter
+            };
+
+            NetworkDelivery networkDelivery;
+            switch (rpcDelivery)
+            {
+                default:
                case RpcDelivery.Reliable:
                    networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                    break;
                case RpcDelivery.Unreliable:
-                    if (writer.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE - sizeof(RpcMessage.RpcType) - sizeof(ulong) - sizeof(uint) - sizeof(ushort))
+                    if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
                    {
                        throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                    }
@@ -57,42 +72,33 @@ namespace Unity.Netcode
                    break;
            }

-            var message = new RpcMessage
-            {
-                Header = new RpcMessage.HeaderData
-                {
-                    Type = RpcMessage.RpcType.Server,
-                    NetworkObjectId = NetworkObjectId,
-                    NetworkBehaviourId = NetworkBehaviourId,
-                    NetworkMethodId = rpcMethodId
-                },
-                RpcData = writer
-            };
-
-            var rpcMessageSize = 0;
+            var rpcWriteSize = 0;

            // If we are a server/host then we just no op and send to ourself
            if (IsHost || IsServer)
            {
-                using var tempBuffer = new FastBufferReader(writer, Allocator.Temp);
+                using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
                var context = new NetworkContext
                {
                    SenderId = NetworkManager.ServerClientId,
                    Timestamp = Time.realtimeSinceStartup,
                    SystemOwner = NetworkManager,
                    // header information isn't valid since it's not a real message.
-                    // Passing false to canDefer prevents it being accessed.
+                    // RpcMessage doesn't access this stuff so it's just left empty.
                    Header = new MessageHeader(),
                    SerializedHeaderSize = 0,
+                    MessageSize = 0
                };
-                message.Handle(tempBuffer, context, NetworkManager, NetworkManager.ServerClientId, false);
-                rpcMessageSize = tempBuffer.Length;
+                serverRpcMessage.ReadBuffer = tempBuffer;
+                serverRpcMessage.Handle(ref context);
+                rpcWriteSize = tempBuffer.Length;
            }
            else
            {
-                rpcMessageSize = NetworkManager.SendMessage(message, networkDelivery, NetworkManager.ServerClientId);
+                rpcWriteSize = NetworkManager.SendMessage(ref serverRpcMessage, networkDelivery, NetworkManager.ServerClientId);
            }

+            bufferWriter.Dispose();

 #if DEVELOPMENT_BUILD || UNITY_EDITOR
            if (NetworkManager.__rpc_name_table.TryGetValue(rpcMethodId, out var rpcMethodName))
@@ -102,26 +108,44 @@ namespace Unity.Netcode
                    NetworkObject,
                    rpcMethodName,
                    __getTypeName(),
-                    rpcMessageSize);
+                    rpcWriteSize);
            }
 #endif
        }

-#pragma warning disable 414 // disable assigned but its value is never used
 #pragma warning disable IDE1006 // disable naming rule violation check
        // RuntimeAccessModifiersILPP will make this `protected`
-        internal unsafe void __sendClientRpc(FastBufferWriter writer, uint rpcMethodId, ClientRpcParams rpcParams, RpcDelivery delivery)
-#pragma warning disable 414 // disable assigned but its value is never used
+        internal FastBufferWriter __beginSendClientRpc(uint rpcMethodId, ClientRpcParams clientRpcParams, RpcDelivery rpcDelivery)
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            return new FastBufferWriter(k_RpcMessageDefaultSize, Allocator.Temp, k_RpcMessageMaximumSize);
+        }
+
 #pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal void __endSendClientRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, ClientRpcParams clientRpcParams, RpcDelivery rpcDelivery)
+#pragma warning restore IDE1006 // restore naming rule violation check
        {
-            NetworkDelivery networkDelivery = NetworkDelivery.Reliable;
-            switch (delivery)
+            var clientRpcMessage = new ClientRpcMessage
            {
+                Metadata = new RpcMetadata
+                {
+                    NetworkObjectId = NetworkObjectId,
+                    NetworkBehaviourId = NetworkBehaviourId,
+                    NetworkRpcMethodId = rpcMethodId,
+                },
+                WriteBuffer = bufferWriter
+            };
+
+            NetworkDelivery networkDelivery;
+            switch (rpcDelivery)
+            {
+                default:
                case RpcDelivery.Reliable:
                    networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                    break;
                case RpcDelivery.Unreliable:
-                    if (writer.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE - sizeof(RpcMessage.RpcType) - sizeof(ulong) - sizeof(uint) - sizeof(ushort))
+                    if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
                    {
                        throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                    }
@@ -129,73 +153,85 @@ namespace Unity.Netcode
                    break;
            }

-            var message = new RpcMessage
-            {
-                Header = new RpcMessage.HeaderData
-                {
-                    Type = RpcMessage.RpcType.Client,
-                    NetworkObjectId = NetworkObjectId,
-                    NetworkBehaviourId = NetworkBehaviourId,
-                    NetworkMethodId = rpcMethodId
-                },
-                RpcData = writer
-            };
-            int messageSize;
+            var rpcWriteSize = 0;

            // We check to see if we need to shortcut for the case where we are the host/server and we can send a clientRPC
            // to ourself. Sadly we have to figure that out from the list of clientIds :(
            bool shouldSendToHost = false;
-
-            if (rpcParams.Send.TargetClientIds != null)
+            if (clientRpcParams.Send.TargetClientIds != null)
            {
-                foreach (var clientId in rpcParams.Send.TargetClientIds)
+                foreach (var targetClientId in clientRpcParams.Send.TargetClientIds)
                {
-                    if (clientId == NetworkManager.ServerClientId)
+                    if (targetClientId == NetworkManager.ServerClientId)
                    {
                        shouldSendToHost = true;
                        break;
                    }
+
+                    // Check to make sure we are sending to only observers, if not log an error.
+                    if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
+                    {
+                        NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
+                    }
                }

-                messageSize = NetworkManager.SendMessage(message, networkDelivery, in rpcParams.Send.TargetClientIds);
+                rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
            }
-            else if (rpcParams.Send.TargetClientIdsNativeArray != null)
+            else if (clientRpcParams.Send.TargetClientIdsNativeArray != null)
            {
-                foreach (var clientId in rpcParams.Send.TargetClientIdsNativeArray)
+                foreach (var targetClientId in clientRpcParams.Send.TargetClientIdsNativeArray)
                {
-                    if (clientId == NetworkManager.ServerClientId)
+                    if (targetClientId == NetworkManager.ServerClientId)
                    {
                        shouldSendToHost = true;
                        break;
                    }
+
+                    // Check to make sure we are sending to only observers, if not log an error.
+                    if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
+                    {
+                        NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
+                    }
                }

-                messageSize = NetworkManager.SendMessage(message, networkDelivery, rpcParams.Send.TargetClientIdsNativeArray.Value);
+                rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
            }
            else
            {
-                shouldSendToHost = IsHost;
-                messageSize = NetworkManager.SendMessage(message, networkDelivery, NetworkManager.ConnectedClientsIds);
+                var observerEnumerator = NetworkObject.Observers.GetEnumerator();
+                while (observerEnumerator.MoveNext())
+                {
+                    // Skip over the host
+                    if (IsHost && observerEnumerator.Current == NetworkManager.LocalClientId)
+                    {
+                        shouldSendToHost = true;
+                        continue;
+                    }
+                    rpcWriteSize = NetworkManager.MessagingSystem.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
+                }
            }

            // If we are a server/host then we just no op and send to ourself
            if (shouldSendToHost)
            {
-                using var tempBuffer = new FastBufferReader(writer, Allocator.Temp);
+                using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
                var context = new NetworkContext
                {
                    SenderId = NetworkManager.ServerClientId,
                    Timestamp = Time.realtimeSinceStartup,
                    SystemOwner = NetworkManager,
                    // header information isn't valid since it's not a real message.
-                    // Passing false to canDefer prevents it being accessed.
+                    // RpcMessage doesn't access this stuff so it's just left empty.
                    Header = new MessageHeader(),
                    SerializedHeaderSize = 0,
+                    MessageSize = 0
                };
-                message.Handle(tempBuffer, context, NetworkManager, NetworkManager.ServerClientId, false);
-                messageSize = tempBuffer.Length;
+                clientRpcMessage.ReadBuffer = tempBuffer;
+                clientRpcMessage.Handle(ref context);
            }

+            bufferWriter.Dispose();
+
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
            if (NetworkManager.__rpc_name_table.TryGetValue(rpcMethodId, out var rpcMethodName))
            {
@@ -206,12 +242,18 @@ namespace Unity.Netcode
                        NetworkObject,
                        rpcMethodName,
                        __getTypeName(),
-                        messageSize);
+                        rpcWriteSize);
                }
            }
 #endif
        }

+        internal string GenerateObserverErrorMessage(ClientRpcParams clientRpcParams, ulong targetClientId)
+        {
+            var containerNameHoldingId = clientRpcParams.Send.TargetClientIds != null ? nameof(ClientRpcParams.Send.TargetClientIds) : nameof(ClientRpcParams.Send.TargetClientIdsNativeArray);
+            return $"Sending ClientRpc to non-observer! {containerNameHoldingId} contains clientId {targetClientId} that is not an observer!";
+        }
+
        /// <summary>
        /// Gets the NetworkManager that owns this NetworkBehaviour instance
        ///   See note around `NetworkObject` for how there is a chicken / egg problem when we are not initialized
@@ -219,50 +261,50 @@ namespace Unity.Netcode
        public NetworkManager NetworkManager => NetworkObject.NetworkManager;

        /// <summary>
-        /// Gets if the object is the the personal clients player object
+        /// If a NetworkObject is assigned, it will return whether or not this NetworkObject
+        /// is the local player object.  If no NetworkObject is assigned it will always return false.
        /// </summary>
-        public bool IsLocalPlayer => NetworkObject.IsLocalPlayer;
+        public bool IsLocalPlayer { get; private set; }

        /// <summary>
        /// Gets if the object is owned by the local player or if the object is the local player object
        /// </summary>
-        public bool IsOwner => NetworkObject.IsOwner;
+        public bool IsOwner { get; internal set; }

        /// <summary>
        /// Gets if we are executing as server
        /// </summary>
-        protected bool IsServer => IsRunning && NetworkManager.IsServer;
+        protected bool IsServer { get; private set; }

        /// <summary>
        /// Gets if we are executing as client
        /// </summary>
-        protected bool IsClient => IsRunning && NetworkManager.IsClient;
+        protected bool IsClient { get; private set; }
+

        /// <summary>
        /// Gets if we are executing as Host, I.E Server and Client
        /// </summary>
-        protected bool IsHost => IsRunning && NetworkManager.IsHost;
-
-        private bool IsRunning => NetworkManager && NetworkManager.IsListening;
+        protected bool IsHost { get; private set; }

        /// <summary>
        /// Gets Whether or not the object has a owner
        /// </summary>
-        public bool IsOwnedByServer => NetworkObject.IsOwnedByServer;
+        public bool IsOwnedByServer { get; internal set; }

        /// <summary>
        /// Used to determine if it is safe to access NetworkObject and NetworkManager from within a NetworkBehaviour component
        /// Primarily useful when checking NetworkObject/NetworkManager properties within FixedUpate
        /// </summary>
-        public bool IsSpawned => HasNetworkObject ? NetworkObject.IsSpawned : false;
+        public bool IsSpawned { get; internal set; }

        internal bool IsBehaviourEditable()
        {
            // Only server can MODIFY. So allow modification if network is either not running or we are server
            return !m_NetworkObject ||
-                   (m_NetworkObject.NetworkManager == null ||
-                    !m_NetworkObject.NetworkManager.IsListening ||
-                    m_NetworkObject.NetworkManager.IsServer);
+                m_NetworkObject.NetworkManager == null ||
+                m_NetworkObject.NetworkManager.IsListening == false ||
+                m_NetworkObject.NetworkManager.IsServer;
        }

        /// <summary>
@@ -284,10 +326,14 @@ namespace Unity.Netcode
                    m_NetworkObject = GetComponentInParent<NetworkObject>();
                }

-                if (m_NetworkObject == null || NetworkManager.Singleton == null ||
-                    (NetworkManager.Singleton != null && !NetworkManager.Singleton.ShutdownInProgress))
+                // ShutdownInProgress check:
+                // This prevents an edge case scenario where the NetworkManager is shutting down but user code
+                // in Update and/or in FixedUpdate could still be checking NetworkBehaviour.NetworkObject directly (i.e. does it exist?)
+                // or NetworkBehaviour.IsSpawned (i.e. to early exit if not spawned) which, in turn, could generate several Warning messages
+                // per spawned NetworkObject.  Checking for ShutdownInProgress prevents these unnecessary LogWarning messages.
+                if (m_NetworkObject == null && (NetworkManager.Singleton == null || !NetworkManager.Singleton.ShutdownInProgress))
                {
-                    if (NetworkLog.CurrentLogLevel < LogLevel.Normal)
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
                        NetworkLog.LogWarning($"Could not get {nameof(NetworkObject)} for the {nameof(NetworkBehaviour)}. Are you missing a {nameof(NetworkObject)} component?");
                    }
@@ -307,12 +353,12 @@ namespace Unity.Netcode
        /// <summary>
        /// Gets the NetworkId of the NetworkObject that owns this NetworkBehaviour
        /// </summary>
-        public ulong NetworkObjectId => NetworkObject.NetworkObjectId;
+        public ulong NetworkObjectId { get; internal set; }

        /// <summary>
        /// Gets NetworkId for this NetworkBehaviour from the owner NetworkObject
        /// </summary>
-        public ushort NetworkBehaviourId => NetworkObject.GetNetworkBehaviourOrderIndex(this);
+        public ushort NetworkBehaviourId { get; internal set; }

        /// <summary>
        /// Internally caches the Id of this behaviour in a NetworkObject. Makes look-up faster
@@ -332,7 +378,47 @@ namespace Unity.Netcode
        /// <summary>
        /// Gets the ClientId that owns the NetworkObject
        /// </summary>
-        public ulong OwnerClientId => NetworkObject.OwnerClientId;
+        public ulong OwnerClientId { get; internal set; }
+
+        /// <summary>
+        /// Updates properties with network session related
+        /// dependencies such as a NetworkObject's spawned
+        /// state or NetworkManager's session state.
+        /// </summary>
+        internal void UpdateNetworkProperties()
+        {
+            // Set NetworkObject dependent properties
+            if (NetworkObject != null)
+            {
+                // Set identification related properties
+                NetworkObjectId = NetworkObject.NetworkObjectId;
+                IsLocalPlayer = NetworkObject.IsLocalPlayer;
+
+                // This is "OK" because GetNetworkBehaviourOrderIndex uses the order of
+                // NetworkObject.ChildNetworkBehaviours which is set once when first
+                // accessed.
+                NetworkBehaviourId = NetworkObject.GetNetworkBehaviourOrderIndex(this);
+
+                // Set ownership related properties
+                IsOwnedByServer = NetworkObject.IsOwnedByServer;
+                IsOwner = NetworkObject.IsOwner;
+                OwnerClientId = NetworkObject.OwnerClientId;
+
+                // Set NetworkManager dependent properties
+                if (NetworkManager != null)
+                {
+                    IsHost = NetworkManager.IsListening && NetworkManager.IsHost;
+                    IsClient = NetworkManager.IsListening && NetworkManager.IsClient;
+                    IsServer = NetworkManager.IsListening && NetworkManager.IsServer;
+                }
+            }
+            else // Shouldn't happen, but if so then set the properties to their default value;
+            {
+                OwnerClientId = NetworkObjectId = default;
+                IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = default;
+                NetworkBehaviourId = default;
+            }
+        }

        /// <summary>
        /// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered and the network is setup.
@@ -346,12 +432,17 @@ namespace Unity.Netcode

        internal void InternalOnNetworkSpawn()
        {
+            IsSpawned = true;
            InitializeVariables();
+            UpdateNetworkProperties();
+            OnNetworkSpawn();
        }

        internal void InternalOnNetworkDespawn()
        {
-
+            IsSpawned = false;
+            UpdateNetworkProperties();
+            OnNetworkDespawn();
        }

        /// <summary>
@@ -359,11 +450,23 @@ namespace Unity.Netcode
        /// </summary>
        public virtual void OnGainedOwnership() { }

+        internal void InternalOnGainedOwnership()
+        {
+            UpdateNetworkProperties();
+            OnGainedOwnership();
+        }
+
        /// <summary>
        /// Gets called when we loose ownership of this object
        /// </summary>
        public virtual void OnLostOwnership() { }

+        internal void InternalOnLostOwnership()
+        {
+            UpdateNetworkProperties();
+            OnLostOwnership();
+        }
+
        /// <summary>
        /// Gets called when the parent NetworkObject of this NetworkBehaviour's NetworkObject has changed
        /// </summary>
@@ -416,20 +519,17 @@ namespace Unity.Netcode

            m_VarInit = true;

-            FieldInfo[] sortedFields = GetFieldInfoForType(GetType());
-
+            var sortedFields = GetFieldInfoForType(GetType());
            for (int i = 0; i < sortedFields.Length; i++)
            {
-                Type fieldType = sortedFields[i].FieldType;
-
+                var fieldType = sortedFields[i].FieldType;
                if (fieldType.IsSubclassOf(typeof(NetworkVariableBase)))
                {
                    var instance = (NetworkVariableBase)sortedFields[i].GetValue(this);

                    if (instance == null)
                    {
-                        instance = (NetworkVariableBase)Activator.CreateInstance(fieldType, true);
-                        sortedFields[i].SetValue(this, instance);
+                        throw new Exception($"{GetType().FullName}.{sortedFields[i].Name} cannot be null. All {nameof(NetworkVariableBase)} instances must be initialized.");
                    }

                    instance.Initialize(this);
@@ -483,7 +583,7 @@ namespace Unity.Netcode
            }
        }

-        internal void VariableUpdate(ulong clientId)
+        internal void VariableUpdate(ulong targetClientId)
        {
            if (!m_VarInit)
            {
@@ -491,37 +591,29 @@ namespace Unity.Netcode
            }

            PreNetworkVariableWrite();
-            NetworkVariableUpdate(clientId, NetworkBehaviourId);
+            NetworkVariableUpdate(targetClientId, NetworkBehaviourId);
        }

        internal readonly List<int> NetworkVariableIndexesToReset = new List<int>();
        internal readonly HashSet<int> NetworkVariableIndexesToResetSet = new HashSet<int>();

-        private void NetworkVariableUpdate(ulong clientId, int behaviourIndex)
+        private void NetworkVariableUpdate(ulong targetClientId, int behaviourIndex)
        {
            if (!CouldHaveDirtyNetworkVariables())
            {
                return;
            }

-            if (NetworkManager.NetworkConfig.UseSnapshotDelta)
-            {
-                for (int k = 0; k < NetworkVariableFields.Count; k++)
-                {
-                    NetworkManager.SnapshotSystem.Store(NetworkObjectId, behaviourIndex, k, NetworkVariableFields[k]);
-                }
-            }
-
-            if (!NetworkManager.NetworkConfig.UseSnapshotDelta)
-            {
            for (int j = 0; j < m_DeliveryMappedNetworkVariableIndices.Count; j++)
            {
                var shouldSend = false;
                for (int k = 0; k < NetworkVariableFields.Count; k++)
                {
-                        if (NetworkVariableFields[k].ShouldWrite(clientId, IsServer))
+                    var networkVariable = NetworkVariableFields[k];
+                    if (networkVariable.IsDirty() && networkVariable.CanClientRead(targetClientId))
                    {
                        shouldSend = true;
+                        break;
                    }
                }

@@ -532,7 +624,7 @@ namespace Unity.Netcode
                        NetworkObjectId = NetworkObjectId,
                        NetworkBehaviourIndex = NetworkObject.GetNetworkBehaviourOrderIndex(this),
                        NetworkBehaviour = this,
-                            ClientId = clientId,
+                        TargetClientId = targetClientId,
                        DeliveryMappedNetworkVariableIndex = m_DeliveryMappedNetworkVariableIndices[j]
                    };
                    // TODO: Serialization is where the IsDirty flag gets changed.
@@ -540,9 +632,9 @@ namespace Unity.Netcode
                    // we still have to actually serialize the message even though we're not sending it, otherwise
                    // the dirty flag doesn't change properly. These two pieces should be decoupled at some point
                    // so we don't have to do this serialization work if we're not going to use the result.
-                        if (IsServer && clientId == NetworkManager.ServerClientId)
+                    if (IsServer && targetClientId == NetworkManager.ServerClientId)
                    {
-                            var tmpWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp);
+                        var tmpWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, MessagingSystem.FRAGMENTED_MESSAGE_MAX_SIZE);
                        using (tmpWriter)
                        {
                            message.Serialize(tmpWriter);
@@ -550,8 +642,7 @@ namespace Unity.Netcode
                    }
                    else
                    {
-                            NetworkManager.SendMessage(message, m_DeliveryTypesForNetworkVariableGroups[j], clientId);
-                        }
+                        NetworkManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
                    }
                }
            }
@@ -579,7 +670,7 @@ namespace Unity.Netcode
            }
        }

-        internal void WriteNetworkVariableData(FastBufferWriter writer, ulong clientId)
+        internal void WriteNetworkVariableData(FastBufferWriter writer, ulong targetClientId)
        {
            if (NetworkVariableFields.Count == 0)
            {
@@ -588,7 +679,7 @@ namespace Unity.Netcode

            for (int j = 0; j < NetworkVariableFields.Count; j++)
            {
-                bool canClientRead = NetworkVariableFields[j].CanClientRead(clientId);
+                bool canClientRead = NetworkVariableFields[j].CanClientRead(targetClientId);

                if (canClientRead)
                {
--- a/Runtime/Core/NetworkBehaviourUpdater.cs
+++ b/Runtime/Core/NetworkBehaviourUpdater.cs
@@ -57,7 +57,7 @@ namespace Unity.Netcode
                        {
                            for (int k = 0; k < sobj.ChildNetworkBehaviours.Count; k++)
                            {
-                                sobj.ChildNetworkBehaviours[k].VariableUpdate(networkManager.ServerClientId);
+                                sobj.ChildNetworkBehaviours[k].VariableUpdate(NetworkManager.ServerClientId);
                            }
                        }
                    }
--- a/Runtime/Core/NetworkManager.cs
+++ b/Runtime/Core/NetworkManager.cs
--- a/Runtime/Core/NetworkObject.cs
+++ b/Runtime/Core/NetworkObject.cs
@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using UnityEngine;
+using UnityEngine.SceneManagement;

 namespace Unity.Netcode
 {
@@ -39,7 +40,7 @@ namespace Unity.Netcode
            var globalObjectIdString = UnityEditor.GlobalObjectId.GetGlobalObjectIdSlow(this).ToString();
            GlobalObjectIdHash = XXHash.Hash32(globalObjectIdString);
        }
-#endif
+#endif // UNITY_EDITOR

        /// <summary>
        /// Gets the NetworkManager that owns this NetworkObject instance
@@ -54,8 +55,6 @@ namespace Unity.Netcode
        /// </summary>
        internal NetworkManager NetworkManagerOwner;

-        private ulong m_NetworkObjectId;
-
        /// <summary>
        /// Gets the unique Id of this object that is synced across the network
        /// </summary>
@@ -64,33 +63,7 @@ namespace Unity.Netcode
        /// <summary>
        /// Gets the ClientId of the owner of this NetworkObject
        /// </summary>
-        public ulong OwnerClientId
-        {
-            get
-            {
-                if (OwnerClientIdInternal == null)
-                {
-                    return NetworkManager != null ? NetworkManager.ServerClientId : 0;
-                }
-                else
-                {
-                    return OwnerClientIdInternal.Value;
-                }
-            }
-            internal set
-            {
-                if (NetworkManager != null && value == NetworkManager.ServerClientId)
-                {
-                    OwnerClientIdInternal = null;
-                }
-                else
-                {
-                    OwnerClientIdInternal = value;
-                }
-            }
-        }
-
-        internal ulong? OwnerClientIdInternal = null;
+        public ulong OwnerClientId { get; internal set; }

        /// <summary>
        /// If true, the object will always be replicated as root on clients and the parent will be ignored.
@@ -103,7 +76,7 @@ namespace Unity.Netcode
        public bool IsPlayerObject { get; internal set; }

        /// <summary>
-        /// Gets if the object is the the personal clients player object
+        /// Gets if the object is the personal clients player object
        /// </summary>
        public bool IsLocalPlayer => NetworkManager != null && IsPlayerObject && OwnerClientId == NetworkManager.LocalClientId;

@@ -179,6 +152,7 @@ namespace Unity.Netcode
 #endif
        }

+        private readonly HashSet<ulong> m_EmptyULongHashSet = new HashSet<ulong>();
        /// <summary>
        /// Returns Observers enumerator
        /// </summary>
@@ -187,7 +161,7 @@ namespace Unity.Netcode
        {
            if (!IsSpawned)
            {
-                throw new SpawnStateException("Object is not spawned");
+                return m_EmptyULongHashSet.GetEnumerator();
            }

            return Observers.GetEnumerator();
@@ -202,15 +176,62 @@ namespace Unity.Netcode
        {
            if (!IsSpawned)
            {
-                throw new SpawnStateException("Object is not spawned");
+                return false;
+            }
+            return Observers.Contains(clientId);
        }

-            return Observers.Contains(clientId);
+        /// <summary>
+        ///  In the event the scene of origin gets unloaded, we keep
+        ///  the most important part to uniquely identify in-scene
+        ///  placed NetworkObjects
+        /// </summary>
+        internal int SceneOriginHandle = 0;
+
+        private Scene m_SceneOrigin;
+        /// <summary>
+        /// The scene where the NetworkObject was first instantiated
+        /// Note: Primarily for in-scene placed NetworkObjects
+        /// We need to keep track of the original scene of origin for
+        /// the NetworkObject in order to be able to uniquely identify it
+        /// using the scene of origin's handle.
+        /// </summary>
+        internal Scene SceneOrigin
+        {
+            get
+            {
+                return m_SceneOrigin;
+            }
+
+            set
+            {
+                // The scene origin should only be set once.
+                // Once set, it should never change.
+                if (SceneOriginHandle == 0 && value.IsValid() && value.isLoaded)
+                {
+                    m_SceneOrigin = value;
+                    SceneOriginHandle = value.handle;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Helper method to return the correct scene handle
+        /// Note: Do not use this within NetworkSpawnManager.SpawnNetworkObjectLocallyCommon
+        /// </summary>
+        internal int GetSceneOriginHandle()
+        {
+            if (SceneOriginHandle == 0 && IsSpawned && IsSceneObject != false)
+            {
+                throw new Exception($"{nameof(GetSceneOriginHandle)} called when {nameof(SceneOriginHandle)} is still zero but the {nameof(NetworkObject)} is already spawned!");
+            }
+            return SceneOriginHandle != 0 ? SceneOriginHandle : gameObject.scene.handle;
        }

        private void Awake()
        {
            SetCachedParent(transform.parent);
+            SceneOrigin = gameObject.scene;
        }

        /// <summary>
@@ -234,11 +255,6 @@ namespace Unity.Netcode
                throw new VisibilityChangeException("The object is already visible");
            }

-            if (NetworkManager.NetworkConfig.UseSnapshotSpawn)
-            {
-                SnapshotSpawn(clientId);
-            }
-
            Observers.Add(clientId);

            NetworkManager.SpawnManager.SendSpawnCallForObject(clientId, this);
@@ -314,24 +330,17 @@ namespace Unity.Netcode
                throw new VisibilityChangeException("Cannot hide an object from the server");
            }

-
            Observers.Remove(clientId);

-            if (NetworkManager.NetworkConfig.UseSnapshotSpawn)
-            {
-                SnapshotDespawn(clientId);
-            }
-            else
-            {
            var message = new DestroyObjectMessage
            {
-                    NetworkObjectId = NetworkObjectId
+                NetworkObjectId = NetworkObjectId,
+                DestroyGameObject = true
            };
            // Send destroy call
-                var size = NetworkManager.SendMessage(message, NetworkDelivery.ReliableSequenced, clientId);
+            var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
            NetworkManager.NetworkMetrics.TrackObjectDestroySent(clientId, this, size);
        }
-        }

        /// <summary>
        /// Hides a list of objects from a client
@@ -345,14 +354,14 @@ namespace Unity.Netcode
                throw new ArgumentNullException("At least one " + nameof(NetworkObject) + " has to be provided");
            }

-            NetworkManager networkManager = networkObjects[0].NetworkManager;
+            var networkManager = networkObjects[0].NetworkManager;

            if (!networkManager.IsServer)
            {
                throw new NotServerException("Only server can change visibility");
            }

-            if (clientId == networkManager.ServerClientId)
+            if (clientId == NetworkManager.ServerClientId)
            {
                throw new VisibilityChangeException("Cannot hide an object from the server");
            }
@@ -384,84 +393,24 @@ namespace Unity.Netcode

        private void OnDestroy()
        {
-            if (NetworkManager != null && NetworkManager.IsListening && NetworkManager.IsServer == false && IsSpawned
-                && (IsSceneObject == null || (IsSceneObject != null && IsSceneObject.Value != true)))
+            if (NetworkManager != null && NetworkManager.IsListening && NetworkManager.IsServer == false && IsSpawned &&
+                (IsSceneObject == null || (IsSceneObject != null && IsSceneObject.Value != true)))
            {
                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.");
            }

-            if (NetworkManager != null && NetworkManager.SpawnManager != null && NetworkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
+            if (NetworkManager != null && NetworkManager.SpawnManager != null &&
+                NetworkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
+            {
+                if (this == networkObject)
                {
                    NetworkManager.SpawnManager.OnDespawnObject(networkObject, false);
                }
            }
-
-        private SnapshotDespawnCommand GetDespawnCommand()
-        {
-            var command = new SnapshotDespawnCommand();
-            command.NetworkObjectId = NetworkObjectId;
-
-            return command;
-        }
-
-        private SnapshotSpawnCommand GetSpawnCommand()
-        {
-            var command = new SnapshotSpawnCommand();
-            command.NetworkObjectId = NetworkObjectId;
-            command.OwnerClientId = OwnerClientId;
-            command.IsPlayerObject = IsPlayerObject;
-            command.IsSceneObject = (IsSceneObject == null) || IsSceneObject.Value;
-
-            ulong? parent = NetworkManager.SpawnManager.GetSpawnParentId(this);
-            if (parent != null)
-            {
-                command.ParentNetworkId = parent.Value;
-            }
-            else
-            {
-                // write own network id, when no parents. todo: optimize this.
-                command.ParentNetworkId = command.NetworkObjectId;
-            }
-
-            command.GlobalObjectIdHash = HostCheckForGlobalObjectIdHashOverride();
-            // todo: check if (IncludeTransformWhenSpawning == null || IncludeTransformWhenSpawning(clientId)) for any clientId
-            command.ObjectPosition = transform.position;
-            command.ObjectRotation = transform.rotation;
-            command.ObjectScale = transform.localScale;
-
-            return command;
-        }
-
-        private void SnapshotSpawn()
-        {
-            var command = GetSpawnCommand();
-            NetworkManager.SnapshotSystem.Spawn(command);
-        }
-
-        private void SnapshotSpawn(ulong clientId)
-        {
-            var command = GetSpawnCommand();
-            command.TargetClientIds = new List<ulong>();
-            command.TargetClientIds.Add(clientId);
-            NetworkManager.SnapshotSystem.Spawn(command);
-        }
-
-        internal void SnapshotDespawn()
-        {
-            var command = GetDespawnCommand();
-            NetworkManager.SnapshotSystem.Despawn(command);
-        }
-
-        internal void SnapshotDespawn(ulong clientId)
-        {
-            var command = GetDespawnCommand();
-            command.TargetClientIds = new List<ulong>();
-            command.TargetClientIds.Add(clientId);
-            NetworkManager.SnapshotSystem.Despawn(command);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void SpawnInternal(bool destroyWithScene, ulong? ownerClientId, bool playerObject)
+        private void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool playerObject)
        {
            if (!NetworkManager.IsListening)
            {
@@ -473,14 +422,8 @@ namespace Unity.Netcode
                throw new NotServerException($"Only server can spawn {nameof(NetworkObject)}s");
            }

-            NetworkManager.SpawnManager.SpawnNetworkObjectLocally(this, NetworkManager.SpawnManager.GetNetworkObjectId(), false, playerObject, ownerClientId, destroyWithScene);
+            NetworkManager.SpawnManager.SpawnNetworkObjectLocally(this, NetworkManager.SpawnManager.GetNetworkObjectId(), IsSceneObject.HasValue && IsSceneObject.Value, playerObject, ownerClientId, destroyWithScene);

-            if (NetworkManager.NetworkConfig.UseSnapshotSpawn)
-            {
-                SnapshotSpawn();
-            }
-
-            ulong ownerId = ownerClientId != null ? ownerClientId.Value : NetworkManager.ServerClientId;
            for (int i = 0; i < NetworkManager.ConnectedClientsList.Count; i++)
            {
                if (Observers.Contains(NetworkManager.ConnectedClientsList[i].ClientId))
@@ -496,7 +439,7 @@ namespace Unity.Netcode
        /// <param name="destroyWithScene">Should the object be destroyed when the scene is changed</param>
        public void Spawn(bool destroyWithScene = false)
        {
-            SpawnInternal(destroyWithScene, null, false);
+            SpawnInternal(destroyWithScene, NetworkManager.ServerClientId, false);
        }

        /// <summary>
@@ -547,17 +490,29 @@ namespace Unity.Netcode

        internal void InvokeBehaviourOnLostOwnership()
        {
+            // Server already handles this earlier, hosts should ignore, all clients should update
+            if (!NetworkManager.IsServer)
+            {
+                NetworkManager.SpawnManager.UpdateOwnershipTable(this, OwnerClientId, true);
+            }
+
            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
            {
-                ChildNetworkBehaviours[i].OnLostOwnership();
+                ChildNetworkBehaviours[i].InternalOnLostOwnership();
            }
        }

        internal void InvokeBehaviourOnGainedOwnership()
        {
+            // Server already handles this earlier, hosts should ignore and only client owners should update
+            if (!NetworkManager.IsServer && NetworkManager.LocalClientId == OwnerClientId)
+            {
+                NetworkManager.SpawnManager.UpdateOwnershipTable(this, OwnerClientId);
+            }
+
            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
            {
-                ChildNetworkBehaviours[i].OnGainedOwnership();
+                ChildNetworkBehaviours[i].InternalOnGainedOwnership();
            }
        }

@@ -714,7 +669,7 @@ namespace Unity.Netcode
                    }
                }

-                NetworkManager.SendMessage(message, NetworkDelivery.ReliableSequenced, clientIds, idx);
+                NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientIds, idx);
            }
        }

@@ -756,13 +711,7 @@ namespace Unity.Netcode

            if (!NetworkManager.SpawnManager.SpawnedObjects.ContainsKey(m_LatestParent.Value))
            {
-                if (OrphanChildren.Add(this))
-                {
-                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
-                    {
-                        NetworkLog.LogWarning($"{nameof(NetworkObject)} ({name}) cannot find its parent, added to {nameof(OrphanChildren)} set");
-                    }
-                }
+                OrphanChildren.Add(this);
                return false;
            }

@@ -793,19 +742,21 @@ namespace Unity.Netcode

        internal void InvokeBehaviourNetworkSpawn()
        {
+            NetworkManager.SpawnManager.UpdateOwnershipTable(this, OwnerClientId);
+
            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
            {
                ChildNetworkBehaviours[i].InternalOnNetworkSpawn();
-                ChildNetworkBehaviours[i].OnNetworkSpawn();
            }
        }

        internal void InvokeBehaviourNetworkDespawn()
        {
+            NetworkManager.SpawnManager.UpdateOwnershipTable(this, OwnerClientId, true);
+
            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
            {
                ChildNetworkBehaviours[i].InternalOnNetworkDespawn();
-                ChildNetworkBehaviours[i].OnNetworkDespawn();
            }
        }

@@ -834,13 +785,13 @@ namespace Unity.Netcode
            }
        }

-        internal void WriteNetworkVariableData(FastBufferWriter writer, ulong clientId)
+        internal void WriteNetworkVariableData(FastBufferWriter writer, ulong targetClientId)
        {
            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
            {
                var behavior = ChildNetworkBehaviours[i];
                behavior.InitializeVariables();
-                behavior.WriteNetworkVariableData(writer, clientId);
+                behavior.WriteNetworkVariableData(writer, targetClientId);
            }
        }

@@ -853,6 +804,27 @@ namespace Unity.Netcode
            }
        }

+        // NGO currently guarantees that the client will receive spawn data for all objects in one network tick.
+        //  Children may arrive before their parents; when they do they are stored in OrphanedChildren and then
+        //  resolved when their parents arrived.  Because we don't send a partial list of spawns (yet), something
+        //  has gone wrong if by the end of an update we still have unresolved orphans
+        //
+
+        // if and when we have different systems for where it is expected that orphans survive across ticks,
+        //   then this warning will remind us that we need to revamp the system because then we can no longer simply
+        //   spawn the orphan without its parent (at least, not when its transform is set to local coords mode)
+        //   - because then you’ll have children popping at the wrong location not having their parent’s global position to root them
+        //   - and then they’ll pop to the correct location after they get the parent, and that would be not good
+        internal static void VerifyParentingStatus()
+        {
+            if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+            {
+                if (OrphanChildren.Count > 0)
+                {
+                    NetworkLog.LogWarning($"{nameof(NetworkObject)} ({OrphanChildren.Count}) children not resolved to parents by the end of frame");
+                }
+            }
+        }
        internal void SetNetworkVariableData(FastBufferReader reader)
        {
            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
@@ -907,7 +879,7 @@ namespace Unity.Netcode

        internal struct SceneObject
        {
-            public struct HeaderData
+            public struct HeaderData : INetworkSerializeByMemcpy
            {
                public ulong NetworkObjectId;
                public ulong OwnerClientId;
@@ -918,7 +890,6 @@ namespace Unity.Netcode
                public bool IsSceneObject;
                public bool HasTransform;
                public bool IsReparented;
-                public bool HasNetworkVariables;
            }

            public HeaderData Header;
@@ -927,7 +898,7 @@ namespace Unity.Netcode
            public ulong ParentObjectId;

            //If(Metadata.HasTransform)
-            public struct TransformData
+            public struct TransformData : INetworkSerializeByMemcpy
            {
                public Vector3 Position;
                public Quaternion Rotation;
@@ -944,16 +915,17 @@ namespace Unity.Netcode
            public NetworkObject OwnerObject;
            public ulong TargetClientId;

+            public int NetworkSceneHandle;
+
            public unsafe void Serialize(FastBufferWriter writer)
            {
-                if (!writer.TryBeginWrite(
-                    sizeof(HeaderData) +
-                    (Header.HasParent ? FastBufferWriter.GetWriteSize(ParentObjectId) : 0) +
-                    (Header.HasTransform ? FastBufferWriter.GetWriteSize(Transform) : 0) +
-                    (Header.IsReparented
-                        ? FastBufferWriter.GetWriteSize(IsLatestParentSet) +
-                          (IsLatestParentSet ? FastBufferWriter.GetWriteSize<ulong>() : 0)
-                        : 0)))
+                var writeSize = sizeof(HeaderData);
+                writeSize += Header.HasParent ? FastBufferWriter.GetWriteSize(ParentObjectId) : 0;
+                writeSize += Header.HasTransform ? FastBufferWriter.GetWriteSize(Transform) : 0;
+                writeSize += Header.IsReparented ? FastBufferWriter.GetWriteSize(IsLatestParentSet) + (IsLatestParentSet ? FastBufferWriter.GetWriteSize<ulong>() : 0) : 0;
+                writeSize += Header.IsSceneObject ? FastBufferWriter.GetWriteSize<int>() : 0;
+
+                if (!writer.TryBeginWrite(writeSize))
                {
                    throw new OverflowException("Could not serialize SceneObject: Out of buffer space.");
                }
@@ -979,10 +951,17 @@ namespace Unity.Netcode
                    }
                }

-                if (Header.HasNetworkVariables)
+                // In-Scene NetworkObjects are uniquely identified NetworkPrefabs defined by their
+                // NetworkSceneHandle and GlobalObjectIdHash. Since each loaded scene has a unique
+                // handle, it provides us with a unique and persistent "scene prefab asset" instance.
+                // This is only set on in-scene placed NetworkObjects to reduce the over-all packet
+                // sizes for dynamically spawned NetworkObjects.
+                if (Header.IsSceneObject)
                {
-                    OwnerObject.WriteNetworkVariableData(writer, TargetClientId);
+                    writer.WriteValue(OwnerObject.GetSceneOriginHandle());
                }
+
+                OwnerObject.WriteNetworkVariableData(writer, TargetClientId);
            }

            public unsafe void Deserialize(FastBufferReader reader)
@@ -992,10 +971,12 @@ namespace Unity.Netcode
                    throw new OverflowException("Could not deserialize SceneObject: Out of buffer space.");
                }
                reader.ReadValue(out Header);
-                if (!reader.TryBeginRead(
-                    (Header.HasParent ? FastBufferWriter.GetWriteSize(ParentObjectId) : 0) +
-                    (Header.HasTransform ? FastBufferWriter.GetWriteSize(Transform) : 0) +
-                    (Header.IsReparented ? FastBufferWriter.GetWriteSize(IsLatestParentSet) : 0)))
+                var readSize = Header.HasParent ? FastBufferWriter.GetWriteSize(ParentObjectId) : 0;
+                readSize += Header.HasTransform ? FastBufferWriter.GetWriteSize(Transform) : 0;
+                readSize += Header.IsReparented ? FastBufferWriter.GetWriteSize(IsLatestParentSet) + (IsLatestParentSet ? FastBufferWriter.GetWriteSize<ulong>() : 0) : 0;
+                readSize += Header.IsSceneObject ? FastBufferWriter.GetWriteSize<int>() : 0;
+
+                if (!reader.TryBeginRead(readSize))
                {
                    throw new OverflowException("Could not deserialize SceneObject: Out of buffer space.");
                }
@@ -1019,10 +1000,20 @@ namespace Unity.Netcode
                        LatestParent = latestParent;
                    }
                }
+
+                // In-Scene NetworkObjects are uniquely identified NetworkPrefabs defined by their
+                // NetworkSceneHandle and GlobalObjectIdHash. Since each loaded scene has a unique
+                // handle, it provides us with a unique and persistent "scene prefab asset" instance.
+                // Client-side NetworkSceneManagers use this to locate their local instance of the
+                // NetworkObject instance.
+                if (Header.IsSceneObject)
+                {
+                    reader.ReadValueSafe(out NetworkSceneHandle);
+                }
            }
        }

-        internal SceneObject GetMessageSceneObject(ulong targetClientId, bool includeNetworkVariableData = true)
+        internal SceneObject GetMessageSceneObject(ulong targetClientId)
        {
            var obj = new SceneObject
            {
@@ -1033,7 +1024,6 @@ namespace Unity.Netcode
                    OwnerClientId = OwnerClientId,
                    IsSceneObject = IsSceneObject ?? true,
                    Hash = HostCheckForGlobalObjectIdHashOverride(),
-                    HasNetworkVariables = includeNetworkVariableData
                },
                OwnerObject = this,
                TargetClientId = targetClientId
@@ -1089,6 +1079,7 @@ namespace Unity.Netcode
            Vector3? position = null;
            Quaternion? rotation = null;
            ulong? parentNetworkId = null;
+            int? networkSceneHandle = null;

            if (sceneObject.Header.HasTransform)
            {
@@ -1101,10 +1092,15 @@ namespace Unity.Netcode
                parentNetworkId = sceneObject.ParentObjectId;
            }

+            if (sceneObject.Header.IsSceneObject)
+            {
+                networkSceneHandle = sceneObject.NetworkSceneHandle;
+            }
+
            //Attempt to create a local NetworkObject
            var networkObject = networkManager.SpawnManager.CreateLocalNetworkObject(
                sceneObject.Header.IsSceneObject, sceneObject.Header.Hash,
-                sceneObject.Header.OwnerClientId, parentNetworkId, position, rotation, sceneObject.Header.IsReparented);
+                sceneObject.Header.OwnerClientId, parentNetworkId, networkSceneHandle, position, rotation, sceneObject.Header.IsReparented);

            networkObject?.SetNetworkParenting(sceneObject.Header.IsReparented, sceneObject.LatestParent);

@@ -1142,8 +1138,7 @@ namespace Unity.Netcode
                    var globalObjectIdHash = NetworkManager.PrefabHandler.GetSourceGlobalObjectIdHash(GlobalObjectIdHash);
                    return globalObjectIdHash == 0 ? GlobalObjectIdHash : globalObjectIdHash;
                }
-                else
-                if (NetworkManager.NetworkConfig.OverrideToNetworkPrefab.ContainsKey(GlobalObjectIdHash))
+                else if (NetworkManager.NetworkConfig.OverrideToNetworkPrefab.ContainsKey(GlobalObjectIdHash))
                {
                    return NetworkManager.NetworkConfig.OverrideToNetworkPrefab[GlobalObjectIdHash];
                }
--- a/Runtime/Core/SnapshotRtt.cs
+++ b/Runtime/Core/SnapshotRtt.cs
@@ -1,93 +0,0 @@
-using System;
-
-namespace Unity.Netcode
-{
-    internal class ConnectionRtt
-    {
-        private double[] m_RttSendTimes; // times at which packet were sent for RTT computations
-        private int[] m_SendSequence; // tick, or other key, at which packets were sent (to allow matching)
-        private double[] m_MeasuredLatencies; // measured latencies (ring buffer)
-        private int m_LatenciesBegin = 0; // ring buffer begin
-        private int m_LatenciesEnd = 0; // ring buffer end
-
-        /// <summary>
-        /// Round-trip-time data
-        /// </summary>
-        public struct Rtt
-        {
-            public double BestSec; // best RTT
-            public double AverageSec; // average RTT
-            public double WorstSec; // worst RTT
-            public double LastSec; // latest ack'ed RTT
-            public int SampleCount; // number of contributing samples
-        }
-
-        public ConnectionRtt()
-        {
-            m_RttSendTimes = new double[NetworkConfig.RttWindowSize];
-            m_SendSequence = new int[NetworkConfig.RttWindowSize];
-            m_MeasuredLatencies = new double[NetworkConfig.RttWindowSize];
-        }
-
-        /// <summary>
-        /// Returns the Round-trip-time computation for this client
-        /// </summary>
-        public Rtt GetRtt()
-        {
-            var ret = new Rtt();
-            var index = m_LatenciesBegin;
-            double total = 0.0;
-            ret.BestSec = m_MeasuredLatencies[m_LatenciesBegin];
-            ret.WorstSec = m_MeasuredLatencies[m_LatenciesBegin];
-
-            while (index != m_LatenciesEnd)
-            {
-                total += m_MeasuredLatencies[index];
-                ret.SampleCount++;
-                ret.BestSec = Math.Min(ret.BestSec, m_MeasuredLatencies[index]);
-                ret.WorstSec = Math.Max(ret.WorstSec, m_MeasuredLatencies[index]);
-                index = (index + 1) % NetworkConfig.RttAverageSamples;
-            }
-
-            if (ret.SampleCount != 0)
-            {
-                ret.AverageSec = total / ret.SampleCount;
-                // the latest RTT is one before m_LatenciesEnd
-                ret.LastSec = m_MeasuredLatencies[(m_LatenciesEnd + (NetworkConfig.RttWindowSize - 1)) % NetworkConfig.RttWindowSize];
-            }
-            else
-            {
-                ret.AverageSec = 0;
-                ret.BestSec = 0;
-                ret.WorstSec = 0;
-                ret.SampleCount = 0;
-                ret.LastSec = 0;
-            }
-
-            return ret;
-        }
-
-        internal void NotifySend(int sequence, double timeSec)
-        {
-            m_RttSendTimes[sequence % NetworkConfig.RttWindowSize] = timeSec;
-            m_SendSequence[sequence % NetworkConfig.RttWindowSize] = sequence;
-        }
-
-        internal void NotifyAck(int sequence, double timeSec)
-        {
-            // if the same slot was not used by a later send
-            if (m_SendSequence[sequence % NetworkConfig.RttWindowSize] == sequence)
-            {
-                double latency = timeSec - m_RttSendTimes[sequence % NetworkConfig.RttWindowSize];
-
-                m_MeasuredLatencies[m_LatenciesEnd] = latency;
-                m_LatenciesEnd = (m_LatenciesEnd + 1) % NetworkConfig.RttAverageSamples;
-
-                if (m_LatenciesEnd == m_LatenciesBegin)
-                {
-                    m_LatenciesBegin = (m_LatenciesBegin + 1) % NetworkConfig.RttAverageSamples;
-                }
-            }
-        }
-    }
-}
--- a/Runtime/Core/SnapshotSystem.cs
+++ b/Runtime/Core/SnapshotSystem.cs
--- a/Runtime/Logging/NetworkLog.cs
+++ b/Runtime/Logging/NetworkLog.cs
@@ -14,9 +14,9 @@ namespace Unity.Netcode
        public static LogLevel CurrentLogLevel => NetworkManager.Singleton == null ? LogLevel.Normal : NetworkManager.Singleton.LogLevel;

        // internal logging
-        internal static void LogInfo(string message) => Debug.Log($"[Netcode] {message}");
-        internal static void LogWarning(string message) => Debug.LogWarning($"[Netcode] {message}");
-        internal static void LogError(string message) => Debug.LogError($"[Netcode] {message}");
+        public static void LogInfo(string message) => Debug.Log($"[Netcode] {message}");
+        public static void LogWarning(string message) => Debug.LogWarning($"[Netcode] {message}");
+        public static void LogError(string message) => Debug.LogError($"[Netcode] {message}");

        /// <summary>
        /// Logs an info log locally and on the server if possible.
@@ -62,10 +62,9 @@ namespace Unity.Netcode
                    LogType = logType,
                    Message = message
                };
-                var size = NetworkManager.Singleton.SendMessage(networkMessage, NetworkDelivery.ReliableFragmentedSequenced,
-                    NetworkManager.Singleton.ServerClientId);
+                var size = NetworkManager.Singleton.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);

-                NetworkManager.Singleton.NetworkMetrics.TrackServerLogSent(NetworkManager.Singleton.ServerClientId, (uint)logType, size);
+                NetworkManager.Singleton.NetworkMetrics.TrackServerLogSent(NetworkManager.ServerClientId, (uint)logType, size);
            }
        }

--- a/Runtime/Messaging/BatchHeader.cs
+++ b/Runtime/Messaging/BatchHeader.cs
@@ -3,7 +3,7 @@ namespace Unity.Netcode
    /// <summary>
    /// Header placed at the start of each message batch
    /// </summary>
-    internal struct BatchHeader
+    internal struct BatchHeader : INetworkSerializeByMemcpy
    {
        /// <summary>
        /// Total number of messages in the batch.
--- a/Runtime/Messaging/CustomMessageManager.cs
+++ b/Runtime/Messaging/CustomMessageManager.cs
@@ -73,9 +73,9 @@ namespace Unity.Netcode

            var message = new UnnamedMessage
            {
-                Data = messageBuffer
+                SendData = messageBuffer
            };
-            var size = m_NetworkManager.SendMessage(message, networkDelivery, clientIds);
+            var size = m_NetworkManager.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)
@@ -94,9 +94,9 @@ namespace Unity.Netcode
        {
            var message = new UnnamedMessage
            {
-                Data = messageBuffer
+                SendData = messageBuffer
            };
-            var size = m_NetworkManager.SendMessage(message, networkDelivery, clientId);
+            var size = m_NetworkManager.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)
            {
@@ -223,9 +223,9 @@ namespace Unity.Netcode
            var message = new NamedMessage
            {
                Hash = hash,
-                Data = messageStream
+                SendData = messageStream,
            };
-            var size = m_NetworkManager.SendMessage(message, networkDelivery, clientId);
+            var size = m_NetworkManager.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)
@@ -238,7 +238,7 @@ namespace Unity.Netcode
        /// Sends the named message
        /// </summary>
        /// <param name="messageName">The message name to send</param>
-        /// <param name="clientIds">The clients to send to, sends to everyone if null</param>
+        /// <param name="clientIds">The clients to send to</param>
        /// <param name="messageStream">The message stream containing the data</param>
        /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
        public void SendNamedMessage(string messageName, IReadOnlyList<ulong> clientIds, FastBufferWriter messageStream, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
@@ -266,9 +266,9 @@ namespace Unity.Netcode
            var message = new NamedMessage
            {
                Hash = hash,
-                Data = messageStream
+                SendData = messageStream
            };
-            var size = m_NetworkManager.SendMessage(message, networkDelivery, clientIds);
+            var size = m_NetworkManager.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)
--- a/Runtime/Messaging/DeferredMessageManager.cs
+++ b/Runtime/Messaging/DeferredMessageManager.cs
@@ -0,0 +1,149 @@
+using System.Collections.Generic;
+using Unity.Collections;
+using Time = UnityEngine.Time;
+
+namespace Unity.Netcode
+{
+    internal class DeferredMessageManager : IDeferredMessageManager
+    {
+        protected struct TriggerData
+        {
+            public FastBufferReader Reader;
+            public MessageHeader Header;
+            public ulong SenderId;
+            public float Timestamp;
+            public int SerializedHeaderSize;
+        }
+        protected struct TriggerInfo
+        {
+            public float Expiry;
+            public NativeList<TriggerData> TriggerData;
+        }
+
+        protected readonly Dictionary<IDeferredMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>> m_Triggers = new Dictionary<IDeferredMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>>();
+
+        private readonly NetworkManager m_NetworkManager;
+
+        internal DeferredMessageManager(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+        }
+
+        /// <summary>
+        /// Defers processing of a message until the moment a specific networkObjectId is spawned.
+        /// This is to handle situations where an RPC or other object-specific message arrives before the spawn does,
+        /// either due to it being requested in OnNetworkSpawn before the spawn call has been executed
+        ///
+        /// 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)
+        {
+            if (!m_Triggers.TryGetValue(trigger, out var triggers))
+            {
+                triggers = new Dictionary<ulong, TriggerInfo>();
+                m_Triggers[trigger] = triggers;
+            }
+
+            if (!triggers.TryGetValue(key, out var triggerInfo))
+            {
+                triggerInfo = new TriggerInfo
+                {
+                    Expiry = Time.realtimeSinceStartup + m_NetworkManager.NetworkConfig.SpawnTimeout,
+                    TriggerData = new NativeList<TriggerData>(Allocator.Persistent)
+                };
+                triggers[key] = triggerInfo;
+            }
+
+            triggerInfo.TriggerData.Add(new TriggerData
+            {
+                Reader = new FastBufferReader(reader.GetUnsafePtr(), Allocator.Persistent, reader.Length),
+                Header = context.Header,
+                Timestamp = context.Timestamp,
+                SenderId = context.SenderId,
+                SerializedHeaderSize = context.SerializedHeaderSize
+            });
+        }
+
+        /// <summary>
+        /// Cleans up any trigger that's existed for more than a second.
+        /// These triggers were probably for situations where a request was received after a despawn rather than before a spawn.
+        /// </summary>
+        public virtual unsafe void CleanupStaleTriggers()
+        {
+            foreach (var kvp in m_Triggers)
+            {
+                ulong* staleKeys = stackalloc ulong[kvp.Value.Count];
+                int index = 0;
+                foreach (var kvp2 in kvp.Value)
+                {
+                    if (kvp2.Value.Expiry < Time.realtimeSinceStartup)
+                    {
+                        staleKeys[index++] = kvp2.Key;
+                        PurgeTrigger(kvp.Key, kvp2.Key, kvp2.Value);
+                    }
+                }
+
+                for (var i = 0; i < index; ++i)
+                {
+                    kvp.Value.Remove(staleKeys[i]);
+                }
+            }
+        }
+
+        protected virtual void PurgeTrigger(IDeferredMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
+        {
+            if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+            {
+                NetworkLog.LogWarning($"Deferred messages were received for a trigger of type {triggerType} with key {key}, but that trigger was not received within within {m_NetworkManager.NetworkConfig.SpawnTimeout} second(s).");
+            }
+
+            foreach (var data in triggerInfo.TriggerData)
+            {
+                data.Reader.Dispose();
+            }
+
+            triggerInfo.TriggerData.Dispose();
+        }
+
+        public virtual void ProcessTriggers(IDeferredMessageManager.TriggerType trigger, ulong key)
+        {
+            if (m_Triggers.TryGetValue(trigger, out var triggers))
+            {
+                // This must happen after InvokeBehaviourNetworkSpawn, otherwise ClientRPCs and other messages can be
+                // processed before the object is fully spawned. This must be the last thing done in the spawn process.
+                if (triggers.TryGetValue(key, out var triggerInfo))
+                {
+                    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);
+                    }
+
+                    triggerInfo.TriggerData.Dispose();
+                    triggers.Remove(key);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Cleans up any trigger that's existed for more than a second.
+        /// These triggers were probably for situations where a request was received after a despawn rather than before a spawn.
+        /// </summary>
+        public virtual void CleanupAllTriggers()
+        {
+            foreach (var kvp in m_Triggers)
+            {
+                foreach (var kvp2 in kvp.Value)
+                {
+                    foreach (var data in kvp2.Value.TriggerData)
+                    {
+                        data.Reader.Dispose();
+                    }
+                    kvp2.Value.TriggerData.Dispose();
+                }
+            }
+            m_Triggers.Clear();
+        }
+    }
+}
--- a/Runtime/Messaging/DeferredMessageManager.cs.meta
+++ b/Runtime/Messaging/DeferredMessageManager.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ac7f57f7d16a46e2aba65558e873727f
+timeCreated: 1649799187
--- a/Runtime/Messaging/IDeferredMessageManager.cs
+++ b/Runtime/Messaging/IDeferredMessageManager.cs
@@ -0,0 +1,35 @@
+namespace Unity.Netcode
+{
+    internal interface IDeferredMessageManager
+    {
+        internal enum TriggerType
+        {
+            OnSpawn,
+            OnAddPrefab,
+        }
+
+        /// <summary>
+        /// Defers processing of a message until the moment a specific networkObjectId is spawned.
+        /// This is to handle situations where an RPC or other object-specific message arrives before the spawn does,
+        /// either due to it being requested in OnNetworkSpawn before the spawn call has been executed
+        ///
+        /// 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>
+        void DeferMessage(TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context);
+
+        /// <summary>
+        /// Cleans up any trigger that's existed for more than a second.
+        /// These triggers were probably for situations where a request was received after a despawn rather than before a spawn.
+        /// </summary>
+        void CleanupStaleTriggers();
+
+        void ProcessTriggers(TriggerType trigger, ulong key);
+
+        /// <summary>
+        /// Cleans up any trigger that's existed for more than a second.
+        /// These triggers were probably for situations where a request was received after a despawn rather than before a spawn.
+        /// </summary>
+        void CleanupAllTriggers();
+    }
+}
--- a/Runtime/Messaging/IDeferredMessageManager.cs.meta
+++ b/Runtime/Messaging/IDeferredMessageManager.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7fb73a029c314763a04ebb015a07664d
+timeCreated: 1649966331
--- a/Runtime/Messaging/INetworkHooks.cs
+++ b/Runtime/Messaging/INetworkHooks.cs
@@ -13,18 +13,18 @@ namespace Unity.Netcode
        /// Called before an individual message is sent.
        /// </summary>
        /// <param name="clientId">The destination clientId</param>
-        /// <param name="messageType">The type of the message being sent</param>
+        /// <param name="message">The message being sent</param>
        /// <param name="delivery"></param>
-        void OnBeforeSendMessage(ulong clientId, Type messageType, NetworkDelivery delivery);
+        void OnBeforeSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery) where T : INetworkMessage;

        /// <summary>
        /// Called after an individual message is sent.
        /// </summary>
        /// <param name="clientId">The destination clientId</param>
-        /// <param name="messageType">The type of the message being sent</param>
+        /// <param name="message">The message being sent</param>
        /// <param name="delivery"></param>
        /// <param name="messageSizeBytes">Number of bytes in the message, not including the message header</param>
-        void OnAfterSendMessage(ulong clientId, Type messageType, NetworkDelivery delivery, int messageSizeBytes);
+        void OnAfterSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery, int messageSizeBytes) where T : INetworkMessage;

        /// <summary>
        /// Called before an individual message is received.
@@ -91,7 +91,27 @@ namespace Unity.Netcode
        /// </summary>
        /// <param name="senderId">The source clientId</param>
        /// <param name="messageType">The type of the message</param>
+        /// <param name="messageContent">The FastBufferReader containing the message</param>
+        /// <param name="context">The NetworkContext the message is being processed in</param>
        /// <returns></returns>
-        bool OnVerifyCanReceive(ulong senderId, Type messageType);
+        bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context);
+
+        /// <summary>
+        /// Called after a message is serialized, but before it's handled.
+        /// Differs from OnBeforeReceiveMessage in that the actual message object is passed and can be inspected.
+        /// </summary>
+        /// <param name="message">The message object</param>
+        /// <param name="context">The network context the message is being ahandled in</param>
+        /// <typeparam name="T"></typeparam>
+        void OnBeforeHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage;
+
+        /// <summary>
+        /// Called after a message is serialized and handled.
+        /// Differs from OnAfterReceiveMessage in that the actual message object is passed and can be inspected.
+        /// </summary>
+        /// <param name="message">The message object</param>
+        /// <param name="context">The network context the message is being ahandled in</param>
+        /// <typeparam name="T"></typeparam>
+        void OnAfterHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage;
    }
 }
--- a/Runtime/Messaging/INetworkMessage.cs
+++ b/Runtime/Messaging/INetworkMessage.cs
@@ -15,7 +15,7 @@ namespace Unity.Netcode
    /// static message handler for receiving messages of the following name and signature:
    ///
    /// <code>
-    /// public static void Receive(FastBufferReader reader, in NetworkContext context)
+    /// public static void Receive(FastBufferReader reader, ref NetworkContext context)
    /// </code>
    ///
    /// It is the responsibility of the Serialize and Receive methods to ensure there is enough buffer space
@@ -40,10 +40,8 @@ namespace Unity.Netcode
    /// </summary>
    internal interface INetworkMessage
    {
-        /// <summary>
-        /// Used to serialize the message.
-        /// </summary>
-        /// <param name="writer"></param>
        void Serialize(FastBufferWriter writer);
+        bool Deserialize(FastBufferReader reader, ref NetworkContext context);
+        void Handle(ref NetworkContext context);
    }
 }
--- a/Runtime/Messaging/MessageHeader.cs
+++ b/Runtime/Messaging/MessageHeader.cs
@@ -3,7 +3,7 @@ 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
+    internal struct MessageHeader : INetworkSerializeByMemcpy
    {
        /// <summary>
        /// The byte representation of the message type. This is automatically assigned to each message
--- a/Runtime/Messaging/Messages/ChangeOwnershipMessage.cs
+++ b/Runtime/Messaging/Messages/ChangeOwnershipMessage.cs
@@ -1,6 +1,6 @@
 namespace Unity.Netcode
 {
-    internal struct ChangeOwnershipMessage : INetworkMessage
+    internal struct ChangeOwnershipMessage : INetworkMessage, INetworkSerializeByMemcpy
    {
        public ulong NetworkObjectId;
        public ulong OwnerClientId;
@@ -10,40 +10,53 @@ namespace Unity.Netcode
            writer.WriteValueSafe(this);
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
        {
            var networkManager = (NetworkManager)context.SystemOwner;
            if (!networkManager.IsClient)
            {
-                return;
+                return false;
            }
-            reader.ReadValueSafe(out ChangeOwnershipMessage message);
-            message.Handle(reader, context, context.SenderId, networkManager, reader.Length);
+            reader.ReadValueSafe(out this);
+            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+            {
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                return false;
            }

-        public void Handle(FastBufferReader reader, in NetworkContext context, ulong senderId, NetworkManager networkManager, int messageSize)
-        {
-            if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
-            {
-                networkManager.SpawnManager.TriggerOnSpawn(NetworkObjectId, reader, context);
-                return;
+            return true;
        }

-            if (networkObject.OwnerClientId == networkManager.LocalClientId)
+        public void Handle(ref NetworkContext context)
        {
-                //We are current owner.
-                networkObject.InvokeBehaviourOnLostOwnership();
-            }
+            var networkManager = (NetworkManager)context.SystemOwner;
+            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
+            var originalOwner = networkObject.OwnerClientId;

            networkObject.OwnerClientId = OwnerClientId;

+            // We are current owner.
+            if (originalOwner == networkManager.LocalClientId)
+            {
+                networkObject.InvokeBehaviourOnLostOwnership();
+            }
+
+            // We are new owner.
            if (OwnerClientId == networkManager.LocalClientId)
            {
-                //We are new owner.
                networkObject.InvokeBehaviourOnGainedOwnership();
            }

-            networkManager.NetworkMetrics.TrackOwnershipChangeReceived(senderId, networkObject, messageSize);
+            // For all other clients that are neither the former or current owner, update the behaviours' properties
+            if (OwnerClientId != networkManager.LocalClientId && originalOwner != networkManager.LocalClientId)
+            {
+                for (int i = 0; i < networkObject.ChildNetworkBehaviours.Count; i++)
+                {
+                    networkObject.ChildNetworkBehaviours[i].UpdateNetworkProperties();
+                }
+            }
+
+            networkManager.NetworkMetrics.TrackOwnershipChangeReceived(context.SenderId, networkObject, context.MessageSize);
        }
    }
 }
--- a/Runtime/Messaging/Messages/ConnectionApprovedMessage.cs
+++ b/Runtime/Messaging/Messages/ConnectionApprovedMessage.cs
@@ -7,24 +7,27 @@ namespace Unity.Netcode
    {
        public ulong OwnerClientId;
        public int NetworkTick;
-        public int SceneObjectCount;

        // Not serialized, held as references to serialize NetworkVariable data
        public HashSet<NetworkObject> SpawnedObjectsList;

+        private FastBufferReader m_ReceivedSceneObjectData;
+
        public void Serialize(FastBufferWriter writer)
        {
            if (!writer.TryBeginWrite(sizeof(ulong) + sizeof(int) + sizeof(int)))
            {
-                throw new OverflowException(
-                    $"Not enough space in the write buffer to serialize {nameof(ConnectionApprovedMessage)}");
+                throw new OverflowException($"Not enough space in the write buffer to serialize {nameof(ConnectionApprovedMessage)}");
            }
            writer.WriteValue(OwnerClientId);
            writer.WriteValue(NetworkTick);
-            writer.WriteValue(SceneObjectCount);

-            if (SceneObjectCount != 0)
+            uint sceneObjectCount = 0;
+            if (SpawnedObjectsList != null)
            {
+                var pos = writer.Position;
+                writer.Seek(writer.Position + FastBufferWriter.GetWriteSize(sceneObjectCount));
+
                // Serialize NetworkVariable data
                foreach (var sobj in SpawnedObjectsList)
                {
@@ -33,34 +36,41 @@ namespace Unity.Netcode
                        sobj.Observers.Add(OwnerClientId);
                        var sceneObject = sobj.GetMessageSceneObject(OwnerClientId);
                        sceneObject.Serialize(writer);
+                        ++sceneObjectCount;
                    }
                }
+                writer.Seek(pos);
+                writer.WriteValue(sceneObjectCount);
+                writer.Seek(writer.Length);
+            }
+            else
+            {
+                writer.WriteValue(sceneObjectCount);
            }
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
        {
            var networkManager = (NetworkManager)context.SystemOwner;
            if (!networkManager.IsClient)
            {
-                return;
+                return false;
            }

            if (!reader.TryBeginRead(sizeof(ulong) + sizeof(int) + sizeof(int)))
            {
-                throw new OverflowException(
-                    $"Not enough space in the buffer to read {nameof(ConnectionApprovedMessage)}");
+                throw new OverflowException($"Not enough space in the buffer to read {nameof(ConnectionApprovedMessage)}");
            }

-            var message = new ConnectionApprovedMessage();
-            reader.ReadValue(out message.OwnerClientId);
-            reader.ReadValue(out message.NetworkTick);
-            reader.ReadValue(out message.SceneObjectCount);
-            message.Handle(reader, context.SenderId, networkManager);
+            reader.ReadValue(out OwnerClientId);
+            reader.ReadValue(out NetworkTick);
+            m_ReceivedSceneObjectData = reader;
+            return true;
        }

-        public void Handle(FastBufferReader reader, ulong clientId, NetworkManager networkManager)
+        public void Handle(ref NetworkContext context)
        {
+            var networkManager = (NetworkManager)context.SystemOwner;
            networkManager.LocalClientId = OwnerClientId;
            networkManager.NetworkMetrics.SetConnectionId(networkManager.LocalClientId);

@@ -74,20 +84,21 @@ namespace Unity.Netcode
            if (!networkManager.NetworkConfig.EnableSceneManagement)
            {
                networkManager.SpawnManager.DestroySceneObjects();
+                m_ReceivedSceneObjectData.ReadValue(out uint sceneObjectCount);

                // Deserializing NetworkVariable data is deferred from Receive() to Handle to avoid needing
                // to create a list to hold the data. This is a breach of convention for performance reasons.
-                for (ushort i = 0; i < SceneObjectCount; i++)
+                for (ushort i = 0; i < sceneObjectCount; i++)
                {
                    var sceneObject = new NetworkObject.SceneObject();
-                    sceneObject.Deserialize(reader);
-                    NetworkObject.AddSceneObject(sceneObject, reader, networkManager);
+                    sceneObject.Deserialize(m_ReceivedSceneObjectData);
+                    NetworkObject.AddSceneObject(sceneObject, m_ReceivedSceneObjectData, networkManager);
                }

                // Mark the client being connected
                networkManager.IsConnectedClient = true;
                // When scene management is disabled we notify after everything is synchronized
-                networkManager.InvokeOnClientConnectedCallback(clientId);
+                networkManager.InvokeOnClientConnectedCallback(context.SenderId);
            }
        }
    }
--- a/Runtime/Messaging/Messages/ConnectionRequestMessage.cs
+++ b/Runtime/Messaging/Messages/ConnectionRequestMessage.cs
@@ -21,19 +21,17 @@ namespace Unity.Netcode
            }
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
        {
            var networkManager = (NetworkManager)context.SystemOwner;
            if (!networkManager.IsServer)
            {
-                return;
+                return false;
            }

-            var message = new ConnectionRequestMessage();
            if (networkManager.NetworkConfig.ConnectionApproval)
            {
-                if (!reader.TryBeginRead(FastBufferWriter.GetWriteSize(message.ConfigHash) +
-                                         FastBufferWriter.GetWriteSize<int>()))
+                if (!reader.TryBeginRead(FastBufferWriter.GetWriteSize(ConfigHash) + FastBufferWriter.GetWriteSize<int>()))
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
@@ -41,11 +39,12 @@ namespace Unity.Netcode
                    }

                    networkManager.DisconnectClient(context.SenderId);
-                    return;
+                    return false;
                }
-                reader.ReadValue(out message.ConfigHash);

-                if (!networkManager.NetworkConfig.CompareConfig(message.ConfigHash))
+                reader.ReadValue(out ConfigHash);
+
+                if (!networkManager.NetworkConfig.CompareConfig(ConfigHash))
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
@@ -53,14 +52,14 @@ namespace Unity.Netcode
                    }

                    networkManager.DisconnectClient(context.SenderId);
-                    return;
+                    return false;
                }

-                reader.ReadValueSafe(out message.ConnectionData);
+                reader.ReadValueSafe(out ConnectionData);
            }
            else
            {
-                if (!reader.TryBeginRead(FastBufferWriter.GetWriteSize(message.ConfigHash)))
+                if (!reader.TryBeginRead(FastBufferWriter.GetWriteSize(ConfigHash)))
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
@@ -68,11 +67,11 @@ namespace Unity.Netcode
                    }

                    networkManager.DisconnectClient(context.SenderId);
-                    return;
+                    return false;
                }
-                reader.ReadValue(out message.ConfigHash);
+                reader.ReadValue(out ConfigHash);

-                if (!networkManager.NetworkConfig.CompareConfig(message.ConfigHash))
+                if (!networkManager.NetworkConfig.CompareConfig(ConfigHash))
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
@@ -80,14 +79,18 @@ namespace Unity.Netcode
                    }

                    networkManager.DisconnectClient(context.SenderId);
-                    return;
+                    return false;
                }
            }
-            message.Handle(networkManager, context.SenderId);
-        }

-        public void Handle(NetworkManager networkManager, ulong senderId)
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            var senderId = context.SenderId;
+
            if (networkManager.PendingClients.TryGetValue(senderId, out PendingClient client))
            {
                // Set to pending approval to prevent future connection requests from being approved
@@ -98,17 +101,24 @@ namespace Unity.Netcode
            {
                // Note: Delegate creation allocates.
                // Note: ToArray() also allocates. :(
-                networkManager.InvokeConnectionApproval(ConnectionData, senderId,
-                    (createPlayerObject, playerPrefabHash, approved, position, rotation) =>
+                var response = new NetworkManager.ConnectionApprovalResponse();
+                networkManager.ClientsToApprove[senderId] = response;
+
+                networkManager.ConnectionApprovalCallback(
+                    new NetworkManager.ConnectionApprovalRequest
                    {
-                        var localCreatePlayerObject = createPlayerObject;
-                        networkManager.HandleApproval(senderId, localCreatePlayerObject, playerPrefabHash, approved,
-                            position, rotation);
-                    });
+                        Payload = ConnectionData,
+                        ClientNetworkId = senderId
+                    }, response);
            }
            else
            {
-                networkManager.HandleApproval(senderId, networkManager.NetworkConfig.PlayerPrefab != null, null, true, null, null);
+                var response = new NetworkManager.ConnectionApprovalResponse
+                {
+                    Approved = true,
+                    CreatePlayerObject = networkManager.NetworkConfig.PlayerPrefab != null
+                };
+                networkManager.HandleConnectionApproval(senderId, response);
            }
        }
    }
--- a/Runtime/Messaging/Messages/CreateObjectMessage.cs
+++ b/Runtime/Messaging/Messages/CreateObjectMessage.cs
@@ -3,28 +3,38 @@ namespace Unity.Netcode
    internal struct CreateObjectMessage : INetworkMessage
    {
        public NetworkObject.SceneObject ObjectInfo;
+        private FastBufferReader m_ReceivedNetworkVariableData;

        public void Serialize(FastBufferWriter writer)
        {
            ObjectInfo.Serialize(writer);
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
        {
            var networkManager = (NetworkManager)context.SystemOwner;
            if (!networkManager.IsClient)
            {
-                return;
-            }
-            var message = new CreateObjectMessage();
-            message.ObjectInfo.Deserialize(reader);
-            message.Handle(context.SenderId, reader, networkManager);
+                return false;
            }

-        public void Handle(ulong senderId, FastBufferReader reader, NetworkManager networkManager)
+            ObjectInfo.Deserialize(reader);
+            if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectInfo))
            {
-            var networkObject = NetworkObject.AddSceneObject(ObjectInfo, reader, networkManager);
-            networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, reader.Length);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Header.Hash, reader, ref context);
+                return false;
+            }
+            m_ReceivedNetworkVariableData = reader;
+
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            var networkObject = NetworkObject.AddSceneObject(ObjectInfo, m_ReceivedNetworkVariableData, networkManager);
+
+            networkManager.NetworkMetrics.TrackObjectSpawnReceived(context.SenderId, networkObject, context.MessageSize);
        }
    }
 }
--- a/Runtime/Messaging/Messages/DestroyObjectMessage.cs
+++ b/Runtime/Messaging/Messages/DestroyObjectMessage.cs
@@ -1,41 +1,44 @@
 namespace Unity.Netcode
 {
-    internal struct DestroyObjectMessage : INetworkMessage
+    internal struct DestroyObjectMessage : INetworkMessage, INetworkSerializeByMemcpy
    {
        public ulong NetworkObjectId;
+        public bool DestroyGameObject;

        public void Serialize(FastBufferWriter writer)
        {
            writer.WriteValueSafe(this);
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
        {
            var networkManager = (NetworkManager)context.SystemOwner;
            if (!networkManager.IsClient)
            {
-                return;
-            }
-            reader.ReadValueSafe(out DestroyObjectMessage message);
-            message.Handle(context.SenderId, networkManager, reader.Length);
+                return false;
            }

-        public void Handle(ulong senderId, NetworkManager networkManager, int messageSize)
+            reader.ReadValueSafe(out this);
+
+            if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
            {
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                return false;
+            }
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
            if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
            {
                // This is the same check and log message that happens inside OnDespawnObject, but we have to do it here
-                // while we still have access to the network ID, otherwise the log message will be less useful.
-                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
-                {
-                    NetworkLog.LogWarning($"Trying to destroy {nameof(NetworkObject)} #{NetworkObjectId} but it does not exist in {nameof(NetworkSpawnManager.SpawnedObjects)} anymore!");
-                }
-
                return;
            }

-            networkManager.NetworkMetrics.TrackObjectDestroyReceived(senderId, networkObject, messageSize);
-            networkManager.SpawnManager.OnDespawnObject(networkObject, true);
+            networkManager.NetworkMetrics.TrackObjectDestroyReceived(context.SenderId, networkObject, context.MessageSize);
+            networkManager.SpawnManager.OnDespawnObject(networkObject, DestroyGameObject);
        }
    }
 }
--- a/Runtime/Messaging/Messages/NamedMessage.cs
+++ b/Runtime/Messaging/Messages/NamedMessage.cs
@@ -3,20 +3,26 @@ namespace Unity.Netcode
    internal struct NamedMessage : INetworkMessage
    {
        public ulong Hash;
-        public FastBufferWriter Data;
+        public FastBufferWriter SendData;
+
+        private FastBufferReader m_ReceiveData;

        public unsafe void Serialize(FastBufferWriter writer)
        {
            writer.WriteValueSafe(Hash);
-            writer.WriteBytesSafe(Data.GetUnsafePtr(), Data.Length);
+            writer.WriteBytesSafe(SendData.GetUnsafePtr(), SendData.Length);
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
        {
-            var message = new NamedMessage();
-            reader.ReadValueSafe(out message.Hash);
+            reader.ReadValueSafe(out Hash);
+            m_ReceiveData = reader;
+            return true;
+        }

-            ((NetworkManager)context.SystemOwner).CustomMessagingManager.InvokeNamedMessage(message.Hash, context.SenderId, reader, context.SerializedHeaderSize);
+        public void Handle(ref NetworkContext context)
+        {
+            ((NetworkManager)context.SystemOwner).CustomMessagingManager.InvokeNamedMessage(Hash, context.SenderId, m_ReceiveData, context.SerializedHeaderSize);
        }
    }
 }
--- a/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs
+++ b/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs
@@ -16,27 +16,29 @@ namespace Unity.Netcode
        public ushort NetworkBehaviourIndex;

        public HashSet<int> DeliveryMappedNetworkVariableIndex;
-        public ulong ClientId;
+        public ulong TargetClientId;
        public NetworkBehaviour NetworkBehaviour;

+        private FastBufferReader m_ReceivedNetworkVariableData;
+
        public void Serialize(FastBufferWriter writer)
        {
-            if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize(NetworkObjectId) +
-                                      FastBufferWriter.GetWriteSize(NetworkBehaviourIndex)))
+            if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize(NetworkObjectId) + FastBufferWriter.GetWriteSize(NetworkBehaviourIndex)))
            {
-                throw new OverflowException(
-                    $"Not enough space in the buffer to write {nameof(NetworkVariableDeltaMessage)}");
+                throw new OverflowException($"Not enough space in the buffer to write {nameof(NetworkVariableDeltaMessage)}");
            }
+
            writer.WriteValue(NetworkObjectId);
            writer.WriteValue(NetworkBehaviourIndex);
-            for (int k = 0; k < NetworkBehaviour.NetworkVariableFields.Count; k++)
+
+            for (int i = 0; i < NetworkBehaviour.NetworkVariableFields.Count; i++)
            {
-                if (!DeliveryMappedNetworkVariableIndex.Contains(k))
+                if (!DeliveryMappedNetworkVariableIndex.Contains(i))
                {
                    // This var does not belong to the currently iterating delivery group.
                    if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                    {
-                        writer.WriteValueSafe((short)0);
+                        writer.WriteValueSafe((ushort)0);
                    }
                    else
                    {
@@ -46,15 +48,25 @@ namespace Unity.Netcode
                    continue;
                }

-                //   if I'm dirty AND a client, write (server always has all permissions)
-                //   if I'm dirty AND the server AND the client can read me, send.
-                bool shouldWrite = NetworkBehaviour.NetworkVariableFields[k].ShouldWrite(ClientId, NetworkBehaviour.NetworkManager.IsServer);
+                var startingSize = writer.Length;
+                var networkVariable = NetworkBehaviour.NetworkVariableFields[i];
+                var shouldWrite = networkVariable.IsDirty() &&
+                    networkVariable.CanClientRead(TargetClientId) &&
+                    (NetworkBehaviour.NetworkManager.IsServer || networkVariable.CanClientWrite(NetworkBehaviour.NetworkManager.LocalClientId));
+
+                // Prevent the server from writing to the client that owns a given NetworkVariable
+                // Allowing the write would send an old value to the client and cause jitter
+                if (networkVariable.WritePerm == NetworkVariableWritePermission.Owner &&
+                    networkVariable.OwnerClientId() == TargetClientId)
+                {
+                    shouldWrite = false;
+                }

                if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                {
                    if (!shouldWrite)
                    {
-                        writer.WriteValueSafe((ushort)0);
+                        BytePacker.WriteValueBitPacked(writer, 0);
                    }
                }
                else
@@ -66,56 +78,62 @@ namespace Unity.Netcode
                {
                    if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                    {
-                        var tmpWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, short.MaxValue);
-                        NetworkBehaviour.NetworkVariableFields[k].WriteDelta(tmpWriter);
+                        var tempWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, MessagingSystem.FRAGMENTED_MESSAGE_MAX_SIZE);
+                        NetworkBehaviour.NetworkVariableFields[i].WriteDelta(tempWriter);
+                        BytePacker.WriteValueBitPacked(writer, tempWriter.Length);

-                        writer.WriteValueSafe((ushort)tmpWriter.Length);
-                        tmpWriter.CopyTo(writer);
+                        if (!writer.TryBeginWrite(tempWriter.Length))
+                        {
+                            throw new OverflowException($"Not enough space in the buffer to write {nameof(NetworkVariableDeltaMessage)}");
+                        }
+
+                        tempWriter.CopyTo(writer);
                    }
                    else
                    {
-                        NetworkBehaviour.NetworkVariableFields[k].WriteDelta(writer);
+                        networkVariable.WriteDelta(writer);
                    }

-                    if (!NetworkBehaviour.NetworkVariableIndexesToResetSet.Contains(k))
+                    if (!NetworkBehaviour.NetworkVariableIndexesToResetSet.Contains(i))
                    {
-                        NetworkBehaviour.NetworkVariableIndexesToResetSet.Add(k);
-                        NetworkBehaviour.NetworkVariableIndexesToReset.Add(k);
+                        NetworkBehaviour.NetworkVariableIndexesToResetSet.Add(i);
+                        NetworkBehaviour.NetworkVariableIndexesToReset.Add(i);
                    }

                    NetworkBehaviour.NetworkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
-                        ClientId,
+                        TargetClientId,
                        NetworkBehaviour.NetworkObject,
-                        NetworkBehaviour.NetworkVariableFields[k].Name,
+                        networkVariable.Name,
                        NetworkBehaviour.__getTypeName(),
-                        writer.Length);
+                        writer.Length - startingSize);
                }
            }
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
+        {
+            if (!reader.TryBeginRead(FastBufferWriter.GetWriteSize(NetworkObjectId) + FastBufferWriter.GetWriteSize(NetworkBehaviourIndex)))
+            {
+                throw new OverflowException($"Not enough data in the buffer to read {nameof(NetworkVariableDeltaMessage)}");
+            }
+
+            reader.ReadValue(out NetworkObjectId);
+            reader.ReadValue(out NetworkBehaviourIndex);
+
+            m_ReceivedNetworkVariableData = reader;
+
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
        {
            var networkManager = (NetworkManager)context.SystemOwner;

-            var message = new NetworkVariableDeltaMessage();
-            if (!reader.TryBeginRead(FastBufferWriter.GetWriteSize(message.NetworkObjectId) +
-                                      FastBufferWriter.GetWriteSize(message.NetworkBehaviourIndex)))
-            {
-                throw new OverflowException(
-                    $"Not enough data in the buffer to read {nameof(NetworkVariableDeltaMessage)}");
-            }
-            reader.ReadValue(out message.NetworkObjectId);
-            reader.ReadValue(out message.NetworkBehaviourIndex);
-            message.Handle(context.SenderId, reader, context, networkManager);
-        }
-
-        public void Handle(ulong senderId, FastBufferReader reader, in NetworkContext context, NetworkManager networkManager)
-        {
            if (networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out NetworkObject networkObject))
            {
-                NetworkBehaviour behaviour = networkObject.GetNetworkBehaviourAtOrderIndex(NetworkBehaviourIndex);
+                var networkBehaviour = networkObject.GetNetworkBehaviourAtOrderIndex(NetworkBehaviourIndex);

-                if (behaviour == null)
+                if (networkBehaviour == null)
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
@@ -124,13 +142,12 @@ namespace Unity.Netcode
                }
                else
                {
-                    for (int i = 0; i < behaviour.NetworkVariableFields.Count; i++)
+                    for (int i = 0; i < networkBehaviour.NetworkVariableFields.Count; i++)
                    {
-                        ushort varSize = 0;
-
+                        int varSize = 0;
                        if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                        {
-                            reader.ReadValueSafe(out varSize);
+                            ByteUnpacker.ReadValueBitPacked(m_ReceivedNetworkVariableData, out varSize);

                            if (varSize == 0)
                            {
@@ -139,25 +156,27 @@ namespace Unity.Netcode
                        }
                        else
                        {
-                            reader.ReadValueSafe(out bool deltaExists);
+                            m_ReceivedNetworkVariableData.ReadValueSafe(out bool deltaExists);
                            if (!deltaExists)
                            {
                                continue;
                            }
                        }

-                        if (networkManager.IsServer)
+                        var networkVariable = networkBehaviour.NetworkVariableFields[i];
+
+                        if (networkManager.IsServer && !networkVariable.CanClientWrite(context.SenderId))
                        {
                            // we are choosing not to fire an exception here, because otherwise a malicious client could use this to crash the server
                            if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                            {
-                                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                                if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
                                {
-                                    NetworkLog.LogWarning($"Client wrote to {typeof(NetworkVariable<>).Name} without permission. => {nameof(NetworkObjectId)}: {NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {networkObject.GetNetworkBehaviourOrderIndex(behaviour)} - VariableIndex: {i}");
-                                    NetworkLog.LogError($"[{behaviour.NetworkVariableFields[i].GetType().Name}]");
+                                    NetworkLog.LogWarning($"Client wrote to {typeof(NetworkVariable<>).Name} without permission. => {nameof(NetworkObjectId)}: {NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {networkObject.GetNetworkBehaviourOrderIndex(networkBehaviour)} - VariableIndex: {i}");
+                                    NetworkLog.LogError($"[{networkVariable.GetType().Name}]");
                                }

-                                reader.Seek(reader.Position + varSize);
+                                m_ReceivedNetworkVariableData.Seek(m_ReceivedNetworkVariableData.Position + varSize);
                                continue;
                            }

@@ -168,47 +187,45 @@ namespace Unity.Netcode
                            //A dummy read COULD be added to the interface for this situation, but it's just being too nice.
                            //This is after all a developer fault. A critical error should be fine.
                            // - TwoTen
-                            if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                            if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
                            {
-                                NetworkLog.LogError($"Client wrote to {typeof(NetworkVariable<>).Name} without permission. No more variables can be read. This is critical. => {nameof(NetworkObjectId)}: {NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {networkObject.GetNetworkBehaviourOrderIndex(behaviour)} - VariableIndex: {i}");
-                                NetworkLog.LogError($"[{behaviour.NetworkVariableFields[i].GetType().Name}]");
+                                NetworkLog.LogError($"Client wrote to {typeof(NetworkVariable<>).Name} without permission. No more variables can be read. This is critical. => {nameof(NetworkObjectId)}: {NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {networkObject.GetNetworkBehaviourOrderIndex(networkBehaviour)} - VariableIndex: {i}");
+                                NetworkLog.LogError($"[{networkVariable.GetType().Name}]");
                            }

                            return;
                        }
-                        int readStartPos = reader.Position;
+                        int readStartPos = m_ReceivedNetworkVariableData.Position;

-                        behaviour.NetworkVariableFields[i].ReadDelta(reader, networkManager.IsServer);
+                        networkVariable.ReadDelta(m_ReceivedNetworkVariableData, networkManager.IsServer);

                        networkManager.NetworkMetrics.TrackNetworkVariableDeltaReceived(
-                            senderId,
+                            context.SenderId,
                            networkObject,
-                            behaviour.NetworkVariableFields[i].Name,
-                            behaviour.__getTypeName(),
-                            reader.Length);
+                            networkVariable.Name,
+                            networkBehaviour.__getTypeName(),
+                            context.MessageSize);


                        if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                        {
-                            if (reader.Position > (readStartPos + varSize))
+                            if (m_ReceivedNetworkVariableData.Position > (readStartPos + varSize))
                            {
                                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                                {
-                                    NetworkLog.LogWarning(
-                                        $"Var delta read too far. {reader.Position - (readStartPos + varSize)} bytes. => {nameof(NetworkObjectId)}: {NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {networkObject.GetNetworkBehaviourOrderIndex(behaviour)} - VariableIndex: {i}");
+                                    NetworkLog.LogWarning($"Var delta read too far. {m_ReceivedNetworkVariableData.Position - (readStartPos + varSize)} bytes. => {nameof(NetworkObjectId)}: {NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {networkObject.GetNetworkBehaviourOrderIndex(networkBehaviour)} - VariableIndex: {i}");
                                }

-                                reader.Seek(readStartPos + varSize);
+                                m_ReceivedNetworkVariableData.Seek(readStartPos + varSize);
                            }
-                            else if (reader.Position < (readStartPos + varSize))
+                            else if (m_ReceivedNetworkVariableData.Position < (readStartPos + varSize))
                            {
                                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                                {
-                                    NetworkLog.LogWarning(
-                                        $"Var delta read too little. {(readStartPos + varSize) - reader.Position} bytes. => {nameof(NetworkObjectId)}: {NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {networkObject.GetNetworkBehaviourOrderIndex(behaviour)} - VariableIndex: {i}");
+                                    NetworkLog.LogWarning($"Var delta read too little. {readStartPos + varSize - m_ReceivedNetworkVariableData.Position} bytes. => {nameof(NetworkObjectId)}: {NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {networkObject.GetNetworkBehaviourOrderIndex(networkBehaviour)} - VariableIndex: {i}");
                                }

-                                reader.Seek(readStartPos + varSize);
+                                m_ReceivedNetworkVariableData.Seek(readStartPos + varSize);
                            }
                        }
                    }
@@ -216,7 +233,7 @@ namespace Unity.Netcode
            }
            else
            {
-                networkManager.SpawnManager.TriggerOnSpawn(NetworkObjectId, reader, context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context);
            }
        }
    }
--- a/Runtime/Messaging/Messages/ParentSyncMessage.cs
+++ b/Runtime/Messaging/Messages/ParentSyncMessage.cs
@@ -26,42 +26,41 @@ namespace Unity.Netcode
            }
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
        {
            var networkManager = (NetworkManager)context.SystemOwner;
            if (!networkManager.IsClient)
            {
-                return;
+                return false;
            }

-            var message = new ParentSyncMessage();
-            reader.ReadValueSafe(out message.NetworkObjectId);
-            reader.ReadValueSafe(out message.IsReparented);
-            if (message.IsReparented)
+            reader.ReadValueSafe(out NetworkObjectId);
+            reader.ReadValueSafe(out IsReparented);
+            if (IsReparented)
            {
-                reader.ReadValueSafe(out message.IsLatestParentSet);
-                if (message.IsLatestParentSet)
+                reader.ReadValueSafe(out IsLatestParentSet);
+                if (IsLatestParentSet)
                {
                    reader.ReadValueSafe(out ulong latestParent);
-                    message.LatestParent = latestParent;
+                    LatestParent = latestParent;
                }
            }

-            message.Handle(reader, context, networkManager);
+            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+            {
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                return false;
            }

-        public void Handle(FastBufferReader reader, in NetworkContext context, NetworkManager networkManager)
-        {
-            if (networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
        {
+            var networkManager = (NetworkManager)context.SystemOwner;
            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
            networkObject.SetNetworkParenting(IsReparented, LatestParent);
            networkObject.ApplyNetworkParenting();
        }
-            else
-            {
-                networkManager.SpawnManager.TriggerOnSpawn(NetworkObjectId, reader, context);
-            }
-        }
    }
 }
--- a/Runtime/Messaging/Messages/RpcMessage.cs
+++ b/Runtime/Messaging/Messages/RpcMessage.cs
@@ -1,109 +0,0 @@
-using System;
-
-namespace Unity.Netcode
-{
-    internal struct RpcMessage : INetworkMessage
-    {
-        public enum RpcType : byte
-        {
-            Server,
-            Client
-        }
-
-        public struct HeaderData
-        {
-            public RpcType Type;
-            public ulong NetworkObjectId;
-            public ushort NetworkBehaviourId;
-            public uint NetworkMethodId;
-        }
-
-        public HeaderData Header;
-        public FastBufferWriter RpcData;
-
-
-        public unsafe void Serialize(FastBufferWriter writer)
-        {
-            if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize(Header) + RpcData.Length))
-            {
-                throw new OverflowException("Not enough space in the buffer to store RPC data.");
-            }
-            writer.WriteValue(Header);
-            writer.WriteBytes(RpcData.GetUnsafePtr(), RpcData.Length);
-        }
-
-        public static void Receive(FastBufferReader reader, in NetworkContext context)
-        {
-            var message = new RpcMessage();
-            if (!reader.TryBeginRead(FastBufferWriter.GetWriteSize(message.Header)))
-            {
-                throw new OverflowException("Not enough space in the buffer to read RPC data.");
-            }
-            reader.ReadValue(out message.Header);
-            message.Handle(reader, context, (NetworkManager)context.SystemOwner, context.SenderId, true);
-        }
-
-        public void Handle(FastBufferReader reader, in NetworkContext context, NetworkManager networkManager, ulong senderId, bool canDefer)
-        {
-            if (NetworkManager.__rpc_func_table.ContainsKey(Header.NetworkMethodId))
-            {
-                if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(Header.NetworkObjectId))
-                {
-                    if (canDefer)
-                    {
-                        networkManager.SpawnManager.TriggerOnSpawn(Header.NetworkObjectId, reader, context);
-                    }
-                    else
-                    {
-                        NetworkLog.LogError($"Tried to invoke an RPC on a non-existent {nameof(NetworkObject)} with {nameof(canDefer)}=false");
-                    }
-                    return;
-                }
-
-                var networkObject = networkManager.SpawnManager.SpawnedObjects[Header.NetworkObjectId];
-
-                var networkBehaviour = networkObject.GetNetworkBehaviourAtOrderIndex(Header.NetworkBehaviourId);
-                if (networkBehaviour == null)
-                {
-                    return;
-                }
-
-                var rpcParams = new __RpcParams();
-                switch (Header.Type)
-                {
-                    case RpcType.Server:
-                        rpcParams.Server = new ServerRpcParams
-                        {
-                            Receive = new ServerRpcReceiveParams
-                            {
-                                SenderClientId = senderId
-                            }
-                        };
-                        break;
-                    case RpcType.Client:
-                        rpcParams.Client = new ClientRpcParams
-                        {
-                            Receive = new ClientRpcReceiveParams
-                            {
-                            }
-                        };
-                        break;
-                }
-
-                NetworkManager.__rpc_func_table[Header.NetworkMethodId](networkBehaviour, reader, rpcParams);
-
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-                if (NetworkManager.__rpc_name_table.TryGetValue(Header.NetworkMethodId, out var rpcMethodName))
-                {
-                    networkManager.NetworkMetrics.TrackRpcReceived(
-                        senderId,
-                        networkObject,
-                        rpcMethodName,
-                        networkBehaviour.__getTypeName(),
-                        reader.Length);
-                }
-#endif
-            }
-        }
-    }
-}
--- a/Runtime/Messaging/Messages/RpcMessages.cs
+++ b/Runtime/Messaging/Messages/RpcMessages.cs
@@ -0,0 +1,157 @@
+using System;
+using UnityEngine;
+using Unity.Collections;
+
+namespace Unity.Netcode
+{
+    internal static class RpcMessageHelpers
+    {
+        public static unsafe void Serialize(ref FastBufferWriter writer, ref RpcMetadata metadata, ref FastBufferWriter payload)
+        {
+            if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize<RpcMetadata>() + payload.Length))
+            {
+                throw new OverflowException("Not enough space in the buffer to store RPC data.");
+            }
+
+            writer.WriteValue(metadata);
+            writer.WriteBytes(payload.GetUnsafePtr(), payload.Length);
+        }
+
+        public static unsafe bool Deserialize(ref FastBufferReader reader, ref NetworkContext context, ref RpcMetadata metadata, ref FastBufferReader payload)
+        {
+            int metadataSize = FastBufferWriter.GetWriteSize<RpcMetadata>();
+            if (!reader.TryBeginRead(metadataSize))
+            {
+                throw new InvalidOperationException("Not enough data in the buffer to read RPC meta.");
+            }
+
+            reader.ReadValue(out metadata);
+
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(metadata.NetworkObjectId))
+            {
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context);
+                return false;
+            }
+
+            var networkObject = networkManager.SpawnManager.SpawnedObjects[metadata.NetworkObjectId];
+            var networkBehaviour = networkManager.SpawnManager.SpawnedObjects[metadata.NetworkObjectId].GetNetworkBehaviourAtOrderIndex(metadata.NetworkBehaviourId);
+            if (networkBehaviour == null)
+            {
+                return false;
+            }
+
+            if (!NetworkManager.__rpc_func_table.ContainsKey(metadata.NetworkRpcMethodId))
+            {
+                return false;
+            }
+
+            payload = new FastBufferReader(reader.GetUnsafePtr() + metadataSize, Allocator.None, reader.Length - metadataSize);
+
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            if (NetworkManager.__rpc_name_table.TryGetValue(metadata.NetworkRpcMethodId, out var rpcMethodName))
+            {
+                networkManager.NetworkMetrics.TrackRpcReceived(
+                    context.SenderId,
+                    networkObject,
+                    rpcMethodName,
+                    networkBehaviour.__getTypeName(),
+                    reader.Length);
+            }
+#endif
+
+            return true;
+        }
+
+        public static void Handle(ref NetworkContext context, ref RpcMetadata metadata, ref FastBufferReader payload, ref __RpcParams rpcParams)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(metadata.NetworkObjectId, out var networkObject))
+            {
+                throw new InvalidOperationException($"An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
+            }
+            var networkBehaviour = networkObject.GetNetworkBehaviourAtOrderIndex(metadata.NetworkBehaviourId);
+
+            try
+            {
+                NetworkManager.__rpc_func_table[metadata.NetworkRpcMethodId](networkBehaviour, payload, rpcParams);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogException(new Exception("Unhandled RPC exception!", ex));
+            }
+        }
+    }
+
+    internal struct RpcMetadata : INetworkSerializeByMemcpy
+    {
+        public ulong NetworkObjectId;
+        public ushort NetworkBehaviourId;
+        public uint NetworkRpcMethodId;
+    }
+
+    internal struct ServerRpcMessage : INetworkMessage
+    {
+        public RpcMetadata Metadata;
+
+        public FastBufferWriter WriteBuffer;
+        public FastBufferReader ReadBuffer;
+
+        public unsafe void Serialize(FastBufferWriter writer)
+        {
+            RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
+        }
+
+        public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context)
+        {
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var rpcParams = new __RpcParams
+            {
+                Server = new ServerRpcParams
+                {
+                    Receive = new ServerRpcReceiveParams
+                    {
+                        SenderClientId = context.SenderId
+                    }
+                }
+            };
+            RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
+        }
+    }
+
+    internal struct ClientRpcMessage : INetworkMessage
+    {
+        public RpcMetadata Metadata;
+
+        public FastBufferWriter WriteBuffer;
+        public FastBufferReader ReadBuffer;
+
+        public void Serialize(FastBufferWriter writer)
+        {
+            RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
+        {
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var rpcParams = new __RpcParams
+            {
+                Client = new ClientRpcParams
+                {
+                    Receive = new ClientRpcReceiveParams
+                    {
+                    }
+                }
+            };
+            RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
+        }
+    }
+}
--- a/Runtime/Messaging/Messages/RpcMessages.cs.meta
+++ b/Runtime/Messaging/Messages/RpcMessages.cs.meta
--- a/Runtime/Messaging/Messages/SceneEventMessage.cs
+++ b/Runtime/Messaging/Messages/SceneEventMessage.cs
@@ -6,14 +6,22 @@ namespace Unity.Netcode
    {
        public SceneEventData EventData;

+        private FastBufferReader m_ReceivedData;
+
        public void Serialize(FastBufferWriter writer)
        {
            EventData.Serialize(writer);
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
        {
-            ((NetworkManager)context.SystemOwner).SceneManager.HandleSceneEvent(context.SenderId, reader);
+            m_ReceivedData = reader;
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            ((NetworkManager)context.SystemOwner).SceneManager.HandleSceneEvent(context.SenderId, m_ReceivedData);
        }
    }
 }
--- a/Runtime/Messaging/Messages/ServerLogMessage.cs
+++ b/Runtime/Messaging/Messages/ServerLogMessage.cs
@@ -17,21 +17,25 @@ namespace Unity.Netcode
            BytePacker.WriteValuePacked(writer, Message);
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
        {
            var networkManager = (NetworkManager)context.SystemOwner;
            if (networkManager.IsServer && networkManager.NetworkConfig.EnableNetworkLogs)
            {
-                var message = new ServerLogMessage();
-                reader.ReadValueSafe(out message.LogType);
-                ByteUnpacker.ReadValuePacked(reader, out message.Message);
-                message.Handle(context.SenderId, networkManager, reader.Length);
-            }
+                reader.ReadValueSafe(out LogType);
+                ByteUnpacker.ReadValuePacked(reader, out Message);
+                return true;
            }

-        public void Handle(ulong senderId, NetworkManager networkManager, int messageSize)
+            return false;
+        }
+
+        public void Handle(ref NetworkContext context)
        {
-            networkManager.NetworkMetrics.TrackServerLogReceived(senderId, (uint)LogType, messageSize);
+            var networkManager = (NetworkManager)context.SystemOwner;
+            var senderId = context.SenderId;
+
+            networkManager.NetworkMetrics.TrackServerLogReceived(senderId, (uint)LogType, context.MessageSize);

            switch (LogType)
            {
--- a/Runtime/Messaging/Messages/SnapshotDataMessage.cs
+++ b/Runtime/Messaging/Messages/SnapshotDataMessage.cs
@@ -1,172 +0,0 @@
-using System;
-using Unity.Collections;
-using Unity.Collections.LowLevel.Unsafe;
-using UnityEngine;
-
-namespace Unity.Netcode
-{
-    internal struct SnapshotDataMessage : INetworkMessage
-    {
-        public int CurrentTick;
-        public ushort Sequence;
-
-        public ushort Range;
-
-        public byte[] SendMainBuffer;
-        public NativeArray<byte> ReceiveMainBuffer;
-
-        public struct AckData
-        {
-            public ushort LastReceivedSequence;
-            public ushort ReceivedSequenceMask;
-        }
-
-        public AckData Ack;
-
-        public struct EntryData
-        {
-            public ulong NetworkObjectId;
-            public ushort BehaviourIndex;
-            public ushort VariableIndex;
-            public int TickWritten;
-            public ushort Position;
-            public ushort Length;
-        }
-
-        public NativeList<EntryData> Entries;
-
-        public struct SpawnData
-        {
-            public ulong NetworkObjectId;
-            public uint Hash;
-            public bool IsSceneObject;
-
-            public bool IsPlayerObject;
-            public ulong OwnerClientId;
-            public ulong ParentNetworkId;
-            public Vector3 Position;
-            public Quaternion Rotation;
-            public Vector3 Scale;
-
-            public int TickWritten;
-        }
-
-        public NativeList<SpawnData> Spawns;
-
-        public struct DespawnData
-        {
-            public ulong NetworkObjectId;
-            public int TickWritten;
-        }
-
-        public NativeList<DespawnData> Despawns;
-
-        public unsafe void Serialize(FastBufferWriter writer)
-        {
-            if (!writer.TryBeginWrite(
-                FastBufferWriter.GetWriteSize(CurrentTick) +
-                FastBufferWriter.GetWriteSize(Sequence) +
-                FastBufferWriter.GetWriteSize(Range) + Range +
-                FastBufferWriter.GetWriteSize(Ack) +
-                FastBufferWriter.GetWriteSize<ushort>() +
-                Entries.Length * sizeof(EntryData) +
-                FastBufferWriter.GetWriteSize<ushort>() +
-                Spawns.Length * sizeof(SpawnData) +
-                FastBufferWriter.GetWriteSize<ushort>() +
-                Despawns.Length * sizeof(DespawnData)
-            ))
-            {
-                Entries.Dispose();
-                Spawns.Dispose();
-                Despawns.Dispose();
-                throw new OverflowException($"Not enough space to serialize {nameof(SnapshotDataMessage)}");
-            }
-            writer.WriteValue(CurrentTick);
-            writer.WriteValue(Sequence);
-
-            writer.WriteValue(Range);
-            writer.WriteBytes(SendMainBuffer, Range);
-            writer.WriteValue(Ack);
-
-            writer.WriteValue((ushort)Entries.Length);
-            writer.WriteBytes((byte*)Entries.GetUnsafePtr(), Entries.Length * sizeof(EntryData));
-
-            writer.WriteValue((ushort)Spawns.Length);
-            writer.WriteBytes((byte*)Spawns.GetUnsafePtr(), Spawns.Length * sizeof(SpawnData));
-
-            writer.WriteValue((ushort)Despawns.Length);
-            writer.WriteBytes((byte*)Despawns.GetUnsafePtr(), Despawns.Length * sizeof(DespawnData));
-
-            Entries.Dispose();
-            Spawns.Dispose();
-            Despawns.Dispose();
-        }
-
-        public static unsafe void Receive(FastBufferReader reader, in NetworkContext context)
-        {
-            var message = new SnapshotDataMessage();
-            if (!reader.TryBeginRead(
-                FastBufferWriter.GetWriteSize(message.CurrentTick) +
-                FastBufferWriter.GetWriteSize(message.Sequence) +
-                FastBufferWriter.GetWriteSize(message.Range)
-            ))
-            {
-                throw new OverflowException($"Not enough space to deserialize {nameof(SnapshotDataMessage)}");
-            }
-            reader.ReadValue(out message.CurrentTick);
-            reader.ReadValue(out message.Sequence);
-
-            reader.ReadValue(out message.Range);
-            message.ReceiveMainBuffer = new NativeArray<byte>(message.Range, Allocator.Temp);
-            reader.ReadBytesSafe((byte*)message.ReceiveMainBuffer.GetUnsafePtr(), message.Range);
-            reader.ReadValueSafe(out message.Ack);
-
-            reader.ReadValueSafe(out ushort length);
-            message.Entries = new NativeList<EntryData>(length, Allocator.Temp);
-            message.Entries.Length = length;
-            reader.ReadBytesSafe((byte*)message.Entries.GetUnsafePtr(), message.Entries.Length * sizeof(EntryData));
-
-            reader.ReadValueSafe(out length);
-            message.Spawns = new NativeList<SpawnData>(length, Allocator.Temp);
-            message.Spawns.Length = length;
-            reader.ReadBytesSafe((byte*)message.Spawns.GetUnsafePtr(), message.Spawns.Length * sizeof(SpawnData));
-
-            reader.ReadValueSafe(out length);
-            message.Despawns = new NativeList<DespawnData>(length, Allocator.Temp);
-            message.Despawns.Length = length;
-            reader.ReadBytesSafe((byte*)message.Despawns.GetUnsafePtr(), message.Despawns.Length * sizeof(DespawnData));
-
-            using (message.ReceiveMainBuffer)
-            using (message.Entries)
-            using (message.Spawns)
-            using (message.Despawns)
-            {
-                message.Handle(context.SenderId, context.SystemOwner);
-            }
-        }
-
-        public void Handle(ulong senderId, object systemOwner)
-        {
-            if (systemOwner is NetworkManager)
-            {
-                var networkManager = (NetworkManager)systemOwner;
-
-                // todo: temporary hack around bug
-                if (!networkManager.IsServer)
-                {
-                    senderId = networkManager.ServerClientId;
-                }
-
-                var snapshotSystem = networkManager.SnapshotSystem;
-                snapshotSystem.HandleSnapshot(senderId, this);
-            }
-            else
-            {
-                var ownerData = (Tuple<SnapshotSystem, ulong>)systemOwner;
-                var snapshotSystem = ownerData.Item1;
-                snapshotSystem.HandleSnapshot(ownerData.Item2, this);
-                return;
-            }
-        }
-    }
-}
--- a/Runtime/Messaging/Messages/SnapshotDataMessage.cs.meta
+++ b/Runtime/Messaging/Messages/SnapshotDataMessage.cs.meta
@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 5cf75026c2ab86646aac16b39d7259ad
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Runtime/Messaging/Messages/TimeSyncMessage.cs
+++ b/Runtime/Messaging/Messages/TimeSyncMessage.cs
@@ -1,6 +1,6 @@
 namespace Unity.Netcode
 {
-    internal struct TimeSyncMessage : INetworkMessage
+    internal struct TimeSyncMessage : INetworkMessage, INetworkSerializeByMemcpy
    {
        public int Tick;

@@ -9,21 +9,22 @@ namespace Unity.Netcode
            writer.WriteValueSafe(this);
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
        {
            var networkManager = (NetworkManager)context.SystemOwner;
            if (!networkManager.IsClient)
            {
-                return;
+                return false;
            }
-            reader.ReadValueSafe(out TimeSyncMessage message);
-            message.Handle(context.SenderId, networkManager);
+            reader.ReadValueSafe(out this);
+            return true;
        }

-        public void Handle(ulong senderId, NetworkManager networkManager)
+        public void Handle(ref NetworkContext context)
        {
+            var networkManager = (NetworkManager)context.SystemOwner;
            var time = new NetworkTime(networkManager.NetworkTickSystem.TickRate, Tick);
-            networkManager.NetworkTimeSystem.Sync(time.Time, networkManager.NetworkConfig.NetworkTransport.GetCurrentRtt(senderId) / 1000d);
+            networkManager.NetworkTimeSystem.Sync(time.Time, networkManager.NetworkConfig.NetworkTransport.GetCurrentRtt(context.SenderId) / 1000d);
        }
    }
 }
--- a/Runtime/Messaging/Messages/UnnamedMessage.cs
+++ b/Runtime/Messaging/Messages/UnnamedMessage.cs
@@ -2,16 +2,23 @@ namespace Unity.Netcode
 {
    internal struct UnnamedMessage : INetworkMessage
    {
-        public FastBufferWriter Data;
+        public FastBufferWriter SendData;
+        private FastBufferReader m_ReceivedData;

        public unsafe void Serialize(FastBufferWriter writer)
        {
-            writer.WriteBytesSafe(Data.GetUnsafePtr(), Data.Length);
+            writer.WriteBytesSafe(SendData.GetUnsafePtr(), SendData.Length);
        }

-        public static void Receive(FastBufferReader reader, in NetworkContext context)
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
        {
-            ((NetworkManager)context.SystemOwner).CustomMessagingManager.InvokeUnnamedMessage(context.SenderId, reader, context.SerializedHeaderSize);
+            m_ReceivedData = reader;
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            ((NetworkManager)context.SystemOwner).CustomMessagingManager.InvokeUnnamedMessage(context.SenderId, m_ReceivedData, context.SerializedHeaderSize);
        }
    }
 }
--- a/Runtime/Messaging/MessagingSystem.cs
+++ b/Runtime/Messaging/MessagingSystem.cs
@@ -40,7 +40,7 @@ namespace Unity.Netcode
            }
        }

-        internal delegate void MessageHandler(FastBufferReader reader, in NetworkContext context);
+        internal delegate void MessageHandler(FastBufferReader reader, ref NetworkContext context, MessagingSystem system);

        private NativeList<ReceiveQueueItem> m_IncomingMessageQueue = new NativeList<ReceiveQueueItem>(16, Allocator.Persistent);

@@ -67,7 +67,7 @@ namespace Unity.Netcode
        }

        public const int NON_FRAGMENTED_MESSAGE_MAX_SIZE = 1300;
-        public const int FRAGMENTED_MESSAGE_MAX_SIZE = int.MaxValue;
+        public const int FRAGMENTED_MESSAGE_MAX_SIZE = BytePacker.BitPackedIntMax;

        internal struct MessageWithHandler
        {
@@ -118,7 +118,7 @@ namespace Unity.Netcode
            for (var queueIndex = 0; queueIndex < m_IncomingMessageQueue.Length; ++queueIndex)
            {
                // Avoid copies...
-                ref var item = ref m_IncomingMessageQueue.GetUnsafeList()->ElementAt(queueIndex);
+                ref var item = ref m_IncomingMessageQueue.ElementAt(queueIndex);
                item.Reader.Dispose();
            }

@@ -136,6 +136,11 @@ namespace Unity.Netcode
            m_Hooks.Add(hooks);
        }

+        public void Unhook(INetworkHooks hooks)
+        {
+            m_Hooks.Remove(hooks);
+        }
+
        private void RegisterMessageType(MessageWithHandler messageWithHandler)
        {
            m_MessageHandlers[m_HighMessageType] = messageWithHandler.Handler;
@@ -208,11 +213,11 @@ namespace Unity.Netcode
            }
        }

-        private bool CanReceive(ulong clientId, Type messageType)
+        private bool CanReceive(ulong clientId, Type messageType, FastBufferReader messageContent, ref NetworkContext context)
        {
            for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
            {
-                if (!m_Hooks[hookIdx].OnVerifyCanReceive(clientId, messageType))
+                if (!m_Hooks[hookIdx].OnVerifyCanReceive(clientId, messageType, messageContent, ref context))
                {
                    return false;
                }
@@ -236,10 +241,11 @@ namespace Unity.Netcode
                Timestamp = timestamp,
                Header = header,
                SerializedHeaderSize = serializedHeaderSize,
+                MessageSize = header.MessageSize,
            };

            var type = m_ReverseTypeMap[header.MessageType];
-            if (!CanReceive(senderId, type))
+            if (!CanReceive(senderId, type, reader, ref context))
            {
                reader.Dispose();
                return;
@@ -260,7 +266,7 @@ namespace Unity.Netcode
                // for some dynamic-length value.
                try
                {
-                    handler.Invoke(reader, context);
+                    handler.Invoke(reader, ref context, this);
                }
                catch (Exception e)
                {
@@ -278,7 +284,7 @@ namespace Unity.Netcode
            for (var index = 0; index < m_IncomingMessageQueue.Length; ++index)
            {
                // Avoid copies...
-                ref var item = ref m_IncomingMessageQueue.GetUnsafeList()->ElementAt(index);
+                ref var item = ref m_IncomingMessageQueue.ElementAt(index);
                HandleMessage(item.Header, item.Reader, item.SenderId, item.Timestamp, item.MessageHeaderSerializedSize);
                if (m_Disposed)
                {
@@ -313,12 +319,31 @@ namespace Unity.Netcode
            var queue = m_SendQueues[clientId];
            for (var i = 0; i < queue.Length; ++i)
            {
-                queue.GetUnsafeList()->ElementAt(i).Writer.Dispose();
+                queue.ElementAt(i).Writer.Dispose();
            }

            queue.Dispose();
        }

+        public static void ReceiveMessage<T>(FastBufferReader reader, ref NetworkContext context, MessagingSystem system) where T : INetworkMessage, new()
+        {
+            var message = new T();
+            if (message.Deserialize(reader, ref context))
+            {
+                for (var hookIdx = 0; hookIdx < system.m_Hooks.Count; ++hookIdx)
+                {
+                    system.m_Hooks[hookIdx].OnBeforeHandleMessage(ref message, ref context);
+                }
+
+                message.Handle(ref context);
+
+                for (var hookIdx = 0; hookIdx < system.m_Hooks.Count; ++hookIdx)
+                {
+                    system.m_Hooks[hookIdx].OnAfterHandleMessage(ref message, ref context);
+                }
+            }
+        }
+
        private bool CanSend(ulong clientId, Type messageType, NetworkDelivery delivery)
        {
            for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
@@ -332,7 +357,7 @@ namespace Unity.Netcode
            return true;
        }

-        internal unsafe int SendMessage<TMessageType, TClientIdListType>(in TMessageType message, NetworkDelivery delivery, in TClientIdListType clientIds)
+        internal int SendMessage<TMessageType, TClientIdListType>(ref TMessageType message, NetworkDelivery delivery, in TClientIdListType clientIds)
            where TMessageType : INetworkMessage
            where TClientIdListType : IReadOnlyList<ulong>
        {
@@ -347,11 +372,17 @@ namespace Unity.Netcode

            message.Serialize(tmpSerializer);

+            return SendPreSerializedMessage(tmpSerializer, maxSize, ref message, delivery, clientIds);
+        }
+
+        internal unsafe int SendPreSerializedMessage<TMessageType>(in FastBufferWriter tmpSerializer, int maxSize, ref TMessageType message, NetworkDelivery delivery, in IReadOnlyList<ulong> clientIds)
+            where TMessageType : INetworkMessage
+        {
            using var headerSerializer = new FastBufferWriter(FastBufferWriter.GetWriteSize<MessageHeader>(), Allocator.Temp);

            var header = new MessageHeader
            {
-                MessageSize = (ushort)tmpSerializer.Length,
+                MessageSize = (uint)tmpSerializer.Length,
                MessageType = m_MessageTypes[typeof(TMessageType)],
            };
            BytePacker.WriteValueBitPacked(headerSerializer, header.MessageType);
@@ -368,7 +399,7 @@ namespace Unity.Netcode

                for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                {
-                    m_Hooks[hookIdx].OnBeforeSendMessage(clientId, typeof(TMessageType), delivery);
+                    m_Hooks[hookIdx].OnBeforeSendMessage(clientId, ref message, delivery);
                }

                var sendQueueItem = m_SendQueues[clientId];
@@ -376,22 +407,22 @@ namespace Unity.Netcode
                {
                    sendQueueItem.Add(new SendQueueItem(delivery, NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.TempJob,
                        maxSize));
-                    sendQueueItem.GetUnsafeList()->ElementAt(0).Writer.Seek(sizeof(BatchHeader));
+                    sendQueueItem.ElementAt(0).Writer.Seek(sizeof(BatchHeader));
                }
                else
                {
-                    ref var lastQueueItem = ref sendQueueItem.GetUnsafeList()->ElementAt(sendQueueItem.Length - 1);
+                    ref var lastQueueItem = ref sendQueueItem.ElementAt(sendQueueItem.Length - 1);
                    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.GetUnsafeList()->ElementAt(sendQueueItem.Length - 1).Writer.Seek(sizeof(BatchHeader));
+                        sendQueueItem.ElementAt(sendQueueItem.Length - 1).Writer.Seek(sizeof(BatchHeader));
                    }
                }

-                ref var writeQueueItem = ref sendQueueItem.GetUnsafeList()->ElementAt(sendQueueItem.Length - 1);
+                ref var writeQueueItem = ref sendQueueItem.ElementAt(sendQueueItem.Length - 1);
                writeQueueItem.Writer.TryBeginWrite(tmpSerializer.Length + headerSerializer.Length);

                writeQueueItem.Writer.WriteBytes(headerSerializer.GetUnsafePtr(), headerSerializer.Length);
@@ -399,13 +430,20 @@ namespace Unity.Netcode
                writeQueueItem.BatchHeader.BatchSize++;
                for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                {
-                    m_Hooks[hookIdx].OnAfterSendMessage(clientId, typeof(TMessageType), delivery, tmpSerializer.Length + headerSerializer.Length);
+                    m_Hooks[hookIdx].OnAfterSendMessage(clientId, ref message, delivery, tmpSerializer.Length + headerSerializer.Length);
                }
            }

            return tmpSerializer.Length + headerSerializer.Length;
        }

+        internal unsafe int SendPreSerializedMessage<TMessageType>(in FastBufferWriter tmpSerializer, int maxSize, ref TMessageType message, NetworkDelivery delivery, ulong clientId)
+            where TMessageType : INetworkMessage
+        {
+            ulong* clientIds = stackalloc ulong[] { clientId };
+            return SendPreSerializedMessage(tmpSerializer, maxSize, ref message, delivery, new PointerListWrapper<ulong>(clientIds, 1));
+        }
+
        private struct PointerListWrapper<T> : IReadOnlyList<T>
            where T : unmanaged
        {
@@ -441,24 +479,24 @@ namespace Unity.Netcode
            }
        }

-        internal unsafe int SendMessage<T>(in T message, NetworkDelivery delivery,
+        internal unsafe int SendMessage<T>(ref T message, NetworkDelivery delivery,
            ulong* clientIds, int numClientIds)
            where T : INetworkMessage
        {
-            return SendMessage(message, delivery, new PointerListWrapper<ulong>(clientIds, numClientIds));
+            return SendMessage(ref message, delivery, new PointerListWrapper<ulong>(clientIds, numClientIds));
        }

-        internal unsafe int SendMessage<T>(in T message, NetworkDelivery delivery, ulong clientId)
+        internal unsafe int SendMessage<T>(ref T message, NetworkDelivery delivery, ulong clientId)
            where T : INetworkMessage
        {
            ulong* clientIds = stackalloc ulong[] { clientId };
-            return SendMessage(message, delivery, new PointerListWrapper<ulong>(clientIds, 1));
+            return SendMessage(ref message, delivery, new PointerListWrapper<ulong>(clientIds, 1));
        }

-        internal unsafe int SendMessage<T>(in T message, NetworkDelivery delivery, in NativeArray<ulong> clientIds)
+        internal unsafe int SendMessage<T>(ref T message, NetworkDelivery delivery, in NativeArray<ulong> clientIds)
            where T : INetworkMessage
        {
-            return SendMessage(message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length));
+            return SendMessage(ref message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length));
        }

        internal unsafe void ProcessSendQueues()
@@ -469,7 +507,7 @@ namespace Unity.Netcode
                var sendQueueItem = kvp.Value;
                for (var i = 0; i < sendQueueItem.Length; ++i)
                {
-                    ref var queueItem = ref sendQueueItem.GetUnsafeList()->ElementAt(i);
+                    ref var queueItem = ref sendQueueItem.ElementAt(i);
                    if (queueItem.BatchHeader.BatchSize == 0)
                    {
                        queueItem.Writer.Dispose();
--- a/Runtime/Messaging/NetworkContext.cs
+++ b/Runtime/Messaging/NetworkContext.cs
@@ -30,5 +30,10 @@ namespace Unity.Netcode
        /// The actual serialized size of the header when packed into the buffer
        /// </summary>
        public int SerializedHeaderSize;
+
+        /// <summary>
+        /// The size of the message in the buffer, header excluded
+        /// </summary>
+        public uint MessageSize;
    }
 }
--- a/Runtime/Metrics/INetworkMetrics.cs
+++ b/Runtime/Metrics/INetworkMetrics.cs
@@ -83,6 +83,18 @@ namespace Unity.Netcode

        void TrackSceneEventReceived(ulong senderClientId, uint sceneEventType, string sceneName, long bytesCount);

+        void TrackPacketSent(uint packetCount);
+
+        void TrackPacketReceived(uint packetCount);
+
+        void UpdateRttToServer(int rtt);
+
+        void UpdateNetworkObjectsCount(int count);
+
+        void UpdateConnectionsCount(int count);
+
+        void UpdatePacketLoss(float packetLoss);
+
        void DispatchFrame();
    }
 }
--- a/Runtime/Metrics/MetricHooks.cs
+++ b/Runtime/Metrics/MetricHooks.cs
@@ -11,14 +11,13 @@ namespace Unity.Netcode
            m_NetworkManager = networkManager;
        }

-
-        public void OnBeforeSendMessage(ulong clientId, Type messageType, NetworkDelivery delivery)
+        public void OnBeforeSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery) where T : INetworkMessage
        {
        }

-        public void OnAfterSendMessage(ulong clientId, Type messageType, NetworkDelivery delivery, int messageSizeBytes)
+        public void OnAfterSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery, int messageSizeBytes) where T : INetworkMessage
        {
-            m_NetworkManager.NetworkMetrics.TrackNetworkMessageSent(clientId, messageType.Name, messageSizeBytes);
+            m_NetworkManager.NetworkMetrics.TrackNetworkMessageSent(clientId, typeof(T).Name, messageSizeBytes);
        }

        public void OnBeforeReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
@@ -53,9 +52,19 @@ namespace Unity.Netcode
            return true;
        }

-        public bool OnVerifyCanReceive(ulong senderId, Type messageType)
+        public bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context)
        {
            return true;
        }
+
+        public void OnBeforeHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
+        {
+            // TODO: Per-message metrics recording moved here
+        }
+
+        public void OnAfterHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
+        {
+            // TODO: Per-message metrics recording moved here
+        }
    }
 }
--- a/Runtime/Metrics/NetworkMetrics.cs
+++ b/Runtime/Metrics/NetworkMetrics.cs
@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using Unity.Multiplayer.Tools;
 using Unity.Multiplayer.Tools.MetricTypes;
 using Unity.Multiplayer.Tools.NetStats;
+using Unity.Profiling;
 using UnityEngine;

 namespace Unity.Netcode
@@ -14,6 +15,8 @@ namespace Unity.Netcode

        static Dictionary<uint, string> s_SceneEventTypeNames;

+        static ProfilerMarker s_FrameDispatch = new ProfilerMarker($"{nameof(NetworkMetrics)}.DispatchFrame");
+
        static NetworkMetrics()
        {
            s_SceneEventTypeNames = new Dictionary<uint, string>();
@@ -63,6 +66,30 @@ namespace Unity.Netcode
        private readonly EventMetric<SceneEventMetric> m_SceneEventSentEvent = new EventMetric<SceneEventMetric>(NetworkMetricTypes.SceneEventSent.Id);
        private readonly EventMetric<SceneEventMetric> m_SceneEventReceivedEvent = new EventMetric<SceneEventMetric>(NetworkMetricTypes.SceneEventReceived.Id);

+#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
+        private readonly Counter m_PacketSentCounter = new Counter(NetworkMetricTypes.PacketsSent.Id)
+        {
+            ShouldResetOnDispatch = true,
+        };
+        private readonly Counter m_PacketReceivedCounter = new Counter(NetworkMetricTypes.PacketsReceived.Id)
+        {
+            ShouldResetOnDispatch = true,
+        };
+        private readonly Gauge m_RttToServerGauge = new Gauge(NetworkMetricTypes.RttToServer.Id)
+        {
+            ShouldResetOnDispatch = true,
+        };
+        private readonly Gauge m_NetworkObjectsGauge = new Gauge(NetworkMetricTypes.NetworkObjects.Id)
+        {
+            ShouldResetOnDispatch = true,
+        };
+        private readonly Gauge m_ConnectionsGauge = new Gauge(NetworkMetricTypes.ConnectedClients.Id)
+        {
+            ShouldResetOnDispatch = true,
+        };
+        private readonly Gauge m_PacketLossGauge = new Gauge(NetworkMetricTypes.PacketLoss.Id);
+#endif
+
        private ulong m_NumberOfMetricsThisFrame;

        public NetworkMetrics()
@@ -79,6 +106,13 @@ namespace Unity.Netcode
                .WithMetricEvents(m_RpcSentEvent, m_RpcReceivedEvent)
                .WithMetricEvents(m_ServerLogSentEvent, m_ServerLogReceivedEvent)
                .WithMetricEvents(m_SceneEventSentEvent, m_SceneEventReceivedEvent)
+#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
+                .WithCounters(m_PacketSentCounter, m_PacketReceivedCounter)
+                .WithGauges(m_RttToServerGauge)
+                .WithGauges(m_NetworkObjectsGauge)
+                .WithGauges(m_ConnectionsGauge)
+                .WithGauges(m_PacketLossGauge)
+#endif
                .Build();

            Dispatcher.RegisterObserver(NetcodeObserver.Observer);
@@ -404,9 +438,85 @@ namespace Unity.Netcode
            IncrementMetricCount();
        }

+        public void TrackPacketSent(uint packetCount)
+        {
+#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
+            if (!CanSendMetrics)
+            {
+                return;
+            }
+
+            m_PacketSentCounter.Increment(packetCount);
+            IncrementMetricCount();
+#endif
+        }
+
+        public void TrackPacketReceived(uint packetCount)
+        {
+#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
+            if (!CanSendMetrics)
+            {
+                return;
+            }
+
+            m_PacketReceivedCounter.Increment(packetCount);
+            IncrementMetricCount();
+#endif
+        }
+
+        public void UpdateRttToServer(int rttMilliseconds)
+        {
+#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
+            if (!CanSendMetrics)
+            {
+                return;
+            }
+            var rttSeconds = rttMilliseconds * 1e-3;
+            m_RttToServerGauge.Set(rttSeconds);
+#endif
+        }
+
+        public void UpdateNetworkObjectsCount(int count)
+        {
+#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
+            if (!CanSendMetrics)
+            {
+                return;
+            }
+
+            m_NetworkObjectsGauge.Set(count);
+#endif
+        }
+
+        public void UpdateConnectionsCount(int count)
+        {
+#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
+            if (!CanSendMetrics)
+            {
+                return;
+            }
+
+            m_ConnectionsGauge.Set(count);
+#endif
+        }
+
+        public void UpdatePacketLoss(float packetLoss)
+        {
+#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
+            if (!CanSendMetrics)
+            {
+                return;
+            }
+
+            m_PacketLossGauge.Set(packetLoss);
+#endif
+        }
+
        public void DispatchFrame()
        {
+            s_FrameDispatch.Begin();
            Dispatcher.Dispatch();
+            s_FrameDispatch.End();
            m_NumberOfMetricsThisFrame = 0;
        }

--- a/Runtime/Metrics/NullNetworkMetrics.cs
+++ b/Runtime/Metrics/NullNetworkMetrics.cs
@@ -137,6 +137,30 @@ namespace Unity.Netcode
        {
        }

+        public void TrackPacketSent(uint packetCount)
+        {
+        }
+
+        public void TrackPacketReceived(uint packetCount)
+        {
+        }
+
+        public void UpdateRttToServer(int rtt)
+        {
+        }
+
+        public void UpdateNetworkObjectsCount(int count)
+        {
+        }
+
+        public void UpdateConnectionsCount(int count)
+        {
+        }
+
+        public void UpdatePacketLoss(float packetLoss)
+        {
+        }
+
        public void DispatchFrame()
        {
        }
--- a/Runtime/NetworkVariable/Collections/NetworkList.cs
+++ b/Runtime/NetworkVariable/Collections/NetworkList.cs
@@ -11,6 +11,7 @@ namespace Unity.Netcode
    public class NetworkList<T> : NetworkVariableBase where T : unmanaged, IEquatable<T>
    {
        private NativeList<T> m_List = new NativeList<T>(64, Allocator.Persistent);
+        private NativeList<T> m_ListAtLastReset = new NativeList<T>(64, Allocator.Persistent);
        private NativeList<NetworkListEvent<T>> m_DirtyEvents = new NativeList<NetworkListEvent<T>>(64, Allocator.Persistent);

        /// <summary>
@@ -24,17 +25,12 @@ namespace Unity.Netcode
        /// </summary>
        public event OnListChangedDelegate OnListChanged;

-        /// <summary>
-        /// Creates a NetworkList with the default value and settings
-        /// </summary>
        public NetworkList() { }

-        /// <summary>
-        /// Creates a NetworkList with the default value and custom settings
-        /// </summary>
-        /// <param name="readPerm">The read permission to use for the NetworkList</param>
-        /// <param name="values">The initial value to use for the NetworkList</param>
-        public NetworkList(NetworkVariableReadPermission readPerm, IEnumerable<T> values) : base(readPerm)
+        public NetworkList(IEnumerable<T> values = default,
+            NetworkVariableReadPermission readPerm = DefaultReadPerm,
+            NetworkVariableWritePermission writePerm = DefaultWritePerm)
+            : base(readPerm, writePerm)
        {
            foreach (var value in values)
            {
@@ -42,24 +38,15 @@ namespace Unity.Netcode
            }
        }

-        /// <summary>
-        /// Creates a NetworkList with a custom value and the default settings
-        /// </summary>
-        /// <param name="values">The initial value to use for the NetworkList</param>
-        public NetworkList(IEnumerable<T> values)
-        {
-            foreach (var value in values)
-            {
-                m_List.Add(value);
-
-            }
-        }
-
        /// <inheritdoc />
        public override void ResetDirty()
        {
            base.ResetDirty();
+            if (m_DirtyEvents.Length > 0)
+            {
                m_DirtyEvents.Clear();
+                m_ListAtLastReset.CopyFrom(m_List);
+            }
        }

        /// <inheritdoc />
@@ -85,34 +72,35 @@ namespace Unity.Netcode
            writer.WriteValueSafe((ushort)m_DirtyEvents.Length);
            for (int i = 0; i < m_DirtyEvents.Length; i++)
            {
-                writer.WriteValueSafe(m_DirtyEvents[i].Type);
-                switch (m_DirtyEvents[i].Type)
+                var element = m_DirtyEvents.ElementAt(i);
+                writer.WriteValueSafe(element.Type);
+                switch (element.Type)
                {
                    case NetworkListEvent<T>.EventType.Add:
                        {
-                            writer.WriteValueSafe(m_DirtyEvents[i].Value);
+                            NetworkVariableSerialization<T>.Write(writer, ref element.Value);
                        }
                        break;
                    case NetworkListEvent<T>.EventType.Insert:
                        {
-                            writer.WriteValueSafe(m_DirtyEvents[i].Index);
-                            writer.WriteValueSafe(m_DirtyEvents[i].Value);
+                            writer.WriteValueSafe(element.Index);
+                            NetworkVariableSerialization<T>.Write(writer, ref element.Value);
                        }
                        break;
                    case NetworkListEvent<T>.EventType.Remove:
                        {
-                            writer.WriteValueSafe(m_DirtyEvents[i].Value);
+                            NetworkVariableSerialization<T>.Write(writer, ref element.Value);
                        }
                        break;
                    case NetworkListEvent<T>.EventType.RemoveAt:
                        {
-                            writer.WriteValueSafe(m_DirtyEvents[i].Index);
+                            writer.WriteValueSafe(element.Index);
                        }
                        break;
                    case NetworkListEvent<T>.EventType.Value:
                        {
-                            writer.WriteValueSafe(m_DirtyEvents[i].Index);
-                            writer.WriteValueSafe(m_DirtyEvents[i].Value);
+                            writer.WriteValueSafe(element.Index);
+                            NetworkVariableSerialization<T>.Write(writer, ref element.Value);
                        }
                        break;
                    case NetworkListEvent<T>.EventType.Clear:
@@ -127,10 +115,10 @@ namespace Unity.Netcode
        /// <inheritdoc />
        public override void WriteField(FastBufferWriter writer)
        {
-            writer.WriteValueSafe((ushort)m_List.Length);
-            for (int i = 0; i < m_List.Length; i++)
+            writer.WriteValueSafe((ushort)m_ListAtLastReset.Length);
+            for (int i = 0; i < m_ListAtLastReset.Length; i++)
            {
-                writer.WriteValueSafe(m_List[i]);
+                NetworkVariableSerialization<T>.Write(writer, ref m_ListAtLastReset.ElementAt(i));
            }
        }

@@ -141,7 +129,7 @@ namespace Unity.Netcode
            reader.ReadValueSafe(out ushort count);
            for (int i = 0; i < count; i++)
            {
-                reader.ReadValueSafe(out T value);
+                NetworkVariableSerialization<T>.Read(reader, out T value);
                m_List.Add(value);
            }
        }
@@ -157,7 +145,7 @@ namespace Unity.Netcode
                {
                    case NetworkListEvent<T>.EventType.Add:
                        {
-                            reader.ReadValueSafe(out T value);
+                            NetworkVariableSerialization<T>.Read(reader, out T value);
                            m_List.Add(value);

                            if (OnListChanged != null)
@@ -184,7 +172,7 @@ namespace Unity.Netcode
                    case NetworkListEvent<T>.EventType.Insert:
                        {
                            reader.ReadValueSafe(out int index);
-                            reader.ReadValueSafe(out T value);
+                            NetworkVariableSerialization<T>.Read(reader, out T value);
                            m_List.InsertRangeWithBeginEnd(index, index + 1);
                            m_List[index] = value;

@@ -211,7 +199,7 @@ namespace Unity.Netcode
                        break;
                    case NetworkListEvent<T>.EventType.Remove:
                        {
-                            reader.ReadValueSafe(out T value);
+                            NetworkVariableSerialization<T>.Read(reader, out T value);
                            int index = m_List.IndexOf(value);
                            if (index == -1)
                            {
@@ -271,7 +259,7 @@ namespace Unity.Netcode
                    case NetworkListEvent<T>.EventType.Value:
                        {
                            reader.ReadValueSafe(out int index);
-                            reader.ReadValueSafe(out T value);
+                            NetworkVariableSerialization<T>.Read(reader, out T value);
                            if (index >= m_List.Length)
                            {
                                throw new Exception("Shouldn't be here, index is higher than list length");
@@ -472,6 +460,7 @@ namespace Unity.Netcode
        public override void Dispose()
        {
            m_List.Dispose();
+            m_ListAtLastReset.Dispose();
            m_DirtyEvents.Dispose();
        }
    }
--- a/Runtime/NetworkVariable/NetworkVariable.cs
+++ b/Runtime/NetworkVariable/NetworkVariable.cs
@@ -1,5 +1,7 @@
 using UnityEngine;
 using System;
+using System.Runtime.CompilerServices;
+using Unity.Collections.LowLevel.Unsafe;

 namespace Unity.Netcode
 {
@@ -9,55 +11,6 @@ namespace Unity.Netcode
    [Serializable]
    public class NetworkVariable<T> : NetworkVariableBase where T : unmanaged
    {
-        // Functions that know how to serialize INetworkSerializable
-        internal static void WriteNetworkSerializable<TForMethod>(FastBufferWriter writer, ref TForMethod value)
-            where TForMethod : INetworkSerializable, new()
-        {
-            writer.WriteNetworkSerializable(value);
-        }
-        internal static void ReadNetworkSerializable<TForMethod>(FastBufferReader reader, out TForMethod value)
-            where TForMethod : INetworkSerializable, new()
-        {
-            reader.ReadNetworkSerializable(out value);
-        }
-
-        // Functions that serialize other types
-        private static void WriteValue<TForMethod>(FastBufferWriter writer, ref TForMethod value) where TForMethod : unmanaged
-        {
-            writer.WriteValueSafe(value);
-        }
-
-        private static void ReadValue<TForMethod>(FastBufferReader reader, out TForMethod value)
-            where TForMethod : unmanaged
-        {
-            reader.ReadValueSafe(out value);
-        }
-
-        internal delegate void WriteDelegate<TForMethod>(FastBufferWriter writer, ref TForMethod value);
-
-        internal delegate void ReadDelegate<TForMethod>(FastBufferReader reader, out TForMethod value);
-
-        // These static delegates provide the right implementation for writing and reading a particular network variable
-        // type.
-        //
-        // For most types, these default to WriteValue() and ReadValue(), which perform simple memcpy operations.
-        //
-        // INetworkSerializableILPP will generate startup code that will set it to WriteNetworkSerializable()
-        // and ReadNetworkSerializable() for INetworkSerializable types, which will call NetworkSerialize().
-        //
-        // In the future we may be able to use this to provide packing implementations for floats and integers to
-        // optimize bandwidth usage.
-        //
-        // The reason this is done is to avoid runtime reflection and boxing in NetworkVariable - without this,
-        // NetworkVariable would need to do a `var is INetworkSerializable` check, and then cast to INetworkSerializable,
-        // *both* of which would cause a boxing allocation. Alternatively, NetworkVariable could have been split into
-        // NetworkVariable and NetworkSerializableVariable or something like that, which would have caused a poor
-        // user experience and an API that's easier to get wrong than right. This is a bit ugly on the implementation
-        // side, but it gets the best achievable user experience and performance.
-        internal static WriteDelegate<T> Write = WriteValue;
-        internal static ReadDelegate<T> Read = ReadValue;
-
-
        /// <summary>
        /// Delegate type for value changed event
        /// </summary>
@@ -69,38 +22,11 @@ namespace Unity.Netcode
        /// </summary>
        public OnValueChangedDelegate OnValueChanged;

-        /// <summary>
-        /// Creates a NetworkVariable with the default value and custom read permission
-        /// </summary>
-        /// <param name="readPerm">The read permission for the NetworkVariable</param>

-        public NetworkVariable()
-        {
-        }
-
-        /// <summary>
-        /// Creates a NetworkVariable with the default value and custom read permission
-        /// </summary>
-        /// <param name="readPerm">The read permission for the NetworkVariable</param>
-        public NetworkVariable(NetworkVariableReadPermission readPerm) : base(readPerm)
-        {
-        }
-
-        /// <summary>
-        /// Creates a NetworkVariable with a custom value and custom settings
-        /// </summary>
-        /// <param name="readPerm">The read permission for the NetworkVariable</param>
-        /// <param name="value">The initial value to use for the NetworkVariable</param>
-        public NetworkVariable(NetworkVariableReadPermission readPerm, T value) : base(readPerm)
-        {
-            m_InternalValue = value;
-        }
-
-        /// <summary>
-        /// Creates a NetworkVariable with a custom value and the default read permission
-        /// </summary>
-        /// <param name="value">The initial value to use for the NetworkVariable</param>
-        public NetworkVariable(T value)
+        public NetworkVariable(T value = default,
+            NetworkVariableReadPermission readPerm = DefaultReadPerm,
+            NetworkVariableWritePermission writePerm = DefaultWritePerm)
+            : base(readPerm, writePerm)
        {
            m_InternalValue = value;
        }
@@ -116,19 +42,36 @@ namespace Unity.Netcode
            get => m_InternalValue;
            set
            {
-                // this could be improved. The Networking Manager is not always initialized here
-                //  Good place to decouple network manager from the network variable
-
-                // Also, note this is not really very water-tight, if you are running as a host
-                //  we cannot tell if a NetworkVariable write is happening inside client-ish code
-                if (m_NetworkBehaviour && (m_NetworkBehaviour.NetworkManager.IsClient && !m_NetworkBehaviour.NetworkManager.IsHost))
+                // Compare bitwise
+                if (ValueEquals(ref m_InternalValue, ref value))
                {
-                    throw new InvalidOperationException("Client can't write to NetworkVariables");
+                    return;
                }
+
+                if (m_NetworkBehaviour && !CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+                {
+                    throw new InvalidOperationException("Client is not allowed to write to this NetworkVariable");
+                }
+
                Set(value);
            }
        }

+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overriden value checks
+        // Size is fixed
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe bool ValueEquals(ref T a, ref T b)
+        {
+            // get unmanaged pointers
+            var aptr = UnsafeUtility.AddressOf(ref a);
+            var bptr = UnsafeUtility.AddressOf(ref b);
+
+            // compare addresses
+            return UnsafeUtility.MemCmp(aptr, bptr, sizeof(T)) == 0;
+        }
+
+
        private protected void Set(T value)
        {
            m_IsDirty = true;
@@ -146,7 +89,6 @@ namespace Unity.Netcode
            WriteField(writer);
        }

-
        /// <summary>
        /// Reads value from the reader and applies it
        /// </summary>
@@ -154,8 +96,13 @@ namespace Unity.Netcode
        /// <param name="keepDirtyDelta">Whether or not the container should keep the dirty delta, or mark the delta as consumed</param>
        public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
        {
+            // todo:
+            // keepDirtyDelta marks a variable received as dirty and causes the server to send the value to clients
+            // In a prefect world, whether a variable was A) modified locally or B) received and needs retransmit
+            // would be stored in different fields
+
            T previousValue = m_InternalValue;
-            Read(reader, out m_InternalValue);
+            NetworkVariableSerialization<T>.Read(reader, out m_InternalValue);

            if (keepDirtyDelta)
            {
@@ -168,13 +115,13 @@ namespace Unity.Netcode
        /// <inheritdoc />
        public override void ReadField(FastBufferReader reader)
        {
-            Read(reader, out m_InternalValue);
+            NetworkVariableSerialization<T>.Read(reader, out m_InternalValue);
        }

        /// <inheritdoc />
        public override void WriteField(FastBufferWriter writer)
        {
-            Write(writer, ref m_InternalValue);
+            NetworkVariableSerialization<T>.Write(writer, ref m_InternalValue);
        }
    }
 }
--- a/Runtime/NetworkVariable/NetworkVariableBase.cs
+++ b/Runtime/NetworkVariable/NetworkVariableBase.cs
@@ -10,7 +10,7 @@ namespace Unity.Netcode
        /// <summary>
        /// The delivery type (QoS) to send data with
        /// </summary>
-        internal const NetworkDelivery Delivery = NetworkDelivery.ReliableSequenced;
+        internal const NetworkDelivery Delivery = NetworkDelivery.ReliableFragmentedSequenced;

        private protected NetworkBehaviour m_NetworkBehaviour;

@@ -19,9 +19,15 @@ namespace Unity.Netcode
            m_NetworkBehaviour = networkBehaviour;
        }

-        protected NetworkVariableBase(NetworkVariableReadPermission readPermIn = NetworkVariableReadPermission.Everyone)
+        public const NetworkVariableReadPermission DefaultReadPerm = NetworkVariableReadPermission.Everyone;
+        public const NetworkVariableWritePermission DefaultWritePerm = NetworkVariableWritePermission.Server;
+
+        protected NetworkVariableBase(
+            NetworkVariableReadPermission readPerm = DefaultReadPerm,
+            NetworkVariableWritePermission writePerm = DefaultWritePerm)
        {
-            ReadPerm = readPermIn;
+            ReadPerm = readPerm;
+            WritePerm = writePerm;
        }

        private protected bool m_IsDirty;
@@ -37,6 +43,8 @@ namespace Unity.Netcode
        /// </summary>
        public readonly NetworkVariableReadPermission ReadPerm;

+        public readonly NetworkVariableWritePermission WritePerm;
+
        /// <summary>
        /// Sets whether or not the variable needs to be delta synced
        /// </summary>
@@ -62,26 +70,36 @@ namespace Unity.Netcode
            return m_IsDirty;
        }

-        public virtual bool ShouldWrite(ulong clientId, bool isServer)
-        {
-            return IsDirty() && isServer && CanClientRead(clientId);
-        }
-
-        /// <summary>
-        /// Gets Whether or not a specific client can read to the varaible
-        /// </summary>
-        /// <param name="clientId">The clientId of the remote client</param>
-        /// <returns>Whether or not the client can read to the variable</returns>
        public bool CanClientRead(ulong clientId)
        {
            switch (ReadPerm)
            {
+                default:
                case NetworkVariableReadPermission.Everyone:
                    return true;
-                case NetworkVariableReadPermission.OwnerOnly:
-                    return m_NetworkBehaviour.OwnerClientId == clientId;
+                case NetworkVariableReadPermission.Owner:
+                    return clientId == m_NetworkBehaviour.NetworkObject.OwnerClientId;
            }
-            return true;
+        }
+
+        public bool CanClientWrite(ulong clientId)
+        {
+            switch (WritePerm)
+            {
+                default:
+                case NetworkVariableWritePermission.Server:
+                    return clientId == NetworkManager.ServerClientId;
+                case NetworkVariableWritePermission.Owner:
+                    return clientId == m_NetworkBehaviour.NetworkObject.OwnerClientId;
+            }
+        }
+
+        /// <summary>
+        /// Returns the ClientId of the owning client
+        /// </summary>
+        internal ulong OwnerClientId()
+        {
+            return m_NetworkBehaviour.NetworkObject.OwnerClientId;
        }

        /// <summary>
@@ -107,7 +125,6 @@ namespace Unity.Netcode
        /// </summary>
        /// <param name="reader">The stream to read the delta from</param>
        /// <param name="keepDirtyDelta">Whether or not the delta should be kept as dirty or consumed</param>
-
        public abstract void ReadDelta(FastBufferReader reader, bool keepDirtyDelta);

        public virtual void Dispose()
--- a/Runtime/NetworkVariable/NetworkVariableHelper.cs
+++ b/Runtime/NetworkVariable/NetworkVariableHelper.cs
@@ -1,22 +0,0 @@
-namespace Unity.Netcode
-{
-    public class NetworkVariableHelper
-    {
-        // This is called by ILPP during module initialization for all unmanaged INetworkSerializable types
-        // This sets up NetworkVariable so that it properly calls NetworkSerialize() when wrapping an INetworkSerializable value
-        //
-        // The reason this is done is to avoid runtime reflection and boxing in NetworkVariable - without this,
-        // NetworkVariable would need to do a `var is INetworkSerializable` check, and then cast to INetworkSerializable,
-        // *both* of which would cause a boxing allocation. Alternatively, NetworkVariable could have been split into
-        // NetworkVariable and NetworkSerializableVariable or something like that, which would have caused a poor
-        // user experience and an API that's easier to get wrong than right. This is a bit ugly on the implementation
-        // side, but it gets the best achievable user experience and performance.
-        //
-        // RuntimeAccessModifiersILPP will make this `public`
-        internal static void InitializeDelegates<T>() where T : unmanaged, INetworkSerializable
-        {
-            NetworkVariable<T>.Write = NetworkVariable<T>.WriteNetworkSerializable;
-            NetworkVariable<T>.Read = NetworkVariable<T>.ReadNetworkSerializable;
-        }
-    }
-}
--- a/Runtime/NetworkVariable/NetworkVariableHelper.cs.meta
+++ b/Runtime/NetworkVariable/NetworkVariableHelper.cs.meta
@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: e54b65208bd3bbe4eaf62ca0384ae21f
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Runtime/NetworkVariable/NetworkVariablePermission.cs
+++ b/Runtime/NetworkVariable/NetworkVariablePermission.cs
@@ -1,18 +1,14 @@
 namespace Unity.Netcode
 {
-    /// <summary>
-    /// Permission type
-    /// </summary>
    public enum NetworkVariableReadPermission
    {
-        /// <summary>
-        /// Everyone
-        /// </summary>
        Everyone,
+        Owner,
+    }

-        /// <summary>
-        /// Owner-ownly
-        /// </summary>
-        OwnerOnly,
+    public enum NetworkVariableWritePermission
+    {
+        Server,
+        Owner
    }
 }
--- a/Runtime/NetworkVariable/NetworkVariableSerialization.cs
+++ b/Runtime/NetworkVariable/NetworkVariableSerialization.cs
@@ -0,0 +1,248 @@
+using System;
+using System.Collections.Generic;
+using Unity.Collections;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// Interface used by NetworkVariables to serialize them
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal interface INetworkVariableSerializer<T>
+    {
+        // Write has to be taken by ref here because of INetworkSerializable
+        // Open Instance Delegates (pointers to methods without an instance attached to them)
+        // require the first parameter passed to them (the instance) to be passed by ref.
+        // So foo.Bar() becomes BarDelegate(ref foo);
+        // Taking T as an in parameter like we do in other places would require making a copy
+        // of it to pass it as a ref parameter.
+        public void Write(FastBufferWriter writer, ref T value);
+        public void Read(FastBufferReader reader, out T value);
+    }
+
+    /// <summary>
+    /// Basic serializer for unmanaged types.
+    /// This covers primitives, built-in unity types, and IForceSerializeByMemcpy
+    /// Since all of those ultimately end up calling WriteUnmanagedSafe, this simplifies things
+    /// by calling that directly - thus preventing us from having to have a specific T that meets
+    /// the specific constraints that the various generic WriteValue calls require.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class UnmanagedTypeSerializer<T> : INetworkVariableSerializer<T> where T : unmanaged
+    {
+        public void Write(FastBufferWriter writer, ref T value)
+        {
+            writer.WriteUnmanagedSafe(value);
+        }
+        public void Read(FastBufferReader reader, out T value)
+        {
+            reader.ReadUnmanagedSafe(out value);
+        }
+    }
+
+    /// <summary>
+    /// Serializer for FixedStrings, which does the same thing FastBufferWriter/FastBufferReader do,
+    /// but is implemented to get the data it needs using open instance delegates that are passed in
+    /// via reflection. This prevents needing T to meet any interface requirements (which isn't achievable
+    /// without incurring GC allocs on every call to Write or Read - reflection + Open Instance Delegates
+    /// circumvent that.)
+    ///
+    /// Tests show that calling these delegates doesn't cause any GC allocations even though they're
+    /// obtained via reflection and Delegate.CreateDelegate() and called on types that, at compile time,
+    /// aren't known to actually contain those methods.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class FixedStringSerializer<T> : INetworkVariableSerializer<T> where T : unmanaged
+    {
+        internal delegate int GetLengthDelegate(ref T value);
+        internal delegate void SetLengthDelegate(ref T value, int length);
+        internal unsafe delegate byte* GetUnsafePtrDelegate(ref T value);
+
+        internal GetLengthDelegate GetLength;
+        internal SetLengthDelegate SetLength;
+        internal GetUnsafePtrDelegate GetUnsafePtr;
+
+        public unsafe void Write(FastBufferWriter writer, ref T value)
+        {
+            int length = GetLength(ref value);
+            byte* data = GetUnsafePtr(ref value);
+            writer.WriteUnmanagedSafe(length);
+            writer.WriteBytesSafe(data, length);
+        }
+        public unsafe void Read(FastBufferReader reader, out T value)
+        {
+            value = new T();
+            reader.ReadValueSafe(out int length);
+            SetLength(ref value, length);
+            reader.ReadBytesSafe(GetUnsafePtr(ref value), length);
+        }
+    }
+
+    /// <summary>
+    /// Serializer for INetworkSerializable types, which does the same thing
+    /// FastBufferWriter/FastBufferReader do, but is implemented to call the NetworkSerialize() method
+    /// via open instance delegates passed in via reflection. This prevents needing T to meet any interface
+    /// requirements (which isn't achievable without incurring GC allocs on every call to Write or Read -
+    /// reflection + Open Instance Delegates circumvent that.)
+    ///
+    /// Tests show that calling these delegates doesn't cause any GC allocations even though they're
+    /// obtained via reflection and Delegate.CreateDelegate() and called on types that, at compile time,
+    /// aren't known to actually contain those methods.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class NetworkSerializableSerializer<T> : INetworkVariableSerializer<T> where T : unmanaged
+    {
+        internal delegate void WriteValueDelegate(ref T value, BufferSerializer<BufferSerializerWriter> serializer);
+        internal delegate void ReadValueDelegate(ref T value, BufferSerializer<BufferSerializerReader> serializer);
+
+        internal WriteValueDelegate WriteValue;
+        internal ReadValueDelegate ReadValue;
+        public void Write(FastBufferWriter writer, ref T value)
+        {
+            var bufferSerializer = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(writer));
+            WriteValue(ref value, bufferSerializer);
+        }
+        public void Read(FastBufferReader reader, out T value)
+        {
+            value = new T();
+            var bufferSerializer = new BufferSerializer<BufferSerializerReader>(new BufferSerializerReader(reader));
+            ReadValue(ref value, bufferSerializer);
+        }
+    }
+
+    /// <summary>
+    /// This class is used to register user serialization with NetworkVariables for types
+    /// that are serialized via user serialization, such as with FastBufferReader and FastBufferWriter
+    /// extension methods. Finding those methods isn't achievable efficiently at runtime, so this allows
+    /// users to tell NetworkVariable about those extension methods (or simply pass in a lambda)
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class UserNetworkVariableSerialization<T>
+    {
+        public delegate void WriteValueDelegate(FastBufferWriter writer, in T value);
+        public delegate void ReadValueDelegate(FastBufferReader reader, out T value);
+
+        public static WriteValueDelegate WriteValue;
+        public static ReadValueDelegate ReadValue;
+    }
+
+    /// <summary>
+    /// This class is instantiated for types that we can't determine ahead of time are serializable - types
+    /// that don't meet any of the constraints for methods that are available on FastBufferReader and
+    /// FastBufferWriter. These types may or may not be serializable through extension methods. To ensure
+    /// the user has time to pass in the delegates to UserNetworkVariableSerialization, the existence
+    /// of user serialization isn't checked until it's used, so if no serialization is provided, this
+    /// will throw an exception when an object containing the relevant NetworkVariable is spawned.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class FallbackSerializer<T> : INetworkVariableSerializer<T>
+    {
+        public void Write(FastBufferWriter writer, ref T value)
+        {
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == 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}.");
+            }
+            UserNetworkVariableSerialization<T>.WriteValue(writer, value);
+        }
+        public void Read(FastBufferReader reader, out T value)
+        {
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == 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}.");
+            }
+            UserNetworkVariableSerialization<T>.ReadValue(reader, out value);
+        }
+    }
+
+    internal static class NetworkVariableSerializationTypes
+    {
+        internal static readonly HashSet<Type> BaseSupportedTypes = new HashSet<Type>
+        {
+            typeof(bool),
+            typeof(byte),
+            typeof(sbyte),
+            typeof(char),
+            typeof(decimal),
+            typeof(double),
+            typeof(float),
+            typeof(int),
+            typeof(uint),
+            typeof(long),
+            typeof(ulong),
+            typeof(short),
+            typeof(ushort),
+            typeof(Vector2),
+            typeof(Vector3),
+            typeof(Vector2Int),
+            typeof(Vector3Int),
+            typeof(Vector4),
+            typeof(Quaternion),
+            typeof(Color),
+            typeof(Color32),
+            typeof(Ray),
+            typeof(Ray2D)
+        };
+    }
+
+    /// <summary>
+    /// Support methods for reading/writing NetworkVariables
+    /// Because there are multiple overloads of WriteValue/ReadValue based on different generic constraints,
+    /// but there's no way to achieve the same thing with a class, this sets up various read/write schemes
+    /// based on which constraints are met by `T` using reflection, which is done at module load time.
+    /// </summary>
+    [Serializable]
+    public static class NetworkVariableSerialization<T> where T : unmanaged
+    {
+        private static INetworkVariableSerializer<T> s_Serializer = GetSerializer();
+
+        private static INetworkVariableSerializer<T> GetSerializer()
+        {
+            if (NetworkVariableSerializationTypes.BaseSupportedTypes.Contains(typeof(T)))
+            {
+                return new UnmanagedTypeSerializer<T>();
+            }
+            if (typeof(INetworkSerializeByMemcpy).IsAssignableFrom(typeof(T)))
+            {
+                return new UnmanagedTypeSerializer<T>();
+            }
+            if (typeof(Enum).IsAssignableFrom(typeof(T)))
+            {
+                return new UnmanagedTypeSerializer<T>();
+            }
+
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // Obtains "Open Instance Delegates" for the type's NetworkSerialize() methods -
+                // one for an instance of the generic method taking BufferSerializerWriter as T,
+                // one for an instance of the generic method taking BufferSerializerReader as T
+                var writeMethod = (NetworkSerializableSerializer<T>.WriteValueDelegate)Delegate.CreateDelegate(typeof(NetworkSerializableSerializer<T>.WriteValueDelegate), null, typeof(T).GetMethod(nameof(INetworkSerializable.NetworkSerialize)).MakeGenericMethod(typeof(BufferSerializerWriter)));
+                var readMethod = (NetworkSerializableSerializer<T>.ReadValueDelegate)Delegate.CreateDelegate(typeof(NetworkSerializableSerializer<T>.ReadValueDelegate), null, typeof(T).GetMethod(nameof(INetworkSerializable.NetworkSerialize)).MakeGenericMethod(typeof(BufferSerializerReader)));
+                return new NetworkSerializableSerializer<T> { WriteValue = writeMethod, ReadValue = readMethod };
+            }
+
+            if (typeof(IUTF8Bytes).IsAssignableFrom(typeof(T)) && typeof(INativeList<byte>).IsAssignableFrom(typeof(T)))
+            {
+                // Get "OpenInstanceDelegates" for the Length property (get and set, which are prefixed
+                // with "get_" and "set_" under the hood and emitted as methods) and GetUnsafePtr()
+                var getLength = (FixedStringSerializer<T>.GetLengthDelegate)Delegate.CreateDelegate(typeof(FixedStringSerializer<T>.GetLengthDelegate), null, typeof(T).GetMethod("get_" + nameof(INativeList<byte>.Length)));
+                var setLength = (FixedStringSerializer<T>.SetLengthDelegate)Delegate.CreateDelegate(typeof(FixedStringSerializer<T>.SetLengthDelegate), null, typeof(T).GetMethod("set_" + nameof(INativeList<byte>.Length)));
+                var getUnsafePtr = (FixedStringSerializer<T>.GetUnsafePtrDelegate)Delegate.CreateDelegate(typeof(FixedStringSerializer<T>.GetUnsafePtrDelegate), null, typeof(T).GetMethod(nameof(IUTF8Bytes.GetUnsafePtr)));
+                return new FixedStringSerializer<T> { GetLength = getLength, SetLength = setLength, GetUnsafePtr = getUnsafePtr };
+            }
+
+            return new FallbackSerializer<T>();
+        }
+
+        internal static void Write(FastBufferWriter writer, ref T value)
+        {
+            s_Serializer.Write(writer, ref value);
+        }
+
+        internal static void Read(FastBufferReader reader, out T value)
+        {
+            s_Serializer.Read(reader, out value);
+        }
+    }
+}
--- a/Runtime/NetworkVariable/NetworkVariableSerialization.cs.meta
+++ b/Runtime/NetworkVariable/NetworkVariableSerialization.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2c6ef5fdf2e94ec3b4ce8086d52700b3
+timeCreated: 1650985453
--- a/Runtime/Profiling/ProfilingHooks.cs
+++ b/Runtime/Profiling/ProfilingHooks.cs
@@ -37,14 +37,14 @@ namespace Unity.Netcode
            return marker;
        }

-        public void OnBeforeSendMessage(ulong clientId, Type messageType, NetworkDelivery delivery)
+        public void OnBeforeSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery) where T : INetworkMessage
        {
-            GetSenderProfilerMarker(messageType).Begin();
+            GetSenderProfilerMarker(typeof(T)).Begin();
        }

-        public void OnAfterSendMessage(ulong clientId, Type messageType, NetworkDelivery delivery, int messageSizeBytes)
+        public void OnAfterSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery, int messageSizeBytes) where T : INetworkMessage
        {
-            GetSenderProfilerMarker(messageType).End();
+            GetSenderProfilerMarker(typeof(T)).End();
        }

        public void OnBeforeReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
@@ -82,9 +82,19 @@ namespace Unity.Netcode
            return true;
        }

-        public bool OnVerifyCanReceive(ulong senderId, Type messageType)
+        public bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context)
        {
            return true;
        }
+
+        public void OnBeforeHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
+        {
+            // nop
+        }
+
+        public void OnAfterHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
+        {
+            // nop
+        }
    }
 }
--- a/Runtime/SceneManagement/ISceneManagerHandler.cs
+++ b/Runtime/SceneManagement/ISceneManagerHandler.cs
@@ -0,0 +1,34 @@
+using System;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// Used to override the LoadSceneAsync and UnloadSceneAsync methods called
+    /// within the NetworkSceneManager.
+    /// </summary>
+    internal interface ISceneManagerHandler
+    {
+        // Generic action to call when a scene is finished loading/unloading
+        struct SceneEventAction
+        {
+            internal uint SceneEventId;
+            internal Action<uint> EventAction;
+            /// <summary>
+            /// Used server-side for integration testing in order to
+            /// invoke the SceneEventProgress once done loading
+            /// </summary>
+            internal Action Completed;
+            internal void Invoke()
+            {
+                Completed?.Invoke();
+                EventAction.Invoke(SceneEventId);
+            }
+        }
+
+        AsyncOperation LoadSceneAsync(string sceneName, LoadSceneMode loadSceneMode, SceneEventAction sceneEventAction);
+
+        AsyncOperation UnloadSceneAsync(Scene scene, SceneEventAction sceneEventAction);
+    }
+}
--- a/Runtime/SceneManagement/ISceneManagerHandler.cs.meta
+++ b/Runtime/SceneManagement/ISceneManagerHandler.cs.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: bd9e1475e8c8e4a6d935fe2409e3bd26
+guid: de907a9fb8151e240800dbcc97f8e745
 MonoImporter:
  externalObjects: {}
  serializedVersion: 2
--- a/Runtime/SceneManagement/NetworkSceneManager.cs
+++ b/Runtime/SceneManagement/NetworkSceneManager.cs
--- a/Runtime/SceneManagement/SceneEventData.cs
+++ b/Runtime/SceneManagement/SceneEventData.cs
@@ -4,7 +4,6 @@ using System.Linq;
 using Unity.Collections;
 using UnityEngine.SceneManagement;

-
 namespace Unity.Netcode
 {
    /// <summary>
@@ -42,7 +41,6 @@ namespace Unity.Netcode
        /// <b>Invocation:</b> Server Side<br/>
        /// <b>Message Flow:</b> Server to client<br/>
        /// <b>Event Notification:</b> Both server and client receive a local notification<br/>
-        /// <em>Note: This will be removed once snapshot and buffered messages are finalized as it will no longer be needed at that point.</em>
        /// </summary>
        ReSynchronize,
        /// <summary>
@@ -93,13 +91,17 @@ namespace Unity.Netcode
    {
        internal SceneEventType SceneEventType;
        internal LoadSceneMode LoadSceneMode;
-        internal Guid SceneEventProgressId;
+        internal ForceNetworkSerializeByMemcpy<Guid> SceneEventProgressId;
        internal uint SceneEventId;


        internal uint SceneHash;
        internal int SceneHandle;

+        // Used by the client during synchronization
+        internal uint ClientSceneHash;
+        internal int NetworkSceneHandle;
+
        /// Only used for <see cref="SceneEventType.Synchronize"/> scene events, this assures permissions when writing
        /// NetworkVariable information.  If that process changes, then we need to update this
        internal ulong TargetClientId;
@@ -116,6 +118,9 @@ namespace Unity.Netcode
        /// </summary>
        private List<NetworkObject> m_NetworkObjectsSync = new List<NetworkObject>();

+        private List<NetworkObject> m_DespawnedInSceneObjectsSync = new List<NetworkObject>();
+        private Dictionary<int, List<uint>> m_DespawnedInSceneObjects = new Dictionary<int, List<uint>>();
+
        /// <summary>
        /// Server Side Re-Synchronization:
        /// If there happens to be NetworkObjects in the final Event_Sync_Complete message that are no longer spawned,
@@ -230,10 +235,30 @@ namespace Unity.Netcode

        internal void AddSpawnedNetworkObjects()
        {
-            m_NetworkObjectsSync = m_NetworkManager.SpawnManager.SpawnedObjectsList.ToList();
+            m_NetworkObjectsSync.Clear();
+            foreach (var sobj in m_NetworkManager.SpawnManager.SpawnedObjectsList)
+            {
+                if (sobj.Observers.Contains(TargetClientId))
+                {
+                    m_NetworkObjectsSync.Add(sobj);
+                }
+            }
            m_NetworkObjectsSync.Sort(SortNetworkObjects);
        }

+        internal void AddDespawnedInSceneNetworkObjects()
+        {
+            m_DespawnedInSceneObjectsSync.Clear();
+            var inSceneNetworkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>().Where((c) => c.NetworkManager == m_NetworkManager);
+            foreach (var sobj in inSceneNetworkObjects)
+            {
+                if (sobj.IsSceneObject.HasValue && sobj.IsSceneObject.Value && !sobj.IsSpawned)
+                {
+                    m_DespawnedInSceneObjectsSync.Add(sobj);
+                }
+            }
+        }
+
        /// <summary>
        /// Server Side:
        /// Used during the synchronization process to associate NetworkObjects with scenes
@@ -363,7 +388,6 @@ namespace Unity.Netcode
            writer.WriteValueSafe(ScenesToSynchronize.ToArray());
            writer.WriteValueSafe(SceneHandlesToSynchronize.ToArray());

-
            // Store our current position in the stream to come back and say how much data we have written
            var positionStart = writer.Position;

@@ -374,17 +398,31 @@ namespace Unity.Netcode
            int totalBytes = 0;

            // Write the number of NetworkObjects we are serializing
-            writer.WriteValueSafe(m_NetworkObjectsSync.Count());
+            BytePacker.WriteValuePacked(writer, m_NetworkObjectsSync.Count());
+            // Serialize all NetworkObjects that are spawned
            for (var i = 0; i < m_NetworkObjectsSync.Count(); ++i)
            {
                var noStart = writer.Position;
                var sceneObject = m_NetworkObjectsSync[i].GetMessageSceneObject(TargetClientId);
-                writer.WriteValueSafe(m_NetworkObjectsSync[i].gameObject.scene.handle);
+                BytePacker.WriteValuePacked(writer, m_NetworkObjectsSync[i].GetSceneOriginHandle());
                sceneObject.Serialize(writer);
                var noStop = writer.Position;
                totalBytes += (int)(noStop - noStart);
            }

+            // Write the number of despawned in-scene placed NetworkObjects
+            writer.WriteValueSafe(m_DespawnedInSceneObjectsSync.Count());
+            // Write the scene handle and GlobalObjectIdHash value
+            for (var i = 0; i < m_DespawnedInSceneObjectsSync.Count(); ++i)
+            {
+                var noStart = writer.Position;
+                var sceneObject = m_DespawnedInSceneObjectsSync[i].GetMessageSceneObject(TargetClientId);
+                BytePacker.WriteValuePacked(writer, m_DespawnedInSceneObjectsSync[i].GetSceneOriginHandle());
+                BytePacker.WriteValuePacked(writer, m_DespawnedInSceneObjectsSync[i].GlobalObjectIdHash);
+                var noStop = writer.Position;
+                totalBytes += (int)(noStop - noStart);
+            }
+
            // Size Place Holder -- End
            var positionEnd = writer.Position;
            var bytesWritten = (uint)(positionEnd - (positionStart + sizeof(uint)));
@@ -582,9 +620,6 @@ namespace Unity.Netcode
                        networkObject.IsSpawned = false;
                        if (m_NetworkManager.PrefabHandler.ContainsHandler(networkObject))
                        {
-                            // Since this is the client side and we have missed the delete message, until the Snapshot system is in place for spawn and despawn handling
-                            // we have to remove this from the list of spawned objects manually or when a NetworkObjectId is recycled the client will throw an error
-                            // about the id already being assigned.
                            if (m_NetworkManager.SpawnManager.SpawnedObjects.ContainsKey(networkObjectId))
                            {
                                m_NetworkManager.SpawnManager.SpawnedObjects.Remove(networkObjectId);
@@ -677,15 +712,16 @@ namespace Unity.Netcode
        {
            try
            {
-                // Process all NetworkObjects for this scene
-                InternalBuffer.ReadValueSafe(out int newObjectsCount);
+                // Process all spawned NetworkObjects for this network session
+                ByteUnpacker.ReadValuePacked(InternalBuffer, out int newObjectsCount);
+

                for (int i = 0; i < newObjectsCount; i++)
                {
                    // We want to make sure for each NetworkObject we have the appropriate scene selected as the scene that is
                    // currently being synchronized.  This assures in-scene placed NetworkObjects will use the right NetworkObject
                    // from the list of populated <see cref="NetworkSceneManager.ScenePlacedObjects"/>
-                    InternalBuffer.ReadValueSafe(out int handle);
+                    ByteUnpacker.ReadValuePacked(InternalBuffer, out int handle);
                    m_NetworkManager.SceneManager.SetTheSceneBeingSynchronized(handle);

                    var sceneObject = new NetworkObject.SceneObject();
@@ -697,6 +733,73 @@ namespace Unity.Netcode
                        m_NetworkObjectsSync.Add(spawnedNetworkObject);
                    }
                }
+
+                // Process all de-spawned in-scene NetworkObjects for this network session
+                m_DespawnedInSceneObjects.Clear();
+                InternalBuffer.ReadValueSafe(out int despawnedObjectsCount);
+                var sceneCache = new Dictionary<int, Dictionary<uint, NetworkObject>>();
+
+                for (int i = 0; i < despawnedObjectsCount; i++)
+                {
+                    // We just need to get the scene
+                    ByteUnpacker.ReadValuePacked(InternalBuffer, out int networkSceneHandle);
+                    ByteUnpacker.ReadValuePacked(InternalBuffer, out uint globalObjectIdHash);
+                    var sceneRelativeNetworkObjects = new Dictionary<uint, NetworkObject>();
+                    if (!sceneCache.ContainsKey(networkSceneHandle))
+                    {
+                        if (m_NetworkManager.SceneManager.ServerSceneHandleToClientSceneHandle.ContainsKey(networkSceneHandle))
+                        {
+                            var localSceneHandle = m_NetworkManager.SceneManager.ServerSceneHandleToClientSceneHandle[networkSceneHandle];
+                            if (m_NetworkManager.SceneManager.ScenesLoaded.ContainsKey(localSceneHandle))
+                            {
+                                var objectRelativeScene = m_NetworkManager.SceneManager.ScenesLoaded[localSceneHandle];
+                                var inSceneNetworkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>().Where((c) =>
+                                c.GetSceneOriginHandle() == localSceneHandle && (c.IsSceneObject != false)).ToList();
+
+                                foreach (var inSceneObject in inSceneNetworkObjects)
+                                {
+                                    sceneRelativeNetworkObjects.Add(inSceneObject.GlobalObjectIdHash, inSceneObject);
+                                }
+                                // Add this to a cache so we don't have to run this potentially multiple times (nothing will spawn or despawn during this time
+                                sceneCache.Add(networkSceneHandle, sceneRelativeNetworkObjects);
+                            }
+                            else
+                            {
+                                UnityEngine.Debug.LogError($"In-Scene NetworkObject GlobalObjectIdHash ({globalObjectIdHash}) cannot find its relative local scene handle {localSceneHandle}!");
+                            }
+                        }
+                        else
+                        {
+                            UnityEngine.Debug.LogError($"In-Scene NetworkObject GlobalObjectIdHash ({globalObjectIdHash}) cannot find its relative NetworkSceneHandle {networkSceneHandle}!");
+                        }
+                    }
+                    else // Use the cached NetworkObjects if they exist
+                    {
+                        sceneRelativeNetworkObjects = sceneCache[networkSceneHandle];
+                    }
+
+                    // Now find the in-scene NetworkObject with the current GlobalObjectIdHash we are looking for
+                    if (sceneRelativeNetworkObjects.ContainsKey(globalObjectIdHash))
+                    {
+                        // Since this is a NetworkObject that was never spawned, we just need to send a notification
+                        // out that it was despawned so users can make adjustments
+                        sceneRelativeNetworkObjects[globalObjectIdHash].InvokeBehaviourNetworkDespawn();
+                        if (!m_NetworkManager.SceneManager.ScenePlacedObjects.ContainsKey(globalObjectIdHash))
+                        {
+                            m_NetworkManager.SceneManager.ScenePlacedObjects.Add(globalObjectIdHash, new Dictionary<int, NetworkObject>());
+                        }
+
+                        if (!m_NetworkManager.SceneManager.ScenePlacedObjects[globalObjectIdHash].ContainsKey(sceneRelativeNetworkObjects[globalObjectIdHash].GetSceneOriginHandle()))
+                        {
+                            m_NetworkManager.SceneManager.ScenePlacedObjects[globalObjectIdHash].Add(sceneRelativeNetworkObjects[globalObjectIdHash].GetSceneOriginHandle(), sceneRelativeNetworkObjects[globalObjectIdHash]);
+                        }
+
+                    }
+                    else
+                    {
+                        UnityEngine.Debug.LogError($"In-Scene NetworkObject GlobalObjectIdHash ({globalObjectIdHash}) could not be found!");
+                    }
+                }
            }
            finally
            {
--- a/Runtime/SceneManagement/SceneEventProgress.cs
+++ b/Runtime/SceneManagement/SceneEventProgress.cs
@@ -61,9 +61,9 @@ namespace Unity.Netcode
        internal List<ulong> DoneClients { get; } = new List<ulong>();

        /// <summary>
-        /// The NetworkTime at the moment the scene switch was initiated by the server.
+        /// The local time when the scene event was "roughly started"
        /// </summary>
-        internal NetworkTime TimeAtInitiation { get; }
+        internal float TimeAtInitiation { get; }

        /// <summary>
        /// Delegate type for when the switch scene progress is completed. Either by all clients done loading the scene or by time out.
@@ -105,22 +105,40 @@ namespace Unity.Netcode

        internal LoadSceneMode LoadSceneMode;

+        internal List<ulong> ClientsThatStartedSceneEvent;
+
        internal SceneEventProgress(NetworkManager networkManager, SceneEventProgressStatus status = SceneEventProgressStatus.Started)
        {
            if (status == SceneEventProgressStatus.Started)
            {
+                // Track the clients that were connected when we started this event
+                ClientsThatStartedSceneEvent = new List<ulong>(networkManager.ConnectedClientsIds);
                m_NetworkManager = networkManager;
                m_TimeOutCoroutine = m_NetworkManager.StartCoroutine(TimeOutSceneEventProgress());
-                TimeAtInitiation = networkManager.LocalTime;
+                TimeAtInitiation = Time.realtimeSinceStartup;
            }
            Status = status;
        }

+        /// <summary>
+        /// Coroutine that checks to see if the scene event is complete every network tick period.
+        /// This will handle completing the scene event when one or more client(s) disconnect(s)
+        /// during a scene event and if it does not complete within the scene loading time out period
+        /// it will time out the scene event.
+        /// </summary>
        internal IEnumerator TimeOutSceneEventProgress()
        {
-            yield return new WaitForSecondsRealtime(m_NetworkManager.NetworkConfig.LoadSceneTimeOut);
-            TimedOut = true;
+            var waitForNetworkTick = new WaitForSeconds(1.0f / m_NetworkManager.NetworkConfig.TickRate);
+            while (!TimedOut && !IsCompleted)
+            {
+                yield return waitForNetworkTick;
+
                CheckCompletion();
+                if (!IsCompleted)
+                {
+                    TimedOut = TimeAtInitiation - Time.realtimeSinceStartup >= m_NetworkManager.NetworkConfig.LoadSceneTimeOut;
+                }
+            }
        }

        internal void AddClientAsDone(ulong clientId)
@@ -141,9 +159,25 @@ namespace Unity.Netcode
            m_SceneLoadOperation.completed += operation => CheckCompletion();
        }

-        internal void CheckCompletion()
+        /// <summary>
+        /// Called only on the server-side during integration test (NetcodeIntegrationTest specific)
+        /// scene loading and unloading.
+        ///
+        /// Note: During integration testing we must queue all scene loading and unloading requests for
+        /// both the server and all clients so they can be processed in a FIFO/linear fashion to avoid
+        /// conflicts when the  <see cref="SceneManager.sceneLoaded"/> and <see cref="SceneManager.sceneUnloaded"/>
+        /// events are triggered. The Completed action simulates the <see cref="AsyncOperation.completed"/> event.
+        /// (See: Unity.Netcode.TestHelpers.Runtime.IntegrationTestSceneHandler)
+        /// </summary>
+        internal void SetSceneLoadOperation(ISceneManagerHandler.SceneEventAction sceneEventAction)
        {
-            if ((!IsCompleted && DoneClients.Count == m_NetworkManager.ConnectedClientsList.Count && m_SceneLoadOperation.isDone) || (!IsCompleted && TimedOut))
+            sceneEventAction.Completed = SetComplete;
+        }
+
+        /// <summary>
+        /// Finalizes the SceneEventProgress
+        /// </summary>
+        internal void SetComplete()
        {
            IsCompleted = true;
            AreAllClientsDoneLoading = true;
@@ -155,6 +189,20 @@ namespace Unity.Netcode
            }
            m_NetworkManager.StopCoroutine(m_TimeOutCoroutine);
        }
+
+        internal void CheckCompletion()
+        {
+            try
+            {
+                if ((!IsCompleted && DoneClients.Count == m_NetworkManager.ConnectedClientsList.Count && (m_SceneLoadOperation == null || m_SceneLoadOperation.isDone)) || (!IsCompleted && TimedOut))
+                {
+                    SetComplete();
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogException(ex);
+            }
        }
    }
 }
--- a/Runtime/Serialization/BufferSerializer.cs
+++ b/Runtime/Serialization/BufferSerializer.cs
@@ -1,3 +1,7 @@
+using System;
+using Unity.Collections;
+using UnityEngine;
+
 namespace Unity.Netcode
 {
    /// <summary>
@@ -7,7 +11,7 @@ namespace Unity.Netcode
    /// 1. The BufferSerializer cannot outlive the FBR/FBW it wraps or using it will cause a crash
    /// 2. The BufferSerializer must always be passed by reference and can't be copied
    ///
-    /// Ref structs help enforce both of those rules: they can't out live the stack context in which they were
+    /// Ref structs help enforce both of those rules: they can't ref live the stack context in which they were
    /// created, and they're always passed by reference no matter what.
    ///
    /// BufferSerializer doesn't wrapp FastBufferReader or FastBufferWriter directly because it can't.
@@ -58,168 +62,89 @@ namespace Unity.Netcode
            return m_Implementation.GetFastBufferWriter();
        }

-        /// <summary>
-        /// Serialize an INetworkSerializable
-        /// 
-        /// Throws OverflowException if the end of the buffer has been reached.
-        /// Write buffers will grow up to the maximum allowable message size before throwing OverflowException.
-        /// </summary>
-        /// <param name="value">Value to serialize</param>
-        public void SerializeNetworkSerializable<T>(ref T value) where T : INetworkSerializable, new()
-        {
-            m_Implementation.SerializeNetworkSerializable(ref value);
-        }
+        public void SerializeValue(ref string s, bool oneByteChars = false) => m_Implementation.SerializeValue(ref s, oneByteChars);
+        public void SerializeValue(ref byte value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue<T>(ref T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue<T>(ref T value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Vector2 value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Vector2[] value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Vector3 value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Vector3[] value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Vector2Int value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Vector2Int[] value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Vector3Int value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Vector3Int[] value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Vector4 value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Vector4[] value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Quaternion value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Quaternion[] value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Color value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Color[] value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Color32 value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Color32[] value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Ray value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Ray[] value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Ray2D value) => m_Implementation.SerializeValue(ref value);
+        public void SerializeValue(ref Ray2D[] value) => m_Implementation.SerializeValue(ref value);

-        /// <summary>
-        /// Serialize a string.
-        ///
-        /// Note: Will ALWAYS allocate a new string when reading.
-        /// 
-        /// Throws OverflowException if the end of the buffer has been reached.
-        /// Write buffers will grow up to the maximum allowable message size before throwing OverflowException.
-        /// </summary>
-        /// <param name="s">Value to serialize</param>
-        /// <param name="oneByteChars">
-        /// If true, will truncate each char to one byte.
-        /// This is slower than two-byte chars, but uses less bandwidth.
-        /// </param>
-        public void SerializeValue(ref string s, bool oneByteChars = false)
-        {
-            m_Implementation.SerializeValue(ref s, oneByteChars);
-        }
+        // There are many FixedString types, but all of them share the interfaces INativeList<bool> and IUTF8Bytes.
+        // INativeList<bool> provides the Length property
+        // IUTF8Bytes provides GetUnsafePtr()
+        // Those two are necessary to serialize FixedStrings efficiently
+        // - otherwise we'd just be memcpying the whole thing even if
+        // most of it isn't used.
+        public void SerializeValue<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Implementation.SerializeValue(ref value);

-        /// <summary>
-        /// Serialize an array value.
-        ///
-        /// Note: Will ALWAYS allocate a new array when reading.
-        /// If you have a statically-sized array that you know is large enough, it's recommended to
-        /// serialize the size yourself and iterate serializing array members.
-        /// 
-        /// (This is because C# doesn't allow setting an array's length value, so deserializing
-        /// into an existing array of larger size would result in an array that doesn't have as many values
-        /// as its Length indicates it should.)
-        /// 
-        /// Throws OverflowException if the end of the buffer has been reached.
-        /// Write buffers will grow up to the maximum allowable message size before throwing OverflowException.
-        /// </summary>
-        /// <param name="array">Value to serialize</param>
-        public void SerializeValue<T>(ref T[] array) where T : unmanaged
-        {
-            m_Implementation.SerializeValue(ref array);
-        }
+        public void SerializeNetworkSerializable<T>(ref T value) where T : INetworkSerializable, new() => m_Implementation.SerializeNetworkSerializable(ref value);

-        /// <summary>
-        /// Serialize a single byte
-        /// 
-        /// Throws OverflowException if the end of the buffer has been reached.
-        /// Write buffers will grow up to the maximum allowable message size before throwing OverflowException.
-        /// </summary>
-        /// <param name="value">Value to serialize</param>
-        public void SerializeValue(ref byte value)
-        {
-            m_Implementation.SerializeValue(ref value);
-        }
-
-        /// <summary>
-        /// Serialize an unmanaged type. Supports basic value types as well as structs.
-        /// The provided type will be copied to/from the buffer as it exists in memory.
-        /// 
-        /// Throws OverflowException if the end of the buffer has been reached.
-        /// Write buffers will grow up to the maximum allowable message size before throwing OverflowException.
-        /// </summary>
-        /// <param name="value">Value to serialize</param>
-        public void SerializeValue<T>(ref T value) where T : unmanaged
-        {
-            m_Implementation.SerializeValue(ref value);
-        }
-
-        /// <summary>
-        /// Allows faster serialization by batching bounds checking.
-        /// When you know you will be writing multiple fields back-to-back and you know the total size,
-        /// you can call PreCheck() once on the total size, and then follow it with calls to
-        /// SerializeValuePreChecked() for faster serialization. Write buffers will grow during PreCheck()
-        /// if needed.
-        /// 
-        /// PreChecked serialization operations will throw OverflowException in editor and development builds if you
-        /// go past the point you've marked using PreCheck(). In release builds, OverflowException will not be thrown
-        /// for performance reasons, since the point of using PreCheck is to avoid bounds checking in the following
-        /// operations in release builds.
-        ///
-        /// To get the correct size to check for, use FastBufferWriter.GetWriteSize(value) or
-        /// FastBufferWriter.GetWriteSize&lt;type&gt;()
-        /// </summary>
-        /// <param name="amount">Number of bytes you plan to read or write</param>
-        /// <returns>True if the read/write can proceed, false otherwise.</returns>
        public bool PreCheck(int amount)
        {
            return m_Implementation.PreCheck(amount);
        }

-        /// <summary>
-        /// Serialize a string.
-        /// 
-        /// Note: Will ALWAYS allocate a new string when reading.
-        ///
-        /// Using the PreChecked versions of these functions requires calling PreCheck() ahead of time, and they should only
-        /// be called if PreCheck() returns true. This is an efficiency option, as it allows you to PreCheck() multiple
-        /// serialization operations in one function call instead of having to do bounds checking on every call.
-        /// </summary>
-        /// <param name="s">Value to serialize</param>
-        /// <param name="oneByteChars">
-        /// If true, will truncate each char to one byte.
-        /// This is slower than two-byte chars, but uses less bandwidth.
-        /// </param>
-        public void SerializeValuePreChecked(ref string s, bool oneByteChars = false)
-        {
-            m_Implementation.SerializeValuePreChecked(ref s, oneByteChars);
-        }
+        public void SerializeValuePreChecked(ref string s, bool oneByteChars = false) => m_Implementation.SerializeValuePreChecked(ref s, oneByteChars);
+        public void SerializeValuePreChecked(ref byte value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Vector2 value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Vector2[] value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Vector3 value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Vector3[] value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Vector2Int value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Vector2Int[] value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Vector3Int value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Vector3Int[] value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Vector4 value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Vector4[] value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Quaternion value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Quaternion[] value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Color value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Color[] value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Color32 value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Color32[] value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Ray value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Ray[] value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Ray2D value) => m_Implementation.SerializeValuePreChecked(ref value);
+        public void SerializeValuePreChecked(ref Ray2D[] value) => m_Implementation.SerializeValuePreChecked(ref value);

-        /// <summary>
-        /// Serialize an array value.
-        ///
-        /// Note: Will ALWAYS allocate a new array when reading.
-        /// If you have a statically-sized array that you know is large enough, it's recommended to
-        /// serialize the size yourself and iterate serializing array members.
-        /// 
-        /// (This is because C# doesn't allow setting an array's length value, so deserializing
-        /// into an existing array of larger size would result in an array that doesn't have as many values
-        /// as its Length indicates it should.)
-        ///
-        /// Using the PreChecked versions of these functions requires calling PreCheck() ahead of time, and they should only
-        /// be called if PreCheck() returns true. This is an efficiency option, as it allows you to PreCheck() multiple
-        /// serialization operations in one function call instead of having to do bounds checking on every call.
-        /// </summary>
-        /// <param name="array">Value to serialize</param>
-        public void SerializeValuePreChecked<T>(ref T[] array) where T : unmanaged
-        {
-            m_Implementation.SerializeValuePreChecked(ref array);
-        }
-
-        /// <summary>
-        /// Serialize a single byte
-        ///
-        /// Using the PreChecked versions of these functions requires calling PreCheck() ahead of time, and they should only
-        /// be called if PreCheck() returns true. This is an efficiency option, as it allows you to PreCheck() multiple
-        /// serialization operations in one function call instead of having to do bounds checking on every call.
-        /// </summary>
-        /// <param name="value">Value to serialize</param>
-        public void SerializeValuePreChecked(ref byte value)
-        {
-            m_Implementation.SerializeValuePreChecked(ref value);
-        }
-
-        /// <summary>
-        /// Serialize an unmanaged type. Supports basic value types as well as structs.
-        /// The provided type will be copied to/from the buffer as it exists in memory.
-        ///
-        /// Using the PreChecked versions of these functions requires calling PreCheck() ahead of time, and they should only
-        /// be called if PreCheck() returns true. This is an efficiency option, as it allows you to PreCheck() multiple
-        /// serialization operations in one function call instead of having to do bounds checking on every call.
-        /// </summary>
-        /// <param name="value">Value to serialize</param>
-        public void SerializeValuePreChecked<T>(ref T value) where T : unmanaged
-        {
-            m_Implementation.SerializeValuePreChecked(ref value);
-        }
+        // There are many FixedString types, but all of them share the interfaces INativeList<bool> and IUTF8Bytes.
+        // INativeList<bool> provides the Length property
+        // IUTF8Bytes provides GetUnsafePtr()
+        // Those two are necessary to serialize FixedStrings efficiently
+        // - otherwise we'd just be memcpying the whole thing even if
+        // most of it isn't used.
+        public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Implementation.SerializeValuePreChecked(ref value);
    }
 }
--- a/Runtime/Serialization/BufferSerializerReader.cs
+++ b/Runtime/Serialization/BufferSerializerReader.cs
@@ -1,4 +1,6 @@
 using System;
+using Unity.Collections;
+using UnityEngine;

 namespace Unity.Netcode
 {
@@ -24,54 +26,77 @@ namespace Unity.Netcode
            throw new InvalidOperationException("Cannot retrieve a FastBufferWriter from a serializer where IsWriter = false");
        }

-        public void SerializeValue(ref string s, bool oneByteChars = false)
-        {
-            m_Reader.ReadValueSafe(out s, oneByteChars);
-        }
+        public void SerializeValue(ref string s, bool oneByteChars = false) => m_Reader.ReadValueSafe(out s, oneByteChars);
+        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 T value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => m_Reader.ReadValue(out 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[] array) where T : unmanaged
-        {
-            m_Reader.ReadValueSafe(out array);
-        }
+        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(ref byte value)
-        {
-            m_Reader.ReadByteSafe(out value);
-        }
+        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);

-        public void SerializeValue<T>(ref T value) where T : unmanaged
-        {
-            m_Reader.ReadValueSafe(out value);
-        }
-
-        public void SerializeNetworkSerializable<T>(ref T value) where T : INetworkSerializable, new()
-        {
-            m_Reader.ReadNetworkSerializable(out value);
-        }
+        public void SerializeNetworkSerializable<T>(ref T value) where T : INetworkSerializable, new() => m_Reader.ReadNetworkSerializable(out value);

        public bool PreCheck(int amount)
        {
            return m_Reader.TryBeginRead(amount);
        }

-        public void SerializeValuePreChecked(ref string s, bool oneByteChars = false)
-        {
-            m_Reader.ReadValue(out s, oneByteChars);
-        }
-
-        public void SerializeValuePreChecked<T>(ref T[] array) where T : unmanaged
-        {
-            m_Reader.ReadValue(out array);
-        }
-
-        public void SerializeValuePreChecked(ref byte value)
-        {
-            m_Reader.ReadValue(out value);
-        }
-
-        public void SerializeValuePreChecked<T>(ref T value) where T : unmanaged
-        {
-            m_Reader.ReadValue(out value);
-        }
+        public void SerializeValuePreChecked(ref string s, bool oneByteChars = false) => m_Reader.ReadValue(out s, oneByteChars);
+        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 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);
    }
 }
--- a/Runtime/Serialization/BufferSerializerWriter.cs
+++ b/Runtime/Serialization/BufferSerializerWriter.cs
@@ -1,4 +1,6 @@
 using System;
+using Unity.Collections;
+using UnityEngine;

 namespace Unity.Netcode
 {
@@ -24,25 +26,39 @@ namespace Unity.Netcode
            return m_Writer;
        }

-        public void SerializeValue(ref string s, bool oneByteChars = false)
-        {
-            m_Writer.WriteValueSafe(s, oneByteChars);
-        }
+        public void SerializeValue(ref string s, bool oneByteChars = false) => m_Writer.WriteValueSafe(s, oneByteChars);
+        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 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 T[] array) where T : unmanaged
-        {
-            m_Writer.WriteValueSafe(array);
-        }
-
-        public void SerializeValue(ref byte value)
-        {
-            m_Writer.WriteByteSafe(value);
-        }
-
-        public void SerializeValue<T>(ref T value) where T : unmanaged
-        {
-            m_Writer.WriteValueSafe(value);
-        }
+        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);

        public void SerializeNetworkSerializable<T>(ref T value) where T : INetworkSerializable, new()
        {
@@ -54,24 +70,37 @@ namespace Unity.Netcode
            return m_Writer.TryBeginWrite(amount);
        }

-        public void SerializeValuePreChecked(ref string s, bool oneByteChars = false)
-        {
-            m_Writer.WriteValue(s, oneByteChars);
-        }
+        public void SerializeValuePreChecked(ref string s, bool oneByteChars = false) => m_Writer.WriteValue(s, oneByteChars);
+        public void SerializeValuePreChecked(ref byte value) => m_Writer.WriteByte(value);
+        public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Writer.WriteValue(value);
+        public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Writer.WriteValue(value);

-        public void SerializeValuePreChecked<T>(ref T[] array) where T : unmanaged
-        {
-            m_Writer.WriteValue(array);
-        }
+        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 T value, FastBufferWriter.ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Writer.WriteValue(value);

-        public void SerializeValuePreChecked(ref byte value)
-        {
-            m_Writer.WriteByte(value);
-        }
-
-        public void SerializeValuePreChecked<T>(ref T value) where T : unmanaged
-        {
-            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);
    }
 }
--- a/Runtime/Serialization/BytePacker.cs
+++ b/Runtime/Serialization/BytePacker.cs
@@ -281,6 +281,17 @@ namespace Unity.Netcode
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void WriteValueBitPacked<T>(FastBufferWriter writer, T value) where T: unmanaged => writer.WriteValueSafe(value);
 #else
+
+        public const ushort BitPackedUshortMax = (1 << 15) - 1;
+        public const short BitPackedShortMax = (1 << 14) - 1;
+        public const short BitPackedShortMin = -(1 << 14);
+        public const uint BitPackedUintMax = (1 << 30) - 1;
+        public const int BitPackedIntMax = (1 << 29) - 1;
+        public const int BitPackedIntMin = -(1 << 29);
+        public const ulong BitPackedULongMax = (1L << 61) - 1;
+        public const long BitPackedLongMax = (1L << 60) - 1;
+        public const long BitPackedLongMin = -(1L << 60);
+
        /// <summary>
        /// Writes a 14-bit signed short to the buffer in a bit-encoded packed format.
        /// The first bit indicates whether the value is 1 byte or 2.
@@ -307,7 +318,7 @@ namespace Unity.Netcode
        public static void WriteValueBitPacked(FastBufferWriter writer, ushort value)
        {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (value >= 0b1000_0000_0000_0000)
+            if (value >= BitPackedUshortMax)
            {
                throw new ArgumentException("BitPacked ushorts must be <= 15 bits");
            }
@@ -356,7 +367,7 @@ namespace Unity.Netcode
        public static void WriteValueBitPacked(FastBufferWriter writer, uint value)
        {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (value >= 0b0100_0000_0000_0000_0000_0000_0000_0000)
+            if (value > BitPackedUintMax)
            {
                throw new ArgumentException("BitPacked uints must be <= 30 bits");
            }
@@ -396,7 +407,7 @@ namespace Unity.Netcode
        public static void WriteValueBitPacked(FastBufferWriter writer, ulong value)
        {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (value >= 0b0010_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000)
+            if (value > BitPackedULongMax)
            {
                throw new ArgumentException("BitPacked ulongs must be <= 61 bits");
            }
--- a/Runtime/Serialization/FastBufferReader.cs
+++ b/Runtime/Serialization/FastBufferReader.cs
@@ -2,6 +2,7 @@ using System;
 using System.Runtime.CompilerServices;
 using Unity.Collections;
 using Unity.Collections.LowLevel.Unsafe;
+using UnityEngine;

 namespace Unity.Netcode
 {
@@ -19,7 +20,7 @@ namespace Unity.Netcode
 #endif
        }

-        internal readonly unsafe ReaderHandle* Handle;
+        internal unsafe ReaderHandle* Handle;

        /// <summary>
        /// Get the current read position
@@ -39,6 +40,11 @@ namespace Unity.Netcode
            get => Handle->Length;
        }

+        /// <summary>
+        /// Gets a value indicating whether the reader has been initialized and a handle allocated.
+        /// </summary>
+        public unsafe bool IsInitialized => Handle != null;
+
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal unsafe void CommitBitwiseReads(int amount)
        {
@@ -48,25 +54,29 @@ namespace Unity.Netcode
 #endif
        }

-        private static unsafe ReaderHandle* CreateHandle(byte* buffer, int length, int offset, Allocator allocator)
+        private static unsafe ReaderHandle* CreateHandle(byte* buffer, int length, int offset, Allocator copyAllocator, Allocator internalAllocator)
        {
            ReaderHandle* readerHandle = null;
-            if (allocator == Allocator.None)
+            if (copyAllocator == Allocator.None)
            {
-                readerHandle = (ReaderHandle*)UnsafeUtility.Malloc(sizeof(ReaderHandle) + length, UnsafeUtility.AlignOf<byte>(), Allocator.Temp);
+                readerHandle = (ReaderHandle*)UnsafeUtility.Malloc(sizeof(ReaderHandle) + length, UnsafeUtility.AlignOf<byte>(), internalAllocator);
                readerHandle->BufferPointer = buffer;
                readerHandle->Position = offset;
            }
            else
            {
-                readerHandle = (ReaderHandle*)UnsafeUtility.Malloc(sizeof(ReaderHandle) + length, UnsafeUtility.AlignOf<byte>(), allocator);
+                readerHandle = (ReaderHandle*)UnsafeUtility.Malloc(sizeof(ReaderHandle) + length, UnsafeUtility.AlignOf<byte>(), copyAllocator);
                UnsafeUtility.MemCpy(readerHandle + 1, buffer + offset, length);
                readerHandle->BufferPointer = (byte*)(readerHandle + 1);
                readerHandle->Position = 0;
            }

            readerHandle->Length = length;
-            readerHandle->Allocator = allocator;
+
+            // If the copyAllocator provided is Allocator.None, there is a chance that the internalAllocator was provided
+            // When we dispose, we are really only interested in disposing Allocator.Persistent and Allocator.TempJob
+            // as disposing Allocator.Temp and Allocator.None would do nothing. Therefore, make sure we dispose the readerHandle with the right Allocator label
+            readerHandle->Allocator = copyAllocator == Allocator.None ? internalAllocator : copyAllocator;
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
            readerHandle->AllowedReadMark = 0;
            readerHandle->InBitwiseContext = false;
@@ -77,23 +87,26 @@ namespace Unity.Netcode
        /// <summary>
        /// Create a FastBufferReader from a NativeArray.
        ///
-        /// A new buffer will be created using the given allocator and the value will be copied in.
+        /// A new buffer will be created using the given <param name="copyAllocator"> and the value will be copied in.
        /// FastBufferReader will then own the data.
        ///
-        /// The exception to this is when the allocator passed in is Allocator.None. In this scenario,
+        /// The exception to this is when the <param name="copyAllocator"> passed in is Allocator.None. In this scenario,
        /// ownership of the data remains with the caller and the reader will point at it directly.
        /// When created with Allocator.None, FastBufferReader will allocate some internal data using
-        /// Allocator.Temp, so it should be treated as if it's a ref struct and not allowed to outlive
+        /// Allocator.Temp so it should be treated as if it's a ref struct and not allowed to outlive
        /// the context in which it was created (it should neither be returned from that function nor
-        /// stored anywhere in heap memory).
+        /// stored anywhere in heap memory). This is true, unless the <param name="internalAllocator"> param is explicitly set
+        /// to i.e.: Allocator.Persistent in which case it would allow the internal data to Persist for longer, but the caller
+        /// should manually call Dispose() when it is no longer needed.
        /// </summary>
        /// <param name="buffer"></param>
-        /// <param name="allocator"></param>
+        /// <param name="copyAllocator">The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance</param>
        /// <param name="length"></param>
        /// <param name="offset"></param>
-        public unsafe FastBufferReader(NativeArray<byte> buffer, Allocator allocator, int length = -1, int offset = 0)
+        /// <param name="internalAllocator">The allocator type used for internal data when this reader points directly at a buffer owned by someone else</param>
+        public unsafe FastBufferReader(NativeArray<byte> buffer, Allocator copyAllocator, int length = -1, int offset = 0, Allocator internalAllocator = Allocator.Temp)
        {
-            Handle = CreateHandle((byte*)buffer.GetUnsafePtr(), Math.Max(1, length == -1 ? buffer.Length : length), offset, allocator);
+            Handle = CreateHandle((byte*)buffer.GetUnsafePtr(), length == -1 ? buffer.Length : length, offset, copyAllocator, internalAllocator);
        }

        /// <summary>
@@ -106,18 +119,18 @@ namespace Unity.Netcode
        /// and ensure the FastBufferReader isn't used outside that block.
        /// </summary>
        /// <param name="buffer">The buffer to copy from</param>
-        /// <param name="allocator">The allocator to use</param>
+        /// <param name="copyAllocator">The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance</param>
        /// <param name="length">The number of bytes to copy (all if this is -1)</param>
        /// <param name="offset">The offset of the buffer to start copying from</param>
-        public unsafe FastBufferReader(ArraySegment<byte> buffer, Allocator allocator, int length = -1, int offset = 0)
+        public unsafe FastBufferReader(ArraySegment<byte> buffer, Allocator copyAllocator, int length = -1, int offset = 0)
        {
-            if (allocator == Allocator.None)
+            if (copyAllocator == Allocator.None)
            {
                throw new NotSupportedException("Allocator.None cannot be used with managed source buffers.");
            }
            fixed (byte* data = buffer.Array)
            {
-                Handle = CreateHandle(data, Math.Max(1, length == -1 ? buffer.Count : length), offset, allocator);
+                Handle = CreateHandle(data, length == -1 ? buffer.Count : length, offset, copyAllocator, Allocator.Temp);
            }
        }

@@ -131,63 +144,94 @@ namespace Unity.Netcode
        /// and ensure the FastBufferReader isn't used outside that block.
        /// </summary>
        /// <param name="buffer">The buffer to copy from</param>
-        /// <param name="allocator">The allocator to use</param>
+        /// <param name="copyAllocator">The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance</param>
        /// <param name="length">The number of bytes to copy (all if this is -1)</param>
        /// <param name="offset">The offset of the buffer to start copying from</param>
-        public unsafe FastBufferReader(byte[] buffer, Allocator allocator, int length = -1, int offset = 0)
+        public unsafe FastBufferReader(byte[] buffer, Allocator copyAllocator, int length = -1, int offset = 0)
        {
-            if (allocator == Allocator.None)
+            if (copyAllocator == Allocator.None)
            {
                throw new NotSupportedException("Allocator.None cannot be used with managed source buffers.");
            }
            fixed (byte* data = buffer)
            {
-                Handle = CreateHandle(data, Math.Max(1, length == -1 ? buffer.Length : length), offset, allocator);
+                Handle = CreateHandle(data, length == -1 ? buffer.Length : length, offset, copyAllocator, Allocator.Temp);
            }
        }

        /// <summary>
        /// Create a FastBufferReader from an existing byte buffer.
        ///
-        /// A new buffer will be created using the given allocator and the value will be copied in.
+        /// A new buffer will be created using the given <param name="copyAllocator"> and the value will be copied in.
        /// FastBufferReader will then own the data.
        ///
-        /// The exception to this is when the allocator passed in is Allocator.None. In this scenario,
+        /// The exception to this is when the <param name="copyAllocator"> passed in is Allocator.None. In this scenario,
        /// ownership of the data remains with the caller and the reader will point at it directly.
        /// When created with Allocator.None, FastBufferReader will allocate some internal data using
        /// Allocator.Temp, so it should be treated as if it's a ref struct and not allowed to outlive
        /// the context in which it was created (it should neither be returned from that function nor
-        /// stored anywhere in heap memory).
+        /// stored anywhere in heap memory). This is true, unless the <param name="internalAllocator"> param is explicitly set
+        /// to i.e.: Allocator.Persistent in which case it would allow the internal data to Persist for longer, but the caller
+        /// should manually call Dispose() when it is no longer needed.
        /// </summary>
        /// <param name="buffer">The buffer to copy from</param>
-        /// <param name="allocator">The allocator to use</param>
+        /// <param name="copyAllocator">The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance</param>
        /// <param name="length">The number of bytes to copy</param>
        /// <param name="offset">The offset of the buffer to start copying from</param>
-        public unsafe FastBufferReader(byte* buffer, Allocator allocator, int length, int offset = 0)
+        /// <param name="internalAllocator">The allocator type used for internal data when this reader points directly at a buffer owned by someone else</param>
+        public unsafe FastBufferReader(byte* buffer, Allocator copyAllocator, int length, int offset = 0, Allocator internalAllocator = Allocator.Temp)
        {
-            Handle = CreateHandle(buffer, Math.Max(1, length), offset, allocator);
+            Handle = CreateHandle(buffer, length, offset, copyAllocator, internalAllocator);
        }

        /// <summary>
        /// Create a FastBufferReader from a FastBufferWriter.
        ///
-        /// A new buffer will be created using the given allocator and the value will be copied in.
+        /// A new buffer will be created using the given <param name="copyAllocator"> and the value will be copied in.
        /// FastBufferReader will then own the data.
        ///
-        /// The exception to this is when the allocator passed in is Allocator.None. In this scenario,
+        /// The exception to this is when the <param name="copyAllocator"> passed in is Allocator.None. In this scenario,
+        /// ownership of the data remains with the caller and the reader will point at it directly.
+        /// When created with Allocator.None, FastBufferReader will allocate some internal data using
+        /// Allocator.Temp, so it should be treated as if it's a ref struct and not allowed to outlive
+        /// the context in which it was created (it should neither be returned from that function nor
+        /// stored anywhere in heap memory). This is true, unless the <param name="internalAllocator"> param is explicitly set
+        /// to i.e.: Allocator.Persistent in which case it would allow the internal data to Persist for longer, but the caller
+        /// should manually call Dispose() when it is no longer needed.
+        /// </summary>
+        /// <param name="writer">The writer to copy from</param>
+        /// <param name="copyAllocator">The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance</param>
+        /// <param name="length">The number of bytes to copy (all if this is -1)</param>
+        /// <param name="offset">The offset of the buffer to start copying from</param>
+        /// <param name="internalAllocator">The allocator type used for internal data when this reader points directly at a buffer owned by someone else</param>
+        public unsafe FastBufferReader(FastBufferWriter writer, Allocator copyAllocator, int length = -1, int offset = 0, Allocator internalAllocator = Allocator.Temp)
+        {
+            Handle = CreateHandle(writer.GetUnsafePtr(), length == -1 ? writer.Length : length, offset, copyAllocator, internalAllocator);
+        }
+
+        /// <summary>
+        /// Create a FastBufferReader from another existing FastBufferReader. This is typically used when you
+        /// want to change the copyAllocator that a reader is allocated to - for example, upgrading a Temp reader to
+        /// a Persistent one to be processed later.
+        ///
+        /// A new buffer will be created using the given <param name="copyAllocator"> and the value will be copied in.
+        /// FastBufferReader will then own the data.
+        ///
+        /// The exception to this is when the <param name="copyAllocator"> passed in is Allocator.None. In this scenario,
        /// ownership of the data remains with the caller and the reader will point at it directly.
        /// When created with Allocator.None, FastBufferReader will allocate some internal data using
        /// Allocator.Temp, so it should be treated as if it's a ref struct and not allowed to outlive
        /// the context in which it was created (it should neither be returned from that function nor
        /// stored anywhere in heap memory).
        /// </summary>
-        /// <param name="writer">The writer to copy from</param>
-        /// <param name="allocator">The allocator to use</param>
+        /// <param name="reader">The reader to copy from</param>
+        /// <param name="copyAllocator">The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance</param>
        /// <param name="length">The number of bytes to copy (all if this is -1)</param>
        /// <param name="offset">The offset of the buffer to start copying from</param>
-        public unsafe FastBufferReader(FastBufferWriter writer, Allocator allocator, int length = -1, int offset = 0)
+        /// <param name="internalAllocator">The allocator type used for internal data when this reader points directly at a buffer owned by someone else</param>
+        public unsafe FastBufferReader(FastBufferReader reader, Allocator copyAllocator, int length = -1, int offset = 0, Allocator internalAllocator = Allocator.Temp)
        {
-            Handle = CreateHandle(writer.GetUnsafePtr(), Math.Max(1, length == -1 ? writer.Length : length), offset, allocator);
+            Handle = CreateHandle(reader.GetUnsafePtr(), length == -1 ? reader.Length : length, offset, copyAllocator, internalAllocator);
        }

        /// <summary>
@@ -196,6 +240,7 @@ namespace Unity.Netcode
        public unsafe void Dispose()
        {
            UnsafeUtility.Free(Handle, Handle->Allocator);
+            Handle = null;
        }

        /// <summary>
@@ -486,61 +531,6 @@ namespace Unity.Netcode
            }
        }

-        /// <summary>
-        /// Writes an unmanaged array
-        /// NOTE: ALLOCATES
-        /// </summary>
-        /// <param name="array">Stores the read array</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void ReadValue<T>(out T[] array) where T : unmanaged
-        {
-            ReadValue(out int sizeInTs);
-            int sizeInBytes = sizeInTs * sizeof(T);
-            array = new T[sizeInTs];
-            fixed (T* native = array)
-            {
-                byte* bytes = (byte*)(native);
-                ReadBytes(bytes, sizeInBytes);
-            }
-        }
-
-        /// <summary>
-        /// Reads an unmanaged array
-        /// NOTE: ALLOCATES
-        ///
-        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
-        /// for multiple reads at once by calling TryBeginRead.
-        /// </summary>
-        /// <param name="array">Stores the read array</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void ReadValueSafe<T>(out T[] array) where T : unmanaged
-        {
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (Handle->InBitwiseContext)
-            {
-                throw new InvalidOperationException(
-                    "Cannot use BufferReader in bytewise mode while in a bitwise context.");
-            }
-#endif
-
-            if (!TryBeginReadInternal(sizeof(int)))
-            {
-                throw new OverflowException("Reading past the end of the buffer");
-            }
-            ReadValue(out int sizeInTs);
-            int sizeInBytes = sizeInTs * sizeof(T);
-            if (!TryBeginReadInternal(sizeInBytes))
-            {
-                throw new OverflowException("Reading past the end of the buffer");
-            }
-            array = new T[sizeInTs];
-            fixed (T* native = array)
-            {
-                byte* bytes = (byte*)(native);
-                ReadBytes(bytes, sizeInBytes);
-            }
-        }
-
        /// <summary>
        /// Read a partial value. The value is zero-initialized and then the specified number of bytes is read into it.
        /// </summary>
@@ -705,69 +695,197 @@ namespace Unity.Netcode
            }
        }

-        /// <summary>
-        /// Read a value of any unmanaged type to the buffer.
-        /// It will be copied from the buffer exactly as it existed in memory on the writing end.
-        /// </summary>
-        /// <param name="value">The read value</param>
-        /// <typeparam name="T">Any unmanaged type</typeparam>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void ReadValue<T>(out T value) where T : unmanaged
+        internal unsafe void ReadUnmanaged<T>(out T value) where T : unmanaged
        {
-            int len = sizeof(T);
-
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (Handle->InBitwiseContext)
-            {
-                throw new InvalidOperationException(
-                    "Cannot use BufferReader in bytewise mode while in a bitwise context.");
-            }
-            if (Handle->Position + len > Handle->AllowedReadMark)
-            {
-                throw new OverflowException($"Attempted to read without first calling {nameof(TryBeginRead)}()");
-            }
-#endif
-
            fixed (T* ptr = &value)
            {
-                UnsafeUtility.MemCpy((byte*)ptr, Handle->BufferPointer + Handle->Position, len);
+                byte* bytes = (byte*)ptr;
+                ReadBytes(bytes, sizeof(T));
            }
-            Handle->Position += len;
        }
-
-        /// <summary>
-        /// Read a value of any unmanaged type to the buffer.
-        /// It will be copied from the buffer exactly as it existed in memory on the writing end.
-        ///
-        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
-        /// for multiple reads at once by calling TryBeginRead.
-        /// </summary>
-        /// <param name="value">The read value</param>
-        /// <typeparam name="T">Any unmanaged type</typeparam>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void ReadValueSafe<T>(out T value) where T : unmanaged
+        internal unsafe void ReadUnmanagedSafe<T>(out T value) where T : unmanaged
        {
-            int len = sizeof(T);
-
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (Handle->InBitwiseContext)
-            {
-                throw new InvalidOperationException(
-                    "Cannot use BufferReader in bytewise mode while in a bitwise context.");
-            }
-#endif
-
-            if (!TryBeginReadInternal(len))
-            {
-                throw new OverflowException("Reading past the end of the buffer");
-            }
-
-
            fixed (T* ptr = &value)
            {
-                UnsafeUtility.MemCpy((byte*)ptr, Handle->BufferPointer + Handle->Position, len);
+                byte* bytes = (byte*)ptr;
+                ReadBytesSafe(bytes, sizeof(T));
            }
-            Handle->Position += len;
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void ReadUnmanaged<T>(out T[] value) where T : unmanaged
+        {
+            ReadUnmanaged(out int sizeInTs);
+            int sizeInBytes = sizeInTs * sizeof(T);
+            value = new T[sizeInTs];
+            fixed (T* ptr = value)
+            {
+                byte* bytes = (byte*)ptr;
+                ReadBytes(bytes, sizeInBytes);
+            }
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void ReadUnmanagedSafe<T>(out T[] value) where T : unmanaged
+        {
+            ReadUnmanagedSafe(out int sizeInTs);
+            int sizeInBytes = sizeInTs * sizeof(T);
+            value = new T[sizeInTs];
+            fixed (T* ptr = value)
+            {
+                byte* bytes = (byte*)ptr;
+                ReadBytesSafe(bytes, sizeInBytes);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue<T>(out T value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => ReadNetworkSerializable(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue<T>(out T[] value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => ReadNetworkSerializable(out value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out T value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => ReadNetworkSerializable(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => ReadNetworkSerializable(out value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue<T>(out T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue<T>(out T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => ReadUnmanaged(out value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => ReadUnmanagedSafe(out value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue<T>(out T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue<T>(out T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => ReadUnmanaged(out value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => ReadUnmanagedSafe(out value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue<T>(out T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue<T>(out T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => ReadUnmanaged(out value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+
+        public void ReadValueSafe<T>(out T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+
+        public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => ReadUnmanagedSafe(out value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Vector2 value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Vector2[] value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Vector3 value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Vector3[] value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Vector2Int value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Vector2Int[] value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Vector3Int value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Vector3Int[] value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Vector4 value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Vector4[] value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Quaternion value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Quaternion[] value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Color value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Color[] value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Color32 value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Color32[] value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Ray value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Ray[] value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Ray2D value) => ReadUnmanaged(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue(out Ray2D[] value) => ReadUnmanaged(out value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Vector2 value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Vector2[] value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Vector3 value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Vector3[] value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Vector2Int value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Vector2Int[] value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Vector3Int value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Vector3Int[] value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Vector4 value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Vector4[] value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Quaternion value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Quaternion[] value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Color value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Color[] value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Color32 value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Color32[] value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Ray value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Ray[] value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Ray2D value) => ReadUnmanagedSafe(out value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe(out Ray2D[] value) => ReadUnmanagedSafe(out value);
+
+        // There are many FixedString types, but all of them share the interfaces INativeList<bool> and IUTF8Bytes.
+        // INativeList<bool> provides the Length property
+        // IUTF8Bytes provides GetUnsafePtr()
+        // Those two are necessary to serialize FixedStrings efficiently
+        // - otherwise we'd just be memcpying the whole thing even if
+        // most of it isn't used.
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void ReadValue<T>(out T value, FastBufferWriter.ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            ReadUnmanaged(out int length);
+            value = new T();
+            value.Length = length;
+            ReadBytes(value.GetUnsafePtr(), length);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void ReadValueSafe<T>(out T value, FastBufferWriter.ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            ReadUnmanagedSafe(out int length);
+            value = new T();
+            value.Length = length;
+            ReadBytesSafe(value.GetUnsafePtr(), length);
        }
    }
 }
--- a/Runtime/Serialization/FastBufferWriter.cs
+++ b/Runtime/Serialization/FastBufferWriter.cs
@@ -2,6 +2,7 @@ using System;
 using System.Runtime.CompilerServices;
 using Unity.Collections;
 using Unity.Collections.LowLevel.Unsafe;
+using UnityEngine;

 namespace Unity.Netcode
 {
@@ -22,7 +23,7 @@ namespace Unity.Netcode
 #endif
        }

-        internal readonly unsafe WriterHandle* Handle;
+        internal unsafe WriterHandle* Handle;

        private static byte[] s_ByteArrayCache = new byte[65535];

@@ -62,6 +63,11 @@ namespace Unity.Netcode
            get => Handle->Position > Handle->Length ? Handle->Position : Handle->Length;
        }

+        /// <summary>
+        /// Gets a value indicating whether the writer has been initialized and a handle allocated.
+        /// </summary>
+        public unsafe bool IsInitialized => Handle != null;
+

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal unsafe void CommitBitwiseWrites(int amount)
@@ -111,6 +117,7 @@ namespace Unity.Netcode
                UnsafeUtility.Free(Handle->BufferPointer, Handle->Allocator);
            }
            UnsafeUtility.Free(Handle, Handle->Allocator);
+            Handle = null;
        }

        /// <summary>
@@ -522,60 +529,6 @@ namespace Unity.Netcode
            return sizeof(int) + sizeInBytes;
        }

-        /// <summary>
-        /// Writes an unmanaged array
-        /// </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>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void WriteValue<T>(T[] array, int count = -1, int offset = 0) where T : unmanaged
-        {
-            int sizeInTs = count != -1 ? count : array.Length - offset;
-            int sizeInBytes = sizeInTs * sizeof(T);
-            WriteValue(sizeInTs);
-            fixed (T* native = array)
-            {
-                byte* bytes = (byte*)(native + offset);
-                WriteBytes(bytes, sizeInBytes);
-            }
-        }
-
-        /// <summary>
-        /// Writes an unmanaged array
-        ///
-        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
-        /// for multiple writes at once by calling TryBeginWrite.
-        /// </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>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void WriteValueSafe<T>(T[] array, int count = -1, int offset = 0) where T : unmanaged
-        {
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (Handle->InBitwiseContext)
-            {
-                throw new InvalidOperationException(
-                    "Cannot use BufferWriter in bytewise mode while in a bitwise context.");
-            }
-#endif
-
-            int sizeInTs = count != -1 ? count : array.Length - offset;
-            int sizeInBytes = sizeInTs * sizeof(T);
-
-            if (!TryBeginWriteInternal(sizeInBytes + sizeof(int)))
-            {
-                throw new OverflowException("Writing past the end of the buffer");
-            }
-            WriteValue(sizeInTs);
-            fixed (T* native = array)
-            {
-                byte* bytes = (byte*)(native + offset);
-                WriteBytes(bytes, sizeInBytes);
-            }
-        }
-
        /// <summary>
        /// Write a partial value. The specified number of bytes is written from the value and the rest is ignored.
        /// </summary>
@@ -763,15 +716,30 @@ namespace Unity.Netcode
        }

        /// <summary>
-        /// Get the size required to write an unmanaged value
+        /// Get the write size for any general unmanaged value
+        /// The ForStructs value here makes this the lowest-priority overload so other versions
+        /// will be prioritized over this if they match
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unused"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int GetWriteSize<T>(in T value, ForStructs unused = default) where T : unmanaged
+        {
+            return sizeof(T);
+        }
+
+        /// <summary>
+        /// Get the write size for a FixedString
        /// </summary>
        /// <param name="value"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static unsafe int GetWriteSize<T>(in T value) where T : unmanaged
+        public static int GetWriteSize<T>(in T value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
        {
-            return sizeof(T);
+            return value.Length + sizeof(int);
        }

        /// <summary>
@@ -784,68 +752,223 @@ namespace Unity.Netcode
            return sizeof(T);
        }

-        /// <summary>
-        /// Write a value of any unmanaged type (including unmanaged structs) to the buffer.
-        /// It will be copied into the buffer exactly as it exists in memory.
-        /// </summary>
-        /// <param name="value">The value to copy</param>
-        /// <typeparam name="T">Any unmanaged type</typeparam>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void WriteValue<T>(in T value) where T : unmanaged
+        internal unsafe void WriteUnmanaged<T>(in T value) where T : unmanaged
        {
-            int len = sizeof(T);
-
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (Handle->InBitwiseContext)
-            {
-                throw new InvalidOperationException(
-                    "Cannot use BufferWriter in bytewise mode while in a bitwise context.");
-            }
-            if (Handle->Position + len > Handle->AllowedWriteMark)
-            {
-                throw new OverflowException($"Attempted to write without first calling {nameof(TryBeginWrite)}()");
-            }
-#endif
-
            fixed (T* ptr = &value)
            {
-                UnsafeUtility.MemCpy(Handle->BufferPointer + Handle->Position, (byte*)ptr, len);
+                byte* bytes = (byte*)ptr;
+                WriteBytes(bytes, sizeof(T));
            }
-            Handle->Position += len;
        }
-
-        /// <summary>
-        /// Write a value of any unmanaged type (including unmanaged structs) to the buffer.
-        /// It will be copied into the buffer exactly as it exists in memory.
-        ///
-        /// "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 copy</param>
-        /// <typeparam name="T">Any unmanaged type</typeparam>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void WriteValueSafe<T>(in T value) where T : unmanaged
+        internal unsafe void WriteUnmanagedSafe<T>(in T value) where T : unmanaged
        {
-            int len = sizeof(T);
-
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (Handle->InBitwiseContext)
+            fixed (T* ptr = &value)
            {
-                throw new InvalidOperationException(
-                    "Cannot use BufferWriter in bytewise mode while in a bitwise context.");
+                byte* bytes = (byte*)ptr;
+                WriteBytesSafe(bytes, sizeof(T));
+            }
        }
-#endif

-            if (!TryBeginWriteInternal(len))
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void WriteUnmanaged<T>(T[] value) where T : unmanaged
+        {
+            WriteUnmanaged(value.Length);
+            fixed (T* ptr = value)
+            {
+                byte* bytes = (byte*)ptr;
+                WriteBytes(bytes, sizeof(T) * value.Length);
+            }
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void WriteUnmanagedSafe<T>(T[] value) where T : unmanaged
+        {
+            WriteUnmanagedSafe(value.Length);
+            fixed (T* ptr = value)
+            {
+                byte* bytes = (byte*)ptr;
+                WriteBytesSafe(bytes, sizeof(T) * value.Length);
+            }
+        }
+
+        // These structs enable overloading of WriteValue with different generic constraints.
+        // The compiler's actually able to distinguish between overloads based on generic constraints.
+        // But at the bytecode level, the constraints aren't included in the method signature.
+        // By adding a second parameter with a defaulted value, the signatures of each generic are different,
+        // thus allowing overloads of methods based on the first parameter meeting constraints.
+        public struct ForPrimitives
+        {
+
+        }
+
+        public struct ForEnums
+        {
+
+        }
+
+        public struct ForStructs
+        {
+
+        }
+
+        public struct ForNetworkSerializable
+        {
+
+        }
+
+        public struct ForFixedStrings
+        {
+
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(in T value, ForNetworkSerializable unused = default) where T : INetworkSerializable => WriteNetworkSerializable(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(T[] value, ForNetworkSerializable unused = default) where T : INetworkSerializable => WriteNetworkSerializable(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(in T value, ForNetworkSerializable unused = default) where T : INetworkSerializable => WriteNetworkSerializable(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(T[] value, ForNetworkSerializable unused = default) where T : INetworkSerializable => WriteNetworkSerializable(value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(in T value, ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(T[] value, ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(in T value, ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(T[] value, ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => WriteUnmanagedSafe(value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(in T value, ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(T[] value, ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(in T value, ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(T[] value, ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => WriteUnmanagedSafe(value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(in T value, ForEnums unused = default) where T : unmanaged, Enum => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(T[] value, ForEnums unused = default) where T : unmanaged, Enum => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(in T value, ForEnums unused = default) where T : unmanaged, Enum => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(T[] value, ForEnums unused = default) where T : unmanaged, Enum => WriteUnmanagedSafe(value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(in Vector2 value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(Vector2[] value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(in Vector3 value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(Vector3[] value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(in Vector2Int value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(Vector2Int[] value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(in Vector3Int value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(Vector3Int[] value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(in Vector4 value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(Vector4[] value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(in Quaternion value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(Quaternion[] value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(in Color value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(Color[] value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(in Color32 value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(Color32[] value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(in Ray value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(Ray[] value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(in Ray2D value) => WriteUnmanaged(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue(Ray2D[] value) => WriteUnmanaged(value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(in Vector2 value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(Vector2[] value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(in Vector3 value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(Vector3[] value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(in Vector2Int value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(Vector2Int[] value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(in Vector3Int value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(Vector3Int[] value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(in Vector4 value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(Vector4[] value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(in Quaternion value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(Quaternion[] value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(in Color value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(Color[] value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(in Color32 value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(Color32[] value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(in Ray value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(Ray[] value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(in Ray2D value) => WriteUnmanagedSafe(value);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe(Ray2D[] value) => WriteUnmanagedSafe(value);
+
+        // There are many FixedString types, but all of them share the interfaces INativeList<bool> and IUTF8Bytes.
+        // INativeList<bool> provides the Length property
+        // IUTF8Bytes provides GetUnsafePtr()
+        // Those two are necessary to serialize FixedStrings efficiently
+        // - otherwise we'd just be memcpying the whole thing even if
+        // most of it isn't used.
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void WriteValue<T>(in T value, ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            WriteUnmanaged(value.Length);
+            // This avoids a copy on the string, which could be costly for FixedString4096Bytes
+            // Otherwise, GetUnsafePtr() is an impure function call and will result in a copy
+            // for `in` parameters.
+            fixed (T* ptr = &value)
+            {
+                WriteBytes(ptr->GetUnsafePtr(), value.Length);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(in T value, ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            if (!TryBeginWriteInternal(sizeof(int) + value.Length))
            {
                throw new OverflowException("Writing past the end of the buffer");
            }
-
-            fixed (T* ptr = &value)
-            {
-                UnsafeUtility.MemCpy(Handle->BufferPointer + Handle->Position, (byte*)ptr, len);
-            }
-            Handle->Position += len;
+            WriteValue(value);
        }
    }
 }
--- a/Runtime/Serialization/ForceNetworkSerializeByMemcpy.cs
+++ b/Runtime/Serialization/ForceNetworkSerializeByMemcpy.cs
@@ -0,0 +1,37 @@
+using System;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This is a wrapper that adds `INetworkSerializeByMemcpy` support to existing structs that the developer
+    /// doesn't have the ability to modify (for example, external structs like `Guid`).
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public struct ForceNetworkSerializeByMemcpy<T> : INetworkSerializeByMemcpy, IEquatable<ForceNetworkSerializeByMemcpy<T>> where T : unmanaged, IEquatable<T>
+    {
+        public T Value;
+
+        public ForceNetworkSerializeByMemcpy(T value)
+        {
+            Value = value;
+        }
+
+        public static implicit operator T(ForceNetworkSerializeByMemcpy<T> container) => container.Value;
+        public static implicit operator ForceNetworkSerializeByMemcpy<T>(T underlyingValue) => new ForceNetworkSerializeByMemcpy<T> { Value = underlyingValue };
+
+        public bool Equals(ForceNetworkSerializeByMemcpy<T> other)
+        {
+            return Value.Equals(other.Value);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is ForceNetworkSerializeByMemcpy<T> other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return Value.GetHashCode();
+        }
+    }
+}
--- a/Runtime/Serialization/ForceNetworkSerializeByMemcpy.cs.meta
+++ b/Runtime/Serialization/ForceNetworkSerializeByMemcpy.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d56016695cd44430a345671f7d56b18e
+timeCreated: 1647635768
--- a/Runtime/Serialization/INetworkSerializeByMemcpy.cs
+++ b/Runtime/Serialization/INetworkSerializeByMemcpy.cs
@@ -0,0 +1,15 @@
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This interface is a "tag" that can be applied to a struct to mark that struct as being serializable
+    /// by memcpy. It's up to the developer of the struct to analyze the struct's contents and ensure it
+    /// is actually serializable by memcpy. This requires all of the members of the struct to be
+    /// `unmanaged` Plain-Old-Data values - if your struct contains a pointer (or a type that contains a pointer,
+    /// like `NativeList<T>`), it should be serialized via `INetworkSerializable` or via
+    /// `FastBufferReader`/`FastBufferWriter` extension methods.
+    /// </summary>
+    public interface INetworkSerializeByMemcpy
+    {
+    }
+}
--- a/Runtime/Serialization/INetworkSerializeByMemcpy.cs.meta
+++ b/Runtime/Serialization/INetworkSerializeByMemcpy.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 11b763f46b18465cbffb1972d737a83e
+timeCreated: 1647635592
--- a/Runtime/Serialization/IReaderWriter.cs
+++ b/Runtime/Serialization/IReaderWriter.cs
@@ -1,3 +1,7 @@
+using System;
+using Unity.Collections;
+using UnityEngine;
+
 namespace Unity.Netcode
 {
    public interface IReaderWriter
@@ -9,17 +13,72 @@ namespace Unity.Netcode
        FastBufferWriter GetFastBufferWriter();

        void SerializeValue(ref string s, bool oneByteChars = false);
-        void SerializeValue<T>(ref T[] array) where T : unmanaged;
        void SerializeValue(ref byte value);
-        void SerializeValue<T>(ref T value) where T : unmanaged;
+        void SerializeValue<T>(ref T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T>;
+        void SerializeValue<T>(ref T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T>;
+        void SerializeValue<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum;
+        void SerializeValue<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum;
+        void SerializeValue<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy;
+        void SerializeValue<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy;
+        void SerializeValue<T>(ref T value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new();
+        void SerializeValue<T>(ref T[] value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new();
+        void SerializeValue<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes;
+        void SerializeValue(ref Vector2 value);
+        void SerializeValue(ref Vector2[] value);
+        void SerializeValue(ref Vector3 value);
+        void SerializeValue(ref Vector3[] value);
+        void SerializeValue(ref Vector2Int value);
+        void SerializeValue(ref Vector2Int[] value);
+        void SerializeValue(ref Vector3Int value);
+        void SerializeValue(ref Vector3Int[] value);
+        void SerializeValue(ref Vector4 value);
+        void SerializeValue(ref Vector4[] value);
+        void SerializeValue(ref Quaternion value);
+        void SerializeValue(ref Quaternion[] value);
+        void SerializeValue(ref Color value);
+        void SerializeValue(ref Color[] value);
+        void SerializeValue(ref Color32 value);
+        void SerializeValue(ref Color32[] value);
+        void SerializeValue(ref Ray value);
+        void SerializeValue(ref Ray[] value);
+        void SerializeValue(ref Ray2D value);
+        void SerializeValue(ref Ray2D[] value);

        // Has to have a different name to avoid conflicting with "where T: unmananged"
        void SerializeNetworkSerializable<T>(ref T value) where T : INetworkSerializable, new();

        bool PreCheck(int amount);
        void SerializeValuePreChecked(ref string s, bool oneByteChars = false);
-        void SerializeValuePreChecked<T>(ref T[] array) where T : unmanaged;
        void SerializeValuePreChecked(ref byte value);
-        void SerializeValuePreChecked<T>(ref T value) where T : unmanaged;
+        void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T>;
+        void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T>;
+        void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum;
+        void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum;
+        void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy;
+        void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy;
+        void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes;
+
+        void SerializeValuePreChecked(ref Vector2 value);
+        void SerializeValuePreChecked(ref Vector2[] value);
+        void SerializeValuePreChecked(ref Vector3 value);
+        void SerializeValuePreChecked(ref Vector3[] value);
+        void SerializeValuePreChecked(ref Vector2Int value);
+        void SerializeValuePreChecked(ref Vector2Int[] value);
+        void SerializeValuePreChecked(ref Vector3Int value);
+        void SerializeValuePreChecked(ref Vector3Int[] value);
+        void SerializeValuePreChecked(ref Vector4 value);
+        void SerializeValuePreChecked(ref Vector4[] value);
+        void SerializeValuePreChecked(ref Quaternion value);
+        void SerializeValuePreChecked(ref Quaternion[] value);
+        void SerializeValuePreChecked(ref Color value);
+        void SerializeValuePreChecked(ref Color[] value);
+        void SerializeValuePreChecked(ref Color32 value);
+        void SerializeValuePreChecked(ref Color32[] value);
+        void SerializeValuePreChecked(ref Ray value);
+        void SerializeValuePreChecked(ref Ray[] value);
+        void SerializeValuePreChecked(ref Ray2D value);
+        void SerializeValuePreChecked(ref Ray2D[] value);
    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Unity Technologies	0f7a30d285	com.unity.netcode.gameobjects@1.0.0-pre.10 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.0.0-pre.10] - 2022-06-21 ### Added - Added a new `OnTransportFailure` callback to `NetworkManager`. This callback is invoked when the manager's `NetworkTransport` encounters an unrecoverable error. Transport failures also cause the `NetworkManager` to shut down. Currently, this is only used by `UnityTransport` to signal a timeout of its connection to the Unity Relay servers. (#1994) - Added `NetworkEvent.TransportFailure`, which can be used by implementations of `NetworkTransport` to signal to `NetworkManager` that an unrecoverable error was encountered. (#1994) - Added test to ensure a warning occurs when nesting NetworkObjects in a NetworkPrefab (#1969) - Added `NetworkManager.RemoveNetworkPrefab(...)` to remove a prefab from the prefabs list (#1950) ### Changed - Updated `UnityTransport` dependency on `com.unity.transport` to 1.1.0. (#2025) - (API Breaking) `ConnectionApprovalCallback` is no longer an `event` and will not allow more than 1 handler registered at a time. Also, `ConnectionApprovalCallback` is now a `Func<>` taking `ConnectionApprovalRequest` in and returning `ConnectionApprovalResponse` back out (#1972) ### Removed ### Fixed - Fixed issue where dynamically spawned `NetworkObject`s could throw an exception if the scene of origin handle was zero (0) and the `NetworkObject` was already spawned. (#2017) - Fixed issue where `NetworkObject.Observers` was not being cleared when despawned. (#2009) - Fixed `NetworkAnimator` could not run in the server authoritative mode. (#2003) - Fixed issue where late joining clients would get a soft synchronization error if any in-scene placed NetworkObjects were parented under another `NetworkObject`. (#1985) - Fixed issue where `NetworkBehaviourReference` would throw a type cast exception if using `NetworkBehaviourReference.TryGet` and the component type was not found. (#1984) - Fixed `NetworkSceneManager` was not sending scene event notifications for the currently active scene and any additively loaded scenes when loading a new scene in `LoadSceneMode.Single` mode. (#1975) - Fixed issue where one or more clients disconnecting during a scene event would cause `LoadEventCompleted` or `UnloadEventCompleted` to wait until the `NetworkConfig.LoadSceneTimeOut` period before being triggered. (#1973) - Fixed issues when multiple `ConnectionApprovalCallback`s were registered (#1972) - Fixed a regression in serialization support: `FixedString`, `Vector2Int`, and `Vector3Int` types can now be used in NetworkVariables and RPCs again without requiring a `ForceNetworkSerializeByMemcpy<>` wrapper. (#1961) - Fixed generic types that inherit from NetworkBehaviour causing crashes at compile time. (#1976) - Fixed endless dialog boxes when adding a `NetworkBehaviour` to a `NetworkManager` or vice-versa. (#1947) - Fixed `NetworkAnimator` issue where it was only synchronizing parameters if the layer or state changed or was transitioning between states. (#1946) - Fixed `NetworkAnimator` issue where when it did detect a parameter had changed it would send all parameters as opposed to only the parameters that changed. (#1946) - Fixed `NetworkAnimator` issue where it was not always disposing the `NativeArray` that is allocated when spawned. (#1946) - Fixed `NetworkAnimator` issue where it was not taking the animation speed or state speed multiplier into consideration. (#1946) - Fixed `NetworkAnimator` issue where it was not properly synchronizing late joining clients if they joined while `Animator` was transitioning between states. (#1946) - Fixed `NetworkAnimator` issue where the server was not relaying changes to non-owner clients when a client was the owner. (#1946) - Fixed issue where the `PacketLoss` metric for tools would return the packet loss over a connection lifetime instead of a single frame. (#2004)	2022-06-21 00:00:00 +00:00
Unity Technologies	5b1fc203ed	com.unity.netcode.gameobjects@1.0.0-pre.9 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.0.0-pre.9] - 2022-05-10 ### Fixed - Fixed Hosting again after failing to host now works correctly (#1938) - Fixed NetworkManager to cleanup connected client lists after stopping (#1945) - Fixed NetworkHide followed by NetworkShow on the same frame works correctly (#1940)	2022-05-10 00:00:00 +00:00
Unity Technologies	add668dfd2	com.unity.netcode.gameobjects@1.0.0-pre.8 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.0.0-pre.8] - 2022-04-27 ### Changed - `unmanaged` structs are no longer universally accepted as RPC parameters because some structs (i.e., structs with pointers in them, such as `NativeList<T>`) can't be supported by the default memcpy struct serializer. Structs that are intended to be serialized across the network must add `INetworkSerializeByMemcpy` to the interface list (i.e., `struct Foo : INetworkSerializeByMemcpy`). This interface is empty and just serves to mark the struct as compatible with memcpy serialization. For external structs you can't edit, you can pass them to RPCs by wrapping them in `ForceNetworkSerializeByMemcpy<T>`. (#1901) ### Removed - Removed `SIPTransport` (#1870) - Removed `ClientNetworkTransform` from the package samples and moved to Boss Room's Utilities package which can be found [here](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/main/Packages/com.unity.multiplayer.samples.coop/Utilities/Net/ClientAuthority/ClientNetworkTransform.cs). ### Fixed - Fixed `NetworkTransform` generating false positive rotation delta checks when rolling over between 0 and 360 degrees. (#1890) - Fixed client throwing an exception if it has messages in the outbound queue when processing the `NetworkEvent.Disconnect` event and is using UTP. (#1884) - Fixed issue during client synchronization if 'ValidateSceneBeforeLoading' returned false it would halt the client synchronization process resulting in a client that was approved but not synchronized or fully connected with the server. (#1883) - Fixed an issue where UNetTransport.StartServer would return success even if the underlying transport failed to start (#854) - Passing generic types to RPCs no longer causes a native crash (#1901) - Fixed an issue where calling `Shutdown` on a `NetworkManager` that was already shut down would cause an immediate shutdown the next time it was started (basically the fix makes `Shutdown` idempotent). (#1877)	2022-04-27 00:00:00 +00:00
Unity Technologies	60e2dabef4	com.unity.netcode.gameobjects@1.0.0-pre.7 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.0.0-pre.7] - 2022-04-01 ### Added - Added editor only check prior to entering into play mode if the currently open and active scene is in the build list and if not displays a dialog box asking the user if they would like to automatically add it prior to entering into play mode. (#1828) - Added `UnityTransport` implementation and `com.unity.transport` package dependency (#1823) - Added `NetworkVariableWritePermission` to `NetworkVariableBase` and implemented `Owner` client writable netvars. (#1762) - `UnityTransport` settings can now be set programmatically. (#1845) - `FastBufferWriter` and Reader IsInitialized property. (#1859) ### Changed - Updated `UnityTransport` dependency on `com.unity.transport` to 1.0.0 (#1849) ### Removed - Removed `SnapshotSystem` (#1852) - Removed `com.unity.modules.animation`, `com.unity.modules.physics` and `com.unity.modules.physics2d` dependencies from the package (#1812) - Removed `com.unity.collections` dependency from the package (#1849) ### Fixed - Fixed in-scene placed NetworkObjects not being found/ignored after a client disconnects and then reconnects. (#1850) - Fixed issue where `UnityTransport` send queues were not flushed when calling `DisconnectLocalClient` or `DisconnectRemoteClient`. (#1847) - Fixed NetworkBehaviour dependency verification check for an existing NetworkObject not searching from root parent transform relative GameObject. (#1841) - Fixed issue where entries were not being removed from the NetworkSpawnManager.OwnershipToObjectsTable. (#1838) - Fixed ClientRpcs would always send to all connected clients by default as opposed to only sending to the NetworkObject's Observers list by default. (#1836) - Fixed clarity for NetworkSceneManager client side notification when it receives a scene hash value that does not exist in its local hash table. (#1828) - Fixed client throws a key not found exception when it times out using UNet or UTP. (#1821) - Fixed network variable updates are no longer limited to 32,768 bytes when NetworkConfig.EnsureNetworkVariableLengthSafety is enabled. The limits are now determined by what the transport can send in a message. (#1811) - Fixed in-scene NetworkObjects get destroyed if a client fails to connect and shuts down the NetworkManager. (#1809) - Fixed user never being notified in the editor that a NetworkBehaviour requires a NetworkObject to function properly. (#1808) - Fixed PlayerObjects and dynamically spawned NetworkObjects not being added to the NetworkClient's OwnedObjects (#1801) - Fixed issue where NetworkManager would continue starting even if the NetworkTransport selected failed. (#1780) - Fixed issue when spawning new player if an already existing player exists it does not remove IsPlayer from the previous player (#1779) - Fixed lack of notification that NetworkManager and NetworkObject cannot be added to the same GameObject with in-editor notifications (#1777) - Fixed parenting warning printing for false positives (#1855)	2022-04-01 00:00:00 +00:00
Unity Technologies	5b4aaa8b59	com.unity.netcode.gameobjects@1.0.0-pre.6 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.0.0-pre.6] - 2022-03-02 ### Added - NetworkAnimator now properly synchrhonizes all animation layers as well as runtime-adjusted weighting between them (#1765) - Added first set of tests for NetworkAnimator - parameter syncing, trigger set / reset, override network animator (#1735) ### Changed ### Fixed - Fixed an issue where sometimes the first client to connect to the server could see messages from the server as coming from itself. (#1683) - Fixed an issue where clients seemed to be able to send messages to ClientId 1, but these messages would actually still go to the server (id 0) instead of that client. (#1683) - Improved clarity of error messaging when a client attempts to send a message to a destination other than the server, which isn't allowed. (#1683) - Disallowed async keyword in RPCs (#1681) - Fixed an issue where Alpha release versions of Unity (version 2022.2.0a5 and later) will not compile due to the UNet Transport no longer existing (#1678) - Fixed messages larger than 64k being written with incorrectly truncated message size in header (#1686) (credit: @kaen) - Fixed overloading RPC methods causing collisions and failing on IL2CPP targets. (#1694) - Fixed spawn flow to propagate `IsSceneObject` down to children NetworkObjects, decouple implicit relationship between object spawning & `IsSceneObject` flag (#1685) - Fixed error when serializing ConnectionApprovalMessage with scene management disabled when one or more objects is hidden via the CheckObjectVisibility delegate (#1720) - Fixed CheckObjectVisibility delegate not being properly invoked for connecting clients when Scene Management is enabled. (#1680) - Fixed NetworkList to properly call INetworkSerializable's NetworkSerialize() method (#1682) - Fixed NetworkVariables containing more than 1300 bytes of data (such as large NetworkLists) no longer cause an OverflowException (the limit on data size is now whatever limit the chosen transport imposes on fragmented NetworkDelivery mechanisms) (#1725) - Fixed ServerRpcParams and ClientRpcParams must be the last parameter of an RPC in order to function properly. Added a compile-time check to ensure this is the case and trigger an error if they're placed elsewhere (#1721) - Fixed FastBufferReader being created with a length of 1 if provided an input of length 0 (#1724) - Fixed The NetworkConfig's checksum hash includes the NetworkTick so that clients with a different tickrate than the server are identified and not allowed to connect (#1728) - Fixed OwnedObjects not being properly modified when using ChangeOwnership (#1731) - Improved performance in NetworkAnimator (#1735) - Removed the "always sync" network animator (aka "autosend") parameters (#1746)	2022-03-02 00:00:00 +00:00