diff --git a/NewHorizons/Builder/Props/Audio/SignalBuilder.cs b/NewHorizons/Builder/Props/Audio/SignalBuilder.cs
index e5e0b8852..66a86061d 100644
--- a/NewHorizons/Builder/Props/Audio/SignalBuilder.cs
+++ b/NewHorizons/Builder/Props/Audio/SignalBuilder.cs
@@ -41,7 +41,9 @@ public static void Init()
 
             Initialized = true;
 
+            SceneManager.sceneUnloaded -= OnSceneUnloaded;
             SceneManager.sceneUnloaded += OnSceneUnloaded;
+            Main.Instance.OnStarSystemLoaded.RemoveListener(OnStarSystemLoaded);
             Main.Instance.OnStarSystemLoaded.AddListener(OnStarSystemLoaded);
         }
 
diff --git a/NewHorizons/Builder/Props/BrambleNodeBuilder.cs b/NewHorizons/Builder/Props/BrambleNodeBuilder.cs
index 990b7c183..c02837c87 100644
--- a/NewHorizons/Builder/Props/BrambleNodeBuilder.cs
+++ b/NewHorizons/Builder/Props/BrambleNodeBuilder.cs
@@ -260,9 +260,17 @@ public static GameObject Make(GameObject go, Sector sector, BrambleNodeInfo conf
                 // Default size is 70
                 var fog = brambleNode.FindChild("Effects/InnerWarpFogSphere");
                 fog.transform.localScale = Vector3.one * config.scale * 70f;
-                var fogMaterial = fog.GetComponent<MeshRenderer>().material;
-                fogMaterial.SetFloat("_Radius", fogMaterial.GetFloat("_Radius") * config.scale);
-                fogMaterial.SetFloat("_Density", fogMaterial.GetFloat("_Density") / config.scale);
+
+                // Copy shared material to not be shared
+                var fogRenderer = fog.GetComponent<MeshRenderer>();
+                fogRenderer.material = new Material(fogRenderer.sharedMaterial);
+                fogRenderer.material.SetFloat("_Radius", fogRenderer.material.GetFloat("_Radius") * config.scale);
+                fogRenderer.material.SetFloat("_Density", fogRenderer.material.GetFloat("_Density") / config.scale);
+                // Fixes bramble nodes being a weird colour until you approach the first time #372
+                if (config.fogTint != null)
+                {
+                    fog.GetComponent<OWRenderer>().SetColor(config.fogTint.ToColor());
+                }
             }
 
             // Set colors
@@ -393,7 +401,8 @@ public static GameObject Make(GameObject go, Sector sector, BrambleNodeInfo conf
                 }
             }
 
-            StreamingHandler.SetUpStreaming(brambleNode, sector);
+            // If the outer fog warp volume is null we're exposed to the solar system so treat it as a keepLoaded type prop
+            StreamingHandler.SetUpStreaming(brambleNode, outerFogWarpVolume == null ? null : sector);
 
             // Done!
             brambleNode.SetActive(true);
diff --git a/NewHorizons/Builder/Props/TranslatorText/TranslatorTextBuilder.cs b/NewHorizons/Builder/Props/TranslatorText/TranslatorTextBuilder.cs
index 48a1cc4e0..6ff148ef2 100644
--- a/NewHorizons/Builder/Props/TranslatorText/TranslatorTextBuilder.cs
+++ b/NewHorizons/Builder/Props/TranslatorText/TranslatorTextBuilder.cs
@@ -631,6 +631,12 @@ internal static GameObject MakeArc(NomaiTextArcInfo arcInfo, GameObject conversa
             XmlDocument xmlDocument = new XmlDocument();
             xmlDocument.LoadXml(xmlPath);
             XmlNode rootNode = xmlDocument.SelectSingleNode("NomaiObject");
+            
+            if (rootNode == null)
+            {
+                NHLogger.LogError($"Couldn't find NomaiObject in [{xmlPath}]");
+                return dict;
+            }
 
             foreach (object obj in rootNode.SelectNodes("TextBlock"))
             {
diff --git a/NewHorizons/Handlers/PlanetCreationHandler.cs b/NewHorizons/Handlers/PlanetCreationHandler.cs
index a0e9f4c37..686abcfb4 100644
--- a/NewHorizons/Handlers/PlanetCreationHandler.cs
+++ b/NewHorizons/Handlers/PlanetCreationHandler.cs
@@ -158,8 +158,20 @@ public static bool LoadBody(NewHorizonsBody body, bool defaultPrimaryToSun = fal
             }
             catch (Exception)
             {
-                if (body?.Config?.name == null) NHLogger.LogError($"How is there no name for {body}");
-                else existingPlanet = SearchUtilities.Find(body.Config.name.Replace(" ", "") + "_Body", false);
+                if (body?.Config?.name == null)
+                {
+                    NHLogger.LogError($"How is there no name for {body}");
+                }
+                else
+                {
+                    existingPlanet = SearchUtilities.Find(body.Config.name.Replace(" ", "") + "_Body", false);
+                }
+            }
+
+            if (existingPlanet == null && body.Config.destroy)
+            {
+                NHLogger.LogError($"{body.Config.name} was meant to be destroyed, but was not found");
+                return false;
             }
 
             if (existingPlanet != null)
@@ -169,8 +181,14 @@ public static bool LoadBody(NewHorizonsBody body, bool defaultPrimaryToSun = fal
                     if (body.Config.destroy)
                     {
                         var ao = existingPlanet.GetComponent<AstroObject>();
-                        if (ao != null) Delay.FireInNUpdates(() => PlanetDestructionHandler.RemoveBody(ao), 2);
-                        else Delay.FireInNUpdates(() => PlanetDestructionHandler.DisableBody(existingPlanet, false), 2);
+                        if (ao != null)
+                        {
+                            Delay.FireInNUpdates(() => PlanetDestructionHandler.DisableAstroObject(ao), 2);
+                        }
+                        else
+                        {
+                            Delay.FireInNUpdates(() => PlanetDestructionHandler.DisableGameObject(existingPlanet), 2);
+                        }
                     }
                     else if (body.Config.isQuantumState)
                     {
diff --git a/NewHorizons/Handlers/PlanetDestructionHandler.cs b/NewHorizons/Handlers/PlanetDestructionHandler.cs
index 272dc68ef..cc36636c7 100644
--- a/NewHorizons/Handlers/PlanetDestructionHandler.cs
+++ b/NewHorizons/Handlers/PlanetDestructionHandler.cs
@@ -12,48 +12,9 @@ namespace NewHorizons.Handlers
 {
     public static class PlanetDestructionHandler
     {
-        private static readonly string[] _solarSystemBodies = new string[]
-        {
-            "Ash Twin",
-            "Attlerock",
-            "Brittle Hollow",
-            "Dark Bramble",
-            "DreamWorld",
-            "Ember Twin",
-            "Giant's Deep",
-            "Hollow's Lantern",
-            "Interloper",
-            "Map Satellite",
-            "Orbital Probe Cannon",
-            "Quantum Moon",
-            "RingWorld",
-            "Sun",
-            "Sun Station",
-            "Timber Hearth",
-            "White Hole"
-        };
-
-        private static readonly string[] _eyeOfTheUniverseBodies = new string[]
-        {
-            "Eye Of The Universe",
-            "Vessel"
-        };
-
-        private static readonly string[] _suspendBlacklist = new string[]
-        {
-            "Player_Body",
-            "Ship_Body"
-        };
+        public static readonly string[] _suspendBlacklist = new string[] { "Player_Body", "Probe_Body", "Ship_Body" };
 
         public static void RemoveStockPlanets()
-        {
-            if (Main.Instance.CurrentStarSystem == "EyeOfTheUniverse")
-                RemoveEyeOfTheUniverse();
-            else
-                RemoveSolarSystem();
-        }
-
-        public static void RemoveSolarSystem()
         {
             // Adapted from EOTS thanks corby
             var toDisable = new List<GameObject>();
@@ -61,7 +22,7 @@ public static void RemoveSolarSystem()
             // Collect all rigid bodies and proxies
             foreach (var rigidbody in CenterOfTheUniverse.s_rigidbodies)
             {
-                if (rigidbody.name is not ("Player_Body" or "Probe_Body" or "Ship_Body"))
+                if (!_suspendBlacklist.Contains(rigidbody.name))
                 {
                     toDisable.Add(rigidbody.gameObject);
                 }
@@ -83,137 +44,145 @@ public static void RemoveSolarSystem()
                 }
                 GameObject.FindObjectOfType<SunProxy>().gameObject.SetActive(false);
                 
-                // force call update here to make it switch to an active star. idk why we didnt have to do this before
-                SunLightEffectsController.Instance.Update();
-                
-                // Since we didn't call RemoveBody on the Stranger have to call this here
-                StrangerRemoved();
+                if (Main.Instance.CurrentStarSystem != "EyeOfTheUniverse")
+                {
+                    // Since we didn't call RemoveBody on the all planets there are some we have to call here
+                    StrangerRemoved();
+                    TimberHearthRemoved();
+                    GiantsDeepRemoved();
+                    SunRemoved();
+                }
 
-                // Don't forget to fix THE WARP BUG
-                DisableBody(SearchUtilities.Find("StreamingGroup_TH"), true);
             }, 2); // Have to wait or shit goes wild
+        }
 
-            foreach (var streamingAssetBundle in StreamingManager.s_activeBundles)
+        #region Planet specific removals
+        public static void StrangerRemoved()
+        {
+            CloakHandler.FlagStrangerDisabled = true;
+
+            if (Locator._cloakFieldController?.GetComponentInParent<AstroObject>()?.GetAstroObjectName() == AstroObject.Name.RingWorld)
             {
-                //streamingAssetBundle.Unload();
+                Locator._cloakFieldController = null;
             }
         }
 
-        public static void RemoveEyeOfTheUniverse()
+        private static void SunRemoved()
         {
-            foreach (var name in _eyeOfTheUniverseBodies)
+            var sun = SearchUtilities.Find("Sun_Body").GetComponent<AstroObject>();
+
+            var starController = sun.gameObject.GetComponent<StarController>();
+            SunLightEffectsController.RemoveStar(starController);
+            SunLightEffectsController.RemoveStarLight(sun.transform.Find("Sector_SUN/Effects_SUN/SunLight").GetComponent<Light>());
+            UnityEngine.Object.Destroy(starController);
+
+            var audio = sun.GetComponentInChildren<SunSurfaceAudioController>();
+            UnityEngine.Object.Destroy(audio);
+
+            foreach (var owAudioSource in sun.GetComponentsInChildren<OWAudioSource>())
+            {
+                owAudioSource.Stop();
+                UnityEngine.Object.Destroy(owAudioSource);
+            }
+
+            foreach (var audioSource in sun.GetComponentsInChildren<AudioSource>())
             {
-                var ao = AstroObjectLocator.GetAstroObject(name);
-                if (ao != null) Delay.FireInNUpdates(() => RemoveBody(ao, false), 2);
-                else NHLogger.LogError($"Couldn't find [{name}]");
+                audioSource.Stop();
+                UnityEngine.Object.Destroy(audioSource);
             }
+
+            foreach (var sunProxy in UnityEngine.Object.FindObjectsOfType<SunProxy>())
+            {
+                NHLogger.LogVerbose($"Destroying SunProxy {sunProxy.gameObject.name}");
+                UnityEngine.Object.Destroy(sunProxy.gameObject);
+            }
+
+            // Stop the sun from breaking stuff when the supernova gets triggered
+            GlobalMessenger.RemoveListener("TriggerSupernova", sun.GetComponent<SunController>().OnTriggerSupernova);
+
+            // Just to be safe
+            SunLightEffectsController.Instance.Update();
         }
 
-        public static void StrangerRemoved()
+        private static void TimberHearthRemoved()
         {
-            CloakHandler.FlagStrangerDisabled = true;
+            // Always just fucking kill this one to stop THE WARP BUG!!!
+            GameObject.Destroy(SearchUtilities.Find("StreamingGroup_TH").gameObject);
 
-            if (Locator._cloakFieldController?.GetComponentInParent<AstroObject>()?.GetAstroObjectName() == AstroObject.Name.RingWorld)
+            var timberHearth = SearchUtilities.Find("TimberHearth_Body");
+            foreach (var obj in timberHearth.GetComponentsInChildren<DayNightTracker>())
             {
-                Locator._cloakFieldController = null;
+                GameObject.Destroy(obj.gameObject);
+            }
+            foreach (var obj in timberHearth.GetComponentsInChildren<VillageMusicVolume>())
+            {
+                GameObject.Destroy(obj.gameObject);
             }
         }
 
-        public static void RemoveBody(AstroObject ao, bool delete = false, List<AstroObject> toDestroy = null)
+        private static void GiantsDeepRemoved()
         {
-            NHLogger.LogVerbose($"Removing [{ao.name}]");
-
-            if (ao.GetAstroObjectName() == AstroObject.Name.RingWorld)
+            foreach (var jelly in UnityEngine.Object.FindObjectsOfType<JellyfishController>())
             {
-                StrangerRemoved();
+                if (jelly.GetSector().GetRootSector().GetName() == Sector.Name.GiantsDeep)
+                {
+                    DisableGameObject(jelly.gameObject);
+                }
             }
+        }
+        #endregion
 
+        public static void DisableAstroObject(AstroObject ao, List<AstroObject> toDisable = null)
+        {
             if (ao.gameObject == null || !ao.gameObject.activeInHierarchy)
             {
-                NHLogger.LogVerbose($"[{ao.name}] was already removed");
+                NHLogger.LogVerbose($"[{ao?.name}] was already removed");
                 return;
             }
 
-            if (toDestroy == null) toDestroy = new List<AstroObject>();
+            NHLogger.LogVerbose($"Removing [{ao.name}]");
+
+            toDisable ??= new List<AstroObject>();
 
-            if (toDestroy.Contains(ao))
+            if (toDisable.Contains(ao))
             {
                 NHLogger.LogVerbose($"Possible infinite recursion in RemoveBody: {ao.name} might be it's own primary body?");
                 return;
             }
 
-            toDestroy.Add(ao);
+            toDisable.Add(ao);
 
             try
             {
                 switch(ao._name)
                 {
                     case AstroObject.Name.BrittleHollow:
-                        RemoveBody(AstroObjectLocator.GetAstroObject(AstroObject.Name.WhiteHole.ToString()), delete, toDestroy);
+                        DisableAstroObject(AstroObjectLocator.GetAstroObject(AstroObject.Name.WhiteHole.ToString()), toDisable);
                         // Might prevent leftover fragments from existing
                         // Might also prevent people from using their own detachable fragments however
                         foreach(var fragment in UnityEngine.Object.FindObjectsOfType<DetachableFragment>())
                         {
-                            DisableBody(fragment.gameObject, delete);
+                            DisableGameObject(fragment.gameObject);
                         }
                         break;
+
                     case AstroObject.Name.CaveTwin:
                     case AstroObject.Name.TowerTwin:
-                        DisableBody(SearchUtilities.Find("FocalBody"), delete);
-                        DisableBody(SearchUtilities.Find("SandFunnel_Body", false), delete);
+                        DisableGameObject(SearchUtilities.Find("FocalBody"));
+                        DisableGameObject(SearchUtilities.Find("SandFunnel_Body", false));
                         break;
+
                     case AstroObject.Name.GiantsDeep:
-                        // Might prevent leftover jellyfish from existing
-                        // Might also prevent people from using their own jellyfish however
-                        foreach (var jelly in UnityEngine.Object.FindObjectsOfType<JellyfishController>())
-                        {
-                            DisableBody(jelly.gameObject, delete);
-                        }
-                        // Else it will re-eanble the pieces
-                        // ao.GetComponent<OrbitalProbeLaunchController>()._realDebrisSectorProxies = null;
+                        GiantsDeepRemoved();
                         break;
                     case AstroObject.Name.TimberHearth:
-                        // Always just fucking kill this one to stop THE WARP BUG!!!
-                        DisableBody(SearchUtilities.Find("StreamingGroup_TH"), true);
-
-                        foreach (var obj in UnityEngine.Object.FindObjectsOfType<DayNightTracker>())
-                        {
-                            DisableBody(obj.gameObject, true);
-                        }
-                        foreach (var obj in UnityEngine.Object.FindObjectsOfType<VillageMusicVolume>())
-                        {
-                            DisableBody(obj.gameObject, true);
-                        }
+                        TimberHearthRemoved();
                         break;
                     case AstroObject.Name.Sun:
-                        var starController = ao.gameObject.GetComponent<StarController>();
-                        SunLightEffectsController.RemoveStar(starController);
-                        SunLightEffectsController.RemoveStarLight(ao.transform.Find("Sector_SUN/Effects_SUN/SunLight").GetComponent<Light>());
-                        UnityEngine.Object.Destroy(starController);
-
-                        var audio = ao.GetComponentInChildren<SunSurfaceAudioController>();
-                        UnityEngine.Object.Destroy(audio);
-
-                        foreach (var owAudioSource in ao.GetComponentsInChildren<OWAudioSource>())
-                        {
-                            owAudioSource.Stop();
-                            UnityEngine.Object.Destroy(owAudioSource);
-                        }
-
-                        foreach (var audioSource in ao.GetComponentsInChildren<AudioSource>())
-                        {
-                            audioSource.Stop();
-                            UnityEngine.Object.Destroy(audioSource);
-                        }
-
-                        foreach (var sunProxy in UnityEngine.Object.FindObjectsOfType<SunProxy>())
-                        {
-                            NHLogger.LogVerbose($"Destroying SunProxy {sunProxy.gameObject.name}");
-                            UnityEngine.Object.Destroy(sunProxy.gameObject);
-                        }
-
-                        // Stop the sun from breaking stuff when the supernova gets triggered
-                        GlobalMessenger.RemoveListener("TriggerSupernova", ao.GetComponent<SunController>().OnTriggerSupernova);
+                        SunRemoved();
+                        break;
+                    case AstroObject.Name.RingWorld:
+                        StrangerRemoved();
                         break;
                 }
 
@@ -230,8 +199,14 @@ public static void RemoveBody(AstroObject ao, bool delete = false, List<AstroObj
 
                     // Some children might be astro objects and as such can have children of their own
                     var childAO = child.GetComponent<AstroObject>();
-                    if (childAO != null) RemoveBody(childAO, false, toDestroy);
-                    else DisableBody(child, true);
+                    if (childAO != null)
+                    {
+                        DisableAstroObject(childAO, toDisable);
+                    }
+                    else
+                    {
+                        DisableGameObject(child);
+                    }
                 }
 
                 // Always delete moons
@@ -239,7 +214,7 @@ public static void RemoveBody(AstroObject ao, bool delete = false, List<AstroObj
                 {
                     if (obj == null) continue;
 
-                    RemoveBody(obj.GetComponent<AstroObject>(), false, toDestroy);
+                    DisableAstroObject(obj.GetComponent<AstroObject>(), toDisable);
                 }
             }
             catch (Exception e)
@@ -247,36 +222,8 @@ public static void RemoveBody(AstroObject ao, bool delete = false, List<AstroObj
                 NHLogger.LogError($"Exception thrown when trying to delete bodies related to [{ao.name}]:\n{e}");
             }
 
-            // Deal with proxies
-            foreach (var p in UnityEngine.Object.FindObjectsOfType<ProxyOrbiter>())
-            {
-                if (p._originalBody == ao.gameObject)
-                {
-                    DisableBody(p.gameObject, true);
-                    break;
-                }
-            }
-            RemoveProxy(ao.name.Replace("_Body", ""));
-
-            Delay.RunWhen(() => Main.IsSystemReady, () => DisableBody(ao.gameObject, delete));
-
-            foreach (ProxyBody proxy in UnityEngine.Object.FindObjectsOfType<ProxyBody>())
-            {
-                if (proxy?._realObjectTransform?.gameObject == ao.gameObject)
-                {
-                    UnityEngine.Object.Destroy(proxy.gameObject);
-                }
-            }
-        }
-
-        public static void RemoveAllProxies()
-        {
-            UnityEngine.Object.Destroy(UnityEngine.Object.FindObjectOfType<DistantProxyManager>().gameObject);
-
-            foreach (var name in _solarSystemBodies)
-            {
-                RemoveProxy(name.Replace(" ", "").Replace("'", ""));
-            }
+            DisableGameObject(ao.gameObject);
+            RemoveProxy(ao);
         }
 
         private static bool CanSuspend(OWRigidbody rigidbody, string name)
@@ -286,7 +233,7 @@ private static bool CanSuspend(OWRigidbody rigidbody, string name)
             return CanSuspend(rigidbody._origParentBody, name);
         }
 
-        internal static void DisableBody(GameObject go, bool delete)
+        internal static void DisableGameObject(GameObject go)
         {
             if (go == null) return;
 
@@ -317,33 +264,18 @@ internal static void DisableBody(GameObject go, bool delete)
                 }
             }
 
-            if (delete)
+            go.SetActive(false);
+            var ol = go.GetComponentInChildren<OrbitLine>();
+            if (ol)
             {
-                UnityEngine.Object.Destroy(go);
-            }
-            else
-            {
-                go.SetActive(false);
-                var ol = go.GetComponentInChildren<OrbitLine>();
-                if (ol)
-                {
-                    ol.enabled = false;
-                }
+                ol.enabled = false;
             }
         }
 
-        private static void RemoveProxy(string name)
+        private static void RemoveProxy(AstroObject ao)
         {
-            if (name.Equals("TowerTwin")) name = "AshTwin";
-            if (name.Equals("CaveTwin")) name = "EmberTwin";
-            var distantProxy = SearchUtilities.Find(name + "_DistantProxy", false);
-            var distantProxyClone = SearchUtilities.Find(name + "_DistantProxy(Clone)", false);
-
-            if (distantProxy != null) UnityEngine.Object.Destroy(distantProxy.gameObject);
-            if (distantProxyClone != null) UnityEngine.Object.Destroy(distantProxyClone.gameObject);
-
-            if (distantProxy == null && distantProxyClone == null)
-                NHLogger.LogVerbose($"Couldn't find proxy for {name}");
+            ProxyHandler.GetVanillaProxyBody(ao.transform)?.gameObject?.SetActive(false);
+            ProxyHandler.GetVanillaProxyOrbiter(ao.transform)?.gameObject?.SetActive(false);
         }
     }
 }
diff --git a/NewHorizons/Handlers/ProxyHandler.cs b/NewHorizons/Handlers/ProxyHandler.cs
index 090d519d8..811d0837c 100644
--- a/NewHorizons/Handlers/ProxyHandler.cs
+++ b/NewHorizons/Handlers/ProxyHandler.cs
@@ -1,11 +1,21 @@
 using NewHorizons.Components;
 using System.Collections.Generic;
+using UnityEngine;
 
 namespace NewHorizons.Handlers
 {
     public static class ProxyHandler
     {
-        private static List<NHProxy> _proxies = new List<NHProxy>();
+        private static List<NHProxy> _proxies = new();
+        private static Dictionary<Transform, ProxyBody> _vanillaProxyBody = new();
+        private static Dictionary<Transform, ProxyOrbiter> _vanillaProxyOrbiter = new();
+
+        public static void ClearCache()
+        {
+            _proxies.Clear();
+            _vanillaProxyBody.Clear();
+            _vanillaProxyOrbiter.Clear();
+        }
 
         public static NHProxy GetProxy(string astroName)
         {
@@ -17,6 +27,48 @@ public static NHProxy GetProxy(string astroName)
             return null;
         }
 
+        public static void RegisterVanillaProxyBody(ProxyBody proxy)
+        {
+            if (proxy.realObjectTransform != null)
+            {
+                _vanillaProxyBody.Add(proxy.realObjectTransform, proxy);
+            }
+        }
+
+        public static ProxyBody GetVanillaProxyBody(Transform t)
+        {
+            if (_vanillaProxyBody.TryGetValue(t, out ProxyBody proxy))
+            {
+                return proxy;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public static void RegisterVanillaProxyOrbiter(ProxyOrbiter proxy)
+        {
+            // The _originalBody is the moon
+            // For _originalPlanetBody, that game object will also have a ProxyBody on it so it'd be counted via the other cache
+            if (proxy._originalBody != null)
+            {
+                _vanillaProxyOrbiter.Add(proxy._originalBody, proxy);
+            }
+        }
+
+        public static ProxyOrbiter GetVanillaProxyOrbiter(Transform t)
+        {
+            if (_vanillaProxyOrbiter.TryGetValue(t, out ProxyOrbiter proxy))
+            {
+                return proxy;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
         public static void RegisterProxy(NHProxy proxy)
         {
             _proxies.SafeAdd(proxy);
diff --git a/NewHorizons/Main.cs b/NewHorizons/Main.cs
index e056b4c39..fbfe94fb6 100644
--- a/NewHorizons/Main.cs
+++ b/NewHorizons/Main.cs
@@ -58,8 +58,27 @@ public class Main : ModBehaviour
         public static bool IsSystemReady { get; private set; }
 
         public string DefaultStarSystem => SystemDict.ContainsKey(_defaultSystemOverride) ? _defaultSystemOverride : _defaultStarSystem;
-        public string CurrentStarSystem => _currentStarSystem;
-        public bool TimeLoopEnabled => SystemDict[CurrentStarSystem]?.Config?.enableTimeLoop ?? true;
+        public string CurrentStarSystem
+        {
+            get
+            {
+                return _currentStarSystem;
+            }
+            set
+            {
+                // Prevent invalid values
+                if (value != "SolarSystem" && value != "EyeOfTheUniverse" && !SystemDict.ContainsKey(value) && !BodyDict.ContainsKey(value))
+                {
+                    NHLogger.LogError($"System \"{value}\" does not exist!");
+                    _currentStarSystem = DefaultStarSystem;
+                }
+                _currentStarSystem = value;
+            }
+        }
+        private string _currentStarSystem; 
+        private string _previousStarSystem;
+
+        public bool TimeLoopEnabled => CurrentStarSystem == null || (SystemDict[CurrentStarSystem]?.Config?.enableTimeLoop ?? true);
         public bool IsWarpingFromShip { get; private set; } = false;
         public bool IsWarpingFromVessel { get; private set; } = false;
         public bool IsWarpingBackToEye { get; internal set; } = false;
@@ -72,7 +91,7 @@ public class Main : ModBehaviour
         public static bool HasWarpDrive { get; private set; } = false;
 
         private string _defaultStarSystem = "SolarSystem";
-        internal string _currentStarSystem = "SolarSystem";
+
         private bool _firstLoad = true;
 
         private bool _playerAwake;
@@ -259,11 +278,20 @@ public void OnDestroy()
 
         private void OnSceneUnloaded(Scene scene)
         {
+            // Caches of GameObjects must always be cleared
             SearchUtilities.ClearCache();
-            ImageUtilities.ClearCache();
-            AudioUtilities.ClearCache();
-            AssetBundleUtilities.ClearCache();
-            EnumUtilities.ClearCache();
+            ProxyHandler.ClearCache();
+
+            // Caches of other assets only have to be cleared if we changed star systems
+            if (CurrentStarSystem != _previousStarSystem)
+            {
+                NHLogger.Log($"Changing star system from {_previousStarSystem} to {CurrentStarSystem} - Clearing system-specific caches!");
+                ImageUtilities.ClearCache();
+                AudioUtilities.ClearCache();
+                AssetBundleUtilities.ClearCache();
+                EnumUtilities.ClearCache();
+            }
+
             IsSystemReady = false;
         }
 
@@ -329,7 +357,7 @@ private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
 
             if (isEyeOfTheUniverse)
             {
-                _currentStarSystem = "EyeOfTheUniverse";
+                CurrentStarSystem = "EyeOfTheUniverse";
             }
             else if (IsWarpingBackToEye)
             {
@@ -340,14 +368,8 @@ private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
                 return;
             }
 
-            if (!SystemDict.ContainsKey(_currentStarSystem) || !BodyDict.ContainsKey(_currentStarSystem))
-            {
-                NHLogger.LogError($"System \"{_currentStarSystem}\" does not exist!");
-                _currentStarSystem = DefaultStarSystem;
-            }
-
             // Set time loop stuff if its enabled and if we're warping to a new place
-            if (IsChangingStarSystem && (SystemDict[_currentStarSystem].Config.enableTimeLoop || _currentStarSystem == "SolarSystem") && SecondsElapsedInLoop > 0f)
+            if (IsChangingStarSystem && (SystemDict[CurrentStarSystem].Config.enableTimeLoop || CurrentStarSystem == "SolarSystem") && SecondsElapsedInLoop > 0f)
             {
                 TimeLoopUtilities.SetSecondsElapsed(SecondsElapsedInLoop);
                 // Prevent the OPC from firing
@@ -362,7 +384,7 @@ private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
                     launchController.enabled = false;
                 }
                 var nomaiProbe = SearchUtilities.Find("NomaiProbe_Body");
-                if (nomaiProbe != null) nomaiProbe.gameObject.SetActive(false);
+                nomaiProbe?.gameObject.SetActive(false);
             }
 
             // Reset this
@@ -554,6 +576,10 @@ private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
             {
                 ResetCurrentStarSystem();
             }
+
+            // We only check previous when the scene unloads, and at that point current should be updated to the new system
+            NHLogger.LogVerbose($"Set the previous system to {CurrentStarSystem}");
+            _previousStarSystem = CurrentStarSystem;
         }
 
         // Had a bunch of separate unity things firing stuff when the system is ready so I moved it all to here
@@ -603,7 +629,7 @@ public void LoadStarSystemConfig(string starSystemName, StarSystemConfig starSys
                 if (starSystemName != "SolarSystem")
                 {
                     SetDefaultSystem(starSystemName);
-                    _currentStarSystem = DefaultStarSystem;
+                    CurrentStarSystem = DefaultStarSystem;
                 }
             }
 
@@ -820,7 +846,7 @@ public void ChangeCurrentStarSystem(string newStarSystem, bool warp = false, boo
             // If we're just on the title screen set the system for later
             if (LoadManager.GetCurrentScene() == OWScene.TitleScreen)
             {
-                _currentStarSystem = newStarSystem;
+                CurrentStarSystem = newStarSystem;
                 IsWarpingFromShip = warp;
                 IsWarpingFromVessel = vessel;
                 DidWarpFromVessel = false;
@@ -864,13 +890,13 @@ public void ChangeCurrentStarSystem(string newStarSystem, bool warp = false, boo
                 {
                     PlayerData.SaveEyeCompletion(); // So that the title screen doesn't keep warping you back to eye
 
-                    if (SystemDict[_currentStarSystem].Config.enableTimeLoop) SecondsElapsedInLoop = TimeLoop.GetSecondsElapsed();
+                    if (SystemDict[CurrentStarSystem].Config.enableTimeLoop) SecondsElapsedInLoop = TimeLoop.GetSecondsElapsed();
                     else SecondsElapsedInLoop = -1;
 
                     sceneToLoad = OWScene.SolarSystem;
                 }
 
-                _currentStarSystem = newStarSystem;
+                CurrentStarSystem = newStarSystem;
 
                 // Freeze player inputs
                 OWInput.ChangeInputMode(InputMode.None);
@@ -890,7 +916,7 @@ void OnDeath(DeathType _)
             // We reset the solar system on death
             if (!IsChangingStarSystem)
             {
-                if (SystemDict[_currentStarSystem].Config.respawnHere) return;
+                if (SystemDict[CurrentStarSystem].Config.respawnHere) return;
 
                 ResetCurrentStarSystem();
             }
@@ -900,7 +926,7 @@ private void ResetCurrentStarSystem()
         {
             if (SystemDict.ContainsKey(_defaultSystemOverride))
             {
-                _currentStarSystem = _defaultSystemOverride;
+                CurrentStarSystem = _defaultSystemOverride;
 
                 // Sometimes the override will not support spawning regularly, so always warp in
                 IsWarpingFromShip = true;
@@ -913,7 +939,7 @@ private void ResetCurrentStarSystem()
                     NHLogger.LogError($"The given default system override {_defaultSystemOverride} is invalid - no system exists with that name");
                 }
 
-                _currentStarSystem = _defaultStarSystem;
+                CurrentStarSystem = _defaultStarSystem;
                 IsWarpingFromShip = false;
             }
         }
diff --git a/NewHorizons/Patches/EyeScenePatches/LoadManagerPatches.cs b/NewHorizons/Patches/EyeScenePatches/LoadManagerPatches.cs
index 2bf53abfa..cf12480a1 100644
--- a/NewHorizons/Patches/EyeScenePatches/LoadManagerPatches.cs
+++ b/NewHorizons/Patches/EyeScenePatches/LoadManagerPatches.cs
@@ -12,10 +12,10 @@ private static void OnLoadScene(OWScene scene)
                 PlayerData.SaveEyeCompletion();
 
                 // Switch to default just in case another mod warps back.
-                if (Main.Instance.CurrentStarSystem == "EyeOfTheUniverse") Main.Instance._currentStarSystem = Main.Instance.DefaultStarSystem;
+                if (Main.Instance.CurrentStarSystem == "EyeOfTheUniverse") Main.Instance.CurrentStarSystem = Main.Instance.DefaultStarSystem;
             }
             // Switch to eye just in case another mod warps there.
-            else if (scene == OWScene.EyeOfTheUniverse) Main.Instance._currentStarSystem = "EyeOfTheUniverse";
+            else if (scene == OWScene.EyeOfTheUniverse) Main.Instance.CurrentStarSystem = "EyeOfTheUniverse";
         }
 
         [HarmonyPrefix]
diff --git a/NewHorizons/Patches/ProxyPatches/ProxyBodyPatches.cs b/NewHorizons/Patches/ProxyPatches/ProxyBodyPatches.cs
index 5ff71810d..c3d83d835 100644
--- a/NewHorizons/Patches/ProxyPatches/ProxyBodyPatches.cs
+++ b/NewHorizons/Patches/ProxyPatches/ProxyBodyPatches.cs
@@ -1,15 +1,22 @@
 using HarmonyLib;
+using NewHorizons.Handlers;
 
-namespace NewHorizons.Patches.ProxyPatches
+namespace NewHorizons.Patches.ProxyPatches;
+
+[HarmonyPatch(typeof(ProxyBody))]
+public static class ProxyBodyPatches
 {
-    [HarmonyPatch(typeof(ProxyBody))]
-    public static class ProxyBodyPatches
+    [HarmonyPostfix]
+    [HarmonyPatch(nameof(ProxyBody.LateInitialize))]
+    public static void ProxyBody_LateInitialize(ProxyBody __instance)
+    {
+        ProxyHandler.RegisterVanillaProxyBody(__instance);
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(nameof(ProxyBody.IsObjectInSupernova))]
+    public static bool ProxyBody_IsObjectInSupernova(ProxyBody __instance)
     {
-        [HarmonyPrefix]
-        [HarmonyPatch(nameof(ProxyBody.IsObjectInSupernova))]
-        public static bool ProxyBody_IsObjectInSupernova(ProxyBody __instance)
-        {
-            return Locator.GetSunController() != null;
-        }
+        return Locator.GetSunController() != null;
     }
 }
diff --git a/NewHorizons/Patches/ProxyPatches/ProxyOrbiterPatches.cs b/NewHorizons/Patches/ProxyPatches/ProxyOrbiterPatches.cs
new file mode 100644
index 000000000..be099350a
--- /dev/null
+++ b/NewHorizons/Patches/ProxyPatches/ProxyOrbiterPatches.cs
@@ -0,0 +1,15 @@
+using HarmonyLib;
+using NewHorizons.Handlers;
+
+namespace NewHorizons.Patches.ProxyPatches;
+
+[HarmonyPatch(typeof(ProxyOrbiter))]
+public static class ProxyOrbiterPatches
+{
+    [HarmonyPostfix]
+    [HarmonyPatch(nameof(ProxyOrbiter.SetOriginalBodies))]
+    public static void ProxyOrbiter_SetOriginalBodies(ProxyOrbiter __instance)
+    {
+        ProxyHandler.RegisterVanillaProxyOrbiter(__instance);
+    }
+}
diff --git a/NewHorizons/Patches/WarpPatches/VesselWarpControllerPatches.cs b/NewHorizons/Patches/WarpPatches/VesselWarpControllerPatches.cs
index 8089ac893..559f43d02 100644
--- a/NewHorizons/Patches/WarpPatches/VesselWarpControllerPatches.cs
+++ b/NewHorizons/Patches/WarpPatches/VesselWarpControllerPatches.cs
@@ -63,7 +63,7 @@ public static bool VesselWarpController_OnSlotActivated(VesselWarpController __i
                 Locator.GetPauseCommandListener().AddPauseCommandLock();
                 if (canWarpToEye || canWarpToStarSystem && targetSystem == "EyeOfTheUniverse")
                 {
-                    Main.Instance._currentStarSystem = "EyeOfTheUniverse";
+                    Main.Instance.CurrentStarSystem = "EyeOfTheUniverse";
                     LoadManager.LoadSceneAsync(OWScene.EyeOfTheUniverse, false, LoadManager.FadeType.ToWhite);
                 }
                 else if (canWarpToStarSystem)
diff --git a/NewHorizons/Utility/SearchUtilities.cs b/NewHorizons/Utility/SearchUtilities.cs
index 0bbc5990b..9ed77826b 100644
--- a/NewHorizons/Utility/SearchUtilities.cs
+++ b/NewHorizons/Utility/SearchUtilities.cs
@@ -10,11 +10,13 @@ namespace NewHorizons.Utility
     public static class SearchUtilities
     {
         private static readonly Dictionary<string, GameObject> CachedGameObjects = new Dictionary<string, GameObject>();
+        private static readonly Dictionary<string, GameObject> CachedRootGameObjects = new Dictionary<string, GameObject>();
 
         public static void ClearCache()
         {
             NHLogger.LogVerbose("Clearing search cache");
             CachedGameObjects.Clear();
+            CachedRootGameObjects.Clear();
         }
 
         public static List<T> FindObjectsOfTypeAndName<T>(string name) where T : Object
@@ -107,8 +109,16 @@ public static GameObject Find(string path, bool warn = true)
             // 2: find inactive using root + transform.find
             var names = path.Split('/');
 
+            // Cache the root objects so we don't loop through all of them each time
             var rootName = names[0];
-            var root = SceneManager.GetActiveScene().GetRootGameObjects().FirstOrDefault(x => x.name == rootName);
+            if (!CachedRootGameObjects.TryGetValue(rootName, out var root)) 
+            {
+                root = SceneManager.GetActiveScene().GetRootGameObjects().FirstOrDefault(x => x.name == rootName);
+                if (root != null)
+                {
+                    CachedRootGameObjects.Add(rootName, root);
+                }
+            }
 
             var childPath = string.Join("/", names.Skip(1));
             go = root ? root.FindChild(childPath) : null;