Added new single nested 'for' loop to the core, which can be subscribed to by modules and data members.
Added new single nested 'for' loop to the core, which can be subscribed to by modules and data members.

file:b/API/Enums.cs (new)
--- /dev/null
+++ b/API/Enums.cs
@@ -1,1 +1,25 @@
+// VOID © 2015 toadicus
+//
+// This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a
+// copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/
+using System;
 
+namespace VOID
+{
+	public enum VOID_TimeScale : UInt32
+	{
+		KERBIN_TIME = 1, // Earth if 0
+		SOLAR_DAY = 4, // Sidereal if 0
+		ROUNDED_SCALE = 1024 // Real values if 0
+	}
+
+	public enum IconState : UInt32
+	{
+		PowerOff = 1,
+		PowerOn = 2,
+		Inactive = 4,
+		Active = 8
+	}
+}
+
+

--- a/API/IVOID_Module.cs
+++ b/API/IVOID_Module.cs
@@ -33,20 +33,21 @@
 	public interface IVOID_Module
 	{
 		string Name { get; }
-		bool toggleActive { get; set; }
-		bool guiRunning { get; }
-		bool inValidScene { get; }
-		bool inValidGame { get; }
+		bool Active { get; set; }
+		bool GUIRunning { get; }
+		bool InValidScene { get; }
+		bool InValidGame { get; }
 
-		void DrawGUI();
+		void DrawGUI(object sender);
 		void StartGUI();
 		void StopGUI();
 
 		void DrawConfigurables();
 
-		void LoadConfig();
+		// void LoadConfig();
+		void LoadConfig(KSP.IO.PluginConfiguration config);
 
-		void _SaveToConfig(KSP.IO.PluginConfiguration config);
+		void Save(KSP.IO.PluginConfiguration config, string sceneKey);
 	}
 
 	public interface IVOID_BehaviorModule : IVOID_Module

--- a/API/VOIDCore.cs
+++ b/API/VOIDCore.cs
@@ -29,69 +29,183 @@
 using KerbalEngineer.VesselSimulator;
 using KSP;
 using System;
+using System.Linq;
 using System.Collections.Generic;
-using ToadicusTools;
 using UnityEngine;
 
 namespace VOID
 {
-	public abstract class VOIDCore : VOID_Module, IVOID_Module
+	public abstract class VOIDCore : VOID_WindowModule, IVOID_Module
 	{
 		public const double Constant_G = 6.674e-11;
 		public const int CONFIG_VERSION = 2;
 
-		public static bool useToolbarManager;
-
-		public abstract int configVersion { get; }
+		public static event VOIDEventHandler onModulesLoaded;
+		public static event VOIDEventHandler onModulesDestroyed;
+
+		protected static void FireOnModulesLoaded(object sender)
+		{
+			if (onModulesLoaded != null)
+			{
+				onModulesLoaded(sender);
+			}
+		}
+
+		protected static void FireOnModulesDestroyed(object sender)
+		{
+			if (onModulesDestroyed != null)
+			{
+				onModulesDestroyed(sender);
+			}
+		}
+
+		public abstract int ConfigVersion { get; }
 		public virtual bool configNeedsUpdate { get; set; }
 
-		public abstract int windowID { get; }
+		public virtual string SaveGamePath { get; protected set; }
+		public virtual string VOIDSettingsPath { get; protected set; }
+
+		public abstract string SceneKey { get; }
+
+		public abstract int WindowID { get; }
 		public abstract bool configDirty { get; set; }
 		public abstract bool powerAvailable	{ get; protected set; }
 
-		public abstract List<IVOID_Module> Modules { get; }
-
-		public abstract float updateTimer { get; protected set; }
-		public abstract double updatePeriod { get; }
+		public abstract IList<IVOID_Module> Modules { get; }
+
+		public abstract float UpdateTimer { get; protected set; }
+		public abstract double UpdatePeriod { get; }
 
 		public virtual float saveTimer { get; protected set; }
 
 		public abstract GUISkin Skin { get; }
 
 		public abstract CelestialBody HomeBody { get; }
-		public abstract List<CelestialBody> allBodies { get; }
-		public abstract List<CelestialBody> sortedBodyList { get; protected set; }
-
-		public abstract List<VesselType> allVesselTypes { get; }
-
+		public abstract List<CelestialBody> SortedBodyList { get; protected set; }
+
+		public abstract VesselType[] AllVesselTypes { get; protected set; }
 		public abstract Stage LastStage { get; protected set; }
 		public abstract Stage[] Stages { get; protected set; }
 
+		public abstract VOID_TimeScale TimeScale { get; protected set; }
+
 		public abstract event VOIDEventHandler onApplicationQuit;
 		public abstract event VOIDEventHandler onSkinChanged;
-
-		public virtual void OnGUI() {}
-
-		public override void LoadConfig()
-		{
-			var config = KSP.IO.PluginConfiguration.CreateForType<VOIDCore>(null);
-
-			useToolbarManager = config.GetValue("UseToolbarManager", useToolbarManager);
-
-			base.LoadConfig();
+		public abstract event VOIDEventHandler onUpdate;
+
+		public abstract event VOIDEventHandler onPreForEach;
+		public abstract event VOIDForEachPartHandler onForEachPart;
+		public abstract event VOIDForEachPartModuleHandler onForEachModule;
+		public abstract event VOIDEventHandler onPostForEach;
+
+		public virtual event VOIDEventHandler onPreRender;
+		public virtual event VOIDEventHandler onPostRender;
+
+		public virtual bool MethodInPreRenderQueue(VOIDEventHandler method)
+		{
+			if (this.onPreRender != null)
+			{
+				ToadicusTools.Logging.PostDebugMessage(this, "Looking in onPreRender for method {0} in onGui", method);
+
+				foreach (Delegate invoker in this.onPreRender.GetInvocationList())
+				{
+					ToadicusTools.Logging.PostDebugMessage(this, "Checking invoker {0}", invoker);
+
+					if (invoker == method)
+					{
+						ToadicusTools.Logging.PostDebugMessage(this, "Found match.");
+						return true;
+					}
+				}
+			}
+			#if DEBUG
+			else
+			{
+			ToadicusTools.Logging.PostDebugMessage(this, "this.onPreRender == null");
+			}
+			#endif
+
+
+			return false;
+		}
+
+		public virtual bool MethodInPostRenderQueue(VOIDEventHandler method)
+		{
+			if (this.onPostRender != null)
+			{
+				ToadicusTools.Logging.PostDebugMessage(this, "Looking in onPostRender for method {0} in onGui", method);
+
+				foreach (Delegate invoker in this.onPostRender.GetInvocationList())
+				{
+					ToadicusTools.Logging.PostDebugMessage(this, "Checking invoker {0}", invoker);
+
+					if (invoker == method)
+					{
+						ToadicusTools.Logging.PostDebugMessage(this, "Found match.");
+						return true;
+					}
+				}
+			}
+			#if DEBUG
+			else
+			{
+				ToadicusTools.Logging.PostDebugMessage(this, "this.onPostRender == null");
+			}
+			#endif
+
+
+			return false;
+		}
+
+		public void OnGUI()
+		{
+			if (Event.current.type == EventType.Repaint || Event.current.isMouse)
+			{
+				if (this.onPreRender != null)
+				{
+					ToadicusTools.Logging.PostDebugMessage(this, "In OnGUI; doing 'pre draw' stuff");
+					this.onPreRender(this);
+				}
+			}
+
+			if (this.onPostRender != null)
+			{
+				ToadicusTools.Logging.PostDebugMessage(this, "In OnGUI; doing 'post draw' stuff");
+				this.onPostRender(this);
+			}
 		}
 
 		public abstract void SaveConfig();
 
-		public override void _SaveToConfig(KSP.IO.PluginConfiguration config)
-		{
-			config.SetValue("UseToolbarManager", useToolbarManager);
-
-			base._SaveToConfig(config);
+		public override void Save(KSP.IO.PluginConfiguration config, string sceneKey)
+		{
+			base.Save(config, sceneKey);
+
 		}
 	}
 
 	public delegate void VOIDEventHandler(object sender);
+	public delegate void VOIDForEachPartHandler(object sender, VOIDForEachPartArgs args);
+	public delegate void VOIDForEachPartModuleHandler(object sender, VOIDForEachPartModuleArgs args);
+
+	public abstract class VOIDForEachEventArgs<T> : EventArgs where T : class
+	{
+		public T Data;
+
+		public VOIDForEachEventArgs(T data)
+		{
+			this.Data = data;
+		}
+	}
+
+	public class VOIDForEachPartArgs : VOIDForEachEventArgs<Part>
+	{
+		public VOIDForEachPartArgs(Part data) : base(data) {}
+	}
+	public class VOIDForEachPartModuleArgs : VOIDForEachEventArgs<PartModule>
+	{
+		public VOIDForEachPartModuleArgs(PartModule data) : base(data) {}
+	}
 }
 
 

--- a/API/VOIDMaster.cs
+++ b/API/VOIDMaster.cs
@@ -43,7 +43,7 @@
 using System;
 using UnityEngine;
 using KerbalEngineer.VesselSimulator;
-using ToadicusTools;
+using ToadicusTools.Extensions;
 
 namespace VOID
 {
@@ -75,11 +75,13 @@
 
 			this.Core.Update ();
 
-			if (this.Core.factoryReset)
+			if (this.Core.FactoryReset)
 			{
 				this.LogDebug("Factory reset is true; deleting config and disposing!");
 
 				KSP.IO.File.Delete<T>("config.xml");
+				System.IO.File.Delete(this.Core.VOIDSettingsPath);
+
 				this.Core.Dispose();
 				this.Core = null;
 			}
@@ -127,8 +129,11 @@
 
 		protected virtual bool InValidScene()
 		{
-			foreach (var attr in this.GetType().GetCustomAttributes(true))
+			object[] attributes = this.GetType().GetCustomAttributes(true);
+			object attr;
+			for (int idx = 0; idx < attributes.Length; idx++)
 			{
+				attr = attributes[idx];
 				if (attr is KSPAddon)
 				{
 					KSPAddon addonAttr = (KSPAddon)attr;

--- a/API/VOID_HUDModule.cs
+++ b/API/VOID_HUDModule.cs
@@ -31,7 +31,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using ToadicusTools;
+using ToadicusTools.GUIUtils;
 using UnityEngine;
 
 namespace VOID
@@ -56,11 +56,11 @@
 			{
 				if (this._colorIndex >= this.textColors.Count - 1)
 				{
-					this._colorIndex = 0;
+					this._colorIndex.value = 0;
 					return;
 				}
 
-				this._colorIndex = value;
+				this._colorIndex.value = value;
 			}
 		}
 
@@ -72,7 +72,7 @@
 
 		public VOID_HUDModule() : base()
 		{
-			this._colorIndex = 0;
+			this._colorIndex = (VOID_SaveValue<int>)0;
 
 			this.textColors = new List<Color>();
 
@@ -86,13 +86,18 @@
 			this.textColors.Add(Color.cyan);
 			this.textColors.Add(Color.magenta);
 
-			this.positionsLocked = true;
+			this.positionsLocked = (VOID_SaveValue<bool>)true;
 
 			this.Windows = new List<HUDWindow>();
 		}
 
-		public override void DrawGUI()
-		{
+		public override void DrawGUI(object sender)
+		{
+			if (this.core == null)
+			{
+				return;
+			}
+
 			VOID_Styles.labelHud.normal.textColor = textColors [ColorIndex];
 
 			GUI.skin = this.core.Skin;
@@ -104,10 +109,13 @@
 				SimManager.RequestSimulation();
 			}
 
-			foreach (HUDWindow window in this.Windows)
-			{
+			HUDWindow window;
+			for (int idx = 0; idx < this.Windows.Count; idx++)
+			{
+				window = this.Windows[idx];
+
 				window.WindowPos = GUILayout.Window(
-					this.core.windowID,
+					this.core.WindowID,
 					window.WindowPos,
 					VOID_Tools.GetWindowHandler(window.WindowFunction),
 					GUIContent.none,
@@ -127,24 +135,29 @@
 
 			if (GUILayout.Button(string.Intern("Reset HUD Positions"), GUILayout.ExpandWidth(false)))
 			{
-				foreach (HUDWindow window in this.Windows)
+				HUDWindow window;
+				for (int idx = 0; idx < this.Windows.Count; idx++)
 				{
+					window = this.Windows[idx];
+
 					window.WindowPos = new Rect(window.defaultWindowPos);
 				}
 			}
 
-			this.positionsLocked = GUITools.Toggle(this.positionsLocked, "Lock HUD Positions");
-		}
-
-		public override void LoadConfig()
-		{
-			base.LoadConfig();
-
-			var config = KSP.IO.PluginConfiguration.CreateForType<VOID_HUDModule>();
+			this.positionsLocked.value = Layout.Toggle(this.positionsLocked, "Lock HUD Positions");
+		}
+
+		public override void LoadConfig(KSP.IO.PluginConfiguration config)
+		{
+			base.LoadConfig(config);
+
 			config.load();
 
-			foreach (HUDWindow window in this.Windows)
-			{
+			HUDWindow window;
+			for (int idx = 0; idx < this.Windows.Count; idx++)
+			{
+				window = this.Windows[idx];
+
 				string saveName = string.Format("{0}_{1}", this.GetType().Name, window.WindowName);
 				Rect loadedPos = config.GetValue(saveName, window.defaultWindowPos);
 
@@ -152,12 +165,15 @@
 			}
 		}
 
-		public override void _SaveToConfig(KSP.IO.PluginConfiguration config)
-		{
-			base._SaveToConfig(config);
-
-			foreach (HUDWindow window in this.Windows)
-			{
+		public override void Save(KSP.IO.PluginConfiguration config, string sceneKey)
+		{
+			base.Save(config, sceneKey);
+
+			HUDWindow window;
+			for (int idx = 0; idx < this.Windows.Count; idx++)
+			{
+				window = this.Windows[idx];
+
 				string saveName = string.Format("{0}_{1}", this.GetType().Name, window.WindowName);
 				config.SetValue(saveName, window.WindowPos);
 			}

--- a/API/VOID_Module.cs
+++ b/API/VOID_Module.cs
@@ -26,11 +26,13 @@
 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// TODO: Remove ToadicusTools. prefixes after refactor is done.
+
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
-using ToadicusTools;
+using ToadicusTools.Extensions;
+using ToadicusTools.GUIUtils;
 using UnityEngine;
 
 namespace VOID
@@ -41,136 +43,95 @@
 		 * Fields
 		 * */
 		[AVOID_SaveValue("Active")]
-		protected VOID_SaveValue<bool> _Active = false;
+		protected VOID_SaveValue<bool> active = (VOID_SaveValue<bool>)false;
+
+		protected float lastUpdate = 0;
+
 		private GameScenes[] validScenes;
 		private Game.Modes[] validModes;
-
-		protected float lastUpdate = 0;
 
 		/*
 		 * Properties
 		 * */
-		protected virtual VOIDCore core
-		{
-			get
-			{
-				return VOID_Data.Core;
-			}
-		}
-
-		protected virtual bool timeToUpdate
-		{
-			get
-			{
-				return (
-					(this.core.updateTimer - this.lastUpdate) > this.core.updatePeriod ||
-					this.lastUpdate > this.core.updateTimer
-				);
-			}
-		}
-
-		public virtual bool toggleActive
-		{
-			get
-			{
-				return this._Active && this.inValidGame && this.inValidScene;
+
+		public virtual bool Active
+		{
+			get
+			{
+				return this.active && this.InValidGame && this.InValidScene;
 			}
 			set
 			{
-				this._Active = value && this.inValidGame && this.inValidScene;
-			}
-		}
-
-		public virtual bool guiRunning
-		{
-			get
-			{
-				if (
-					RenderingManager.fetch == null ||
-					RenderingManager.fetch.postDrawQueue == null ||
-					RenderingManager.fetch.postDrawQueue.Length < 4
-				)
-				{
-					return false;
-				}
-				else
-				{
-					Delegate callback = RenderingManager.fetch.postDrawQueue[3];
-					if (callback == null)
+				this.active.value = value && this.InValidGame && this.InValidScene;
+			}
+		}
+
+		public virtual bool GUIRunning
+		{
+			get
+			{
+				using (var log = ToadicusTools.DebugTools.PooledDebugLogger.New(this))
+				{
+					log.AppendFormat("this.core: {0}\n", this.core != null ? this.core.ToString() : "null");
+					if (this.core != null)
 					{
-						return false;
+						log.AppendFormat("this.core.MethodInPostRenderQueue(this.DrawGUI): {0}\n",
+							this.core.MethodInPostRenderQueue(this.DrawGUI));
 					}
 
-					return callback.GetInvocationList().Contains((Callback)this.DrawGUI);
-				}
-			}
-		}
-
-		public virtual GameScenes[] ValidScenes
-		{
-			get
-			{
-				if (this.validScenes == null)
-				{
-					Tools.PostDebugMessage(this, "validScenes is null when checking inValidScene; fetching attribute.");
-					foreach (var attr in this.GetType().GetCustomAttributes(false))
+					log.AppendFormat("this.GUIRunning: {0}\n",
+						this.core != null && this.core.MethodInPostRenderQueue(this.DrawGUI));
+
+					log.Print(false);
+				}
+
+				return this.core != null && this.core.MethodInPostRenderQueue(this.DrawGUI);
+			}
+		}
+
+		public virtual bool InValidGame
+		{
+			get
+			{
+				return this.ValidModes.Contains(HighLogic.CurrentGame.Mode);
+			}
+		}
+
+		public virtual bool InValidScene
+		{
+			get
+			{
+				return this.ValidScenes.Contains(HighLogic.LoadedScene);
+			}
+		}
+
+		public virtual string Name
+		{
+			get;
+			protected set;
+		}
+
+		public virtual Game.Modes[] ValidModes
+		{
+			get
+			{
+				if (this.validModes == null)
+				{
+					ToadicusTools.Logging.PostDebugMessage(this, "validModes is null when checking inValidGame; fetching attribute.");
+
+					object[] attributes = this.GetType().GetCustomAttributes(false);
+					object attr;
+					for (int idx = 0; idx < attributes.Length; idx++)
 					{
-						if (attr is VOID_ScenesAttribute)
-						{
-							VOID_ScenesAttribute addonAttr = (VOID_ScenesAttribute)attr;
-
-							this.validScenes = addonAttr.ValidScenes;
-
-							Tools.PostDebugMessage("Found VOID_ScenesAttribute; validScenes set.");
-
-							break;
-						}
-					}
-
-					if (this.validScenes == null)
-					{
-						this.validScenes = new GameScenes[] { GameScenes.FLIGHT };
-						Tools.PostDebugMessage("No VOID_ScenesAttribute found; validScenes defaulted to flight.");
-					}
-				}
-
-				return this.validScenes;
-			}
-		}
-
-		public virtual bool inValidScene
-		{
-			get
-			{
-
-				Tools.PostDebugMessage(
-					this,
-					"Checking if scene is valid: LoadedScene={0}, ValidScenes={1}, inValidScene={2}",
-					Enum.GetName(typeof(GameScenes), HighLogic.LoadedScene),
-					string.Join(", ", this.ValidScenes.Select(s => Enum.GetName(typeof(GameScenes), s)).ToArray()),
-					this.ValidScenes.Contains(HighLogic.LoadedScene)
-				);
-
-				return this.ValidScenes.Contains(HighLogic.LoadedScene);
-			}
-		}
-
-		public virtual Game.Modes[] ValidModes
-		{
-			get
-			{
-				if (this.validModes == null)
-				{
-					Tools.PostDebugMessage(this, "validModes is null when checking inValidGame; fetching attribute.");
-					foreach (var attr in this.GetType().GetCustomAttributes(false))
-					{
+						attr = attributes[idx];
+
 						if (attr is VOID_GameModesAttribute)
 						{
 							VOID_GameModesAttribute addonAttr = (VOID_GameModesAttribute)attr;
 
 							this.validModes = addonAttr.ValidModes;
 
-							Tools.PostDebugMessage("Found VOID_GameModesAttribute; validScenes set.");
+							ToadicusTools.Logging.PostDebugMessage("Found VOID_GameModesAttribute; validScenes set.");
 
 							break;
 						}
@@ -187,7 +148,7 @@
 							Game.Modes.SCIENCE_SANDBOX
 						};
 
-						Tools.PostDebugMessage("No VOID_GameModesAttribute found; validScenes defaulted to flight.");
+						ToadicusTools.Logging.PostDebugMessage("No VOID_GameModesAttribute found; validScenes defaulted to flight.");
 					}
 				}
 
@@ -195,68 +156,99 @@
 			}
 		}
 
-		public virtual bool inValidGame
-		{
-			get
-			{
-
-				Tools.PostDebugMessage(
-					this,
-					"Checking if mode is valid: CurrentGame.Mode={0}, ValidModes={1}, inValidGame={2}",
-					Enum.GetName(typeof(Game.Modes), HighLogic.CurrentGame.Mode),
-					string.Join(", ", this.ValidModes.Select(m => Enum.GetName(typeof(Game.Modes), m)).ToArray()),
-					this.ValidModes.Contains(HighLogic.CurrentGame.Mode)
+		public virtual GameScenes[] ValidScenes
+		{
+			get
+			{
+				if (this.validScenes == null)
+				{
+					ToadicusTools.Logging.PostDebugMessage(this, "validScenes is null when checking inValidScene; fetching attribute.");
+					object[] attributes = this.GetType().GetCustomAttributes(false);
+					object attr;
+					for (int idx = 0; idx < attributes.Length; idx++)
+					{
+						attr = attributes[idx];
+
+						if (attr is VOID_ScenesAttribute)
+						{
+							VOID_ScenesAttribute addonAttr = (VOID_ScenesAttribute)attr;
+
+							this.validScenes = addonAttr.ValidScenes;
+
+							ToadicusTools.Logging.PostDebugMessage("Found VOID_ScenesAttribute; validScenes set.");
+
+							break;
+						}
+					}
+
+					if (this.validScenes == null)
+					{
+						this.validScenes = new GameScenes[] { GameScenes.FLIGHT };
+						ToadicusTools.Logging.PostDebugMessage("No VOID_ScenesAttribute found; validScenes defaulted to flight.");
+					}
+				}
+
+				return this.validScenes;
+			}
+		}
+
+		public virtual Vessel Vessel
+		{
+			get
+			{
+				return FlightGlobals.ActiveVessel;
+			}
+		}
+
+		protected virtual VOIDCore core
+		{
+			get
+			{
+				return VOID_Data.Core;
+			}
+		}
+
+		protected virtual bool timeToUpdate
+		{
+			get
+			{
+				return (
+					(this.core.UpdateTimer - this.lastUpdate) > this.core.UpdatePeriod ||
+					this.lastUpdate > this.core.UpdateTimer
 				);
-
-				return this.ValidModes.Contains(HighLogic.CurrentGame.Mode);
-			}
-		}
-
-		public virtual string Name
-		{
-			get;
-			protected set;
-		}
-
-		public virtual Vessel vessel
-		{
-			get
-			{
-				return FlightGlobals.ActiveVessel;
 			}
 		}
 
 		/*
 		 * Methods
 		 * */
-		public void StartGUI()
-		{
-			if (!this.toggleActive || this.guiRunning)
+		public virtual void StartGUI()
+		{
+			if (!this.Active || this.GUIRunning)
 			{
 				return;
 			}
 
-			Tools.PostDebugMessage (string.Format("Adding {0} to the draw queue.", this.GetType().Name));
-			RenderingManager.AddToPostDrawQueue (3, this.DrawGUI);
-		}
-
-		public void StopGUI()
-		{
-			if (!this.guiRunning)
+			ToadicusTools.Logging.PostDebugMessage (string.Format("Adding {0} to the draw queue.", this.GetType().Name));
+			this.core.onPostRender += this.DrawGUI;
+		}
+
+		public virtual void StopGUI()
+		{
+			if (!this.GUIRunning)
 			{
 				return;
 			}
-			Tools.PostDebugMessage (string.Format("Removing {0} from the draw queue.", this.GetType().Name));
-			RenderingManager.RemoveFromPostDrawQueue (3, this.DrawGUI);
-		}
-
-		public abstract void DrawGUI();
+			ToadicusTools.Logging.PostDebugMessage (string.Format("Removing {0} from the draw queue.", this.GetType().Name));
+			this.core.onPostRender -= this.DrawGUI;
+		}
+
+		public abstract void DrawGUI(object sender);
 
 		public virtual void DrawConfigurables() {}
 
-		public virtual void LoadConfig()
-		{
-			var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Module> ();
+		public virtual void LoadConfig(KSP.IO.PluginConfiguration config)
+		{
 			config.load ();
 
 			if (this is VOIDCore)
@@ -269,30 +261,40 @@
 				}
 			}
 
-			foreach (var field in this.GetType().GetMembers(
-				BindingFlags.NonPublic |
-				BindingFlags.Public |
-				BindingFlags.Instance |
-				BindingFlags.FlattenHierarchy
-			))
-			{
-				if (!(field is FieldInfo || field is PropertyInfo))
+			MemberInfo[] members = this.GetType().GetMembers(
+				                         BindingFlags.NonPublic |
+				                         BindingFlags.Public |
+				                         BindingFlags.Instance |
+				                         BindingFlags.FlattenHierarchy
+			                         );
+			MemberInfo member;
+
+			for (int fIdx = 0; fIdx < members.Length; fIdx++)
+			{
+				member = members[fIdx];
+
+				if (!(member is FieldInfo || member is PropertyInfo))
 				{
 					continue;
 				}
 
-				if (field is PropertyInfo && (field as PropertyInfo).GetIndexParameters().Length > 0)
+				if (member is PropertyInfo && (member as PropertyInfo).GetIndexParameters().Length > 0)
 				{
 					continue;
 				}
 
-				object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false);
-
-				if (attrs.Length == 0) {
+				object[] attrs = member.GetCustomAttributes(typeof(AVOID_SaveValue), false);
+
+				AVOID_SaveValue attr;
+
+				if (attrs.Length > 0)
+				{
+					attr = (AVOID_SaveValue)attrs[0];
+				}
+				else
+				{
 					continue;
 				}
-
-				AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue;
 
 				string fieldName = string.Empty;
 
@@ -324,17 +326,17 @@
 					);
 				}
 
-				Tools.PostDebugMessage(string.Format("{0}: Loading field {1}.", this.GetType().Name, fieldName));
+				ToadicusTools.Logging.PostDebugMessage(string.Format("{0}: Loading field {1}.", this.GetType().Name, fieldName));
 
 				object fieldValue;
 
-				if (field is FieldInfo)
-				{
-					fieldValue = (field as FieldInfo).GetValue(this);
-				}
-				else
-				{
-					fieldValue = (field as PropertyInfo).GetValue(this, null);
+				if (member is FieldInfo)
+				{
+					fieldValue = (member as FieldInfo).GetValue(this);
+				}
+				else
+				{
+					fieldValue = (member as PropertyInfo).GetValue(this, null);
 				}
 
 				bool convertBack = false;
@@ -354,35 +356,61 @@
 					fieldValue = convertValue;
 				}
 
-				if (field is FieldInfo)
-				{
-					(field as FieldInfo).SetValue(this, fieldValue);
-				}
-				else
-				{
-					(field as PropertyInfo).SetValue(this, fieldValue, null);
-				}
-
-				Tools.PostDebugMessage(string.Format("{0}: Loaded field {1}.", this.GetType().Name, fieldName));
-			}
-		}
-
-		public virtual void _SaveToConfig(KSP.IO.PluginConfiguration config)
-		{
-			foreach (var field in this.GetType().GetMembers(
-				BindingFlags.Instance |
+				if (member is FieldInfo)
+				{
+					(member as FieldInfo).SetValue(this, fieldValue);
+				}
+				else
+				{
+					(member as PropertyInfo).SetValue(this, fieldValue, null);
+				}
+
+				ToadicusTools.Logging.PostDebugMessage(string.Format("{0}: Loaded field {1}.", this.GetType().Name, fieldName));
+			}
+		}
+
+		public virtual void Save(KSP.IO.PluginConfiguration config, string sceneKey)
+		{
+			if (config == null)
+			{
+				ToadicusTools.Logging.PostErrorMessage(
+					"{0}: config argument was null, bailing out.",
+					this.GetType().Name
+				);
+			}
+
+			if (sceneKey == null)
+			{
+				ToadicusTools.Logging.PostErrorMessage(
+					"{0}: sceneKey argument was null, bailing out.",
+					this.GetType().Name
+				);
+			}
+
+			MemberInfo[] members = this.GetType().GetMembers(
 				BindingFlags.NonPublic |
 				BindingFlags.Public |
+				BindingFlags.Instance |
 				BindingFlags.FlattenHierarchy
-				))
-			{
-				object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false);
-
-				if (attrs.Length == 0) {
+			);
+			MemberInfo member;
+
+			for (int fIdx = 0; fIdx < members.Length; fIdx++)
+			{
+				member = members[fIdx];
+
+				object[] attrs = member.GetCustomAttributes(typeof(AVOID_SaveValue), false);
+
+				AVOID_SaveValue attr;
+
+				if (attrs.Length > 0)
+				{
+					attr = (AVOID_SaveValue)attrs[0];
+				}
+				else
+				{
 					continue;
 				}
-
-				AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue;
 
 				string fieldName;
 
@@ -395,20 +423,20 @@
 					fieldName = string.Format(
 						"{0}_{1}_{2}",
 						this.GetType().Name,
-						Enum.GetName(typeof(GameScenes), HighLogic.LoadedScene),
+						sceneKey,
 						attr.Name
 					);
 				}
 
 				object fieldValue;
 
-				if (field is FieldInfo)
-				{
-					fieldValue = (field as FieldInfo).GetValue(this);
-				}
-				else
-				{
-					fieldValue = (field as PropertyInfo).GetValue(this, null);
+				if (member is FieldInfo)
+				{
+					fieldValue = (member as FieldInfo).GetValue(this);
+				}
+				else
+				{
+					fieldValue = (member as PropertyInfo).GetValue(this, null);
 				}
 
 				if (fieldValue is IVOID_SaveValue)
@@ -418,7 +446,7 @@
 
 				config.SetValue(fieldName, fieldValue);
 
-				Tools.PostDebugMessage(string.Format("{0}: Saved field {1}.", this.GetType().Name, fieldName));
+				ToadicusTools.Logging.PostDebugMessage(string.Format("{0}: Saved field {1}.", this.GetType().Name, fieldName));
 			}
 		}
 	}
@@ -430,6 +458,8 @@
 		protected float defWidth;
 		protected float defHeight;
 
+		protected bool decorateWindow;
+
 		protected string inputLockName;
 
 		public VOID_WindowModule() : base()
@@ -437,87 +467,130 @@
 			this.defWidth = 250f;
 			this.defHeight = 50f;
 
+			this.decorateWindow = true;
+
 			this.inputLockName = string.Concat(this.Name, "_edlock");
 
 			this.WindowPos = new Rect(Screen.width / 2, Screen.height / 2, this.defWidth, this.defHeight);
 		}
 
-		public abstract void ModuleWindow(int _);
-
-		public override void DrawGUI()
-		{
+		public virtual void ModuleWindow(int id)
+		{
+			GUIStyle buttonStyle = this.core.Skin.button;
+			RectOffset padding = buttonStyle.padding;
+			RectOffset border = buttonStyle.border;
+
+			Rect closeRect = new Rect(
+				0f,
+				0f,
+				border.left + border.right,
+				border.top + border.bottom
+			);
+
+			closeRect.width = Mathf.Max(closeRect.width, 16f);
+			closeRect.height = Mathf.Max(closeRect.height, 16f);
+
+			closeRect.x = this.WindowPos.width - closeRect.width - 2f;
+			closeRect.y = 2f;
+
+			GUI.Button(closeRect, GUIContent.none, buttonStyle);
+
+			if (Event.current.type == EventType.repaint && Input.GetMouseButtonUp(0))
+			{
+				if (closeRect.Contains(Event.current.mousePosition))
+				{
+					this.Active = false;
+					this.removeUILock();
+				}
+			}
+
+			GUI.DragWindow();
+		}
+
+		public override void DrawGUI(object sender)
+		{
+			if (this.core == null)
+			{
+				return;
+			}
+
 			GUI.skin = this.core.Skin;
 
 			Rect _Pos = this.WindowPos;
 
 			_Pos = GUILayout.Window(
-				this.core.windowID,
+				this.core.WindowID,
 				_Pos,
 				VOID_Tools.GetWindowHandler(this.ModuleWindow),
 				this.Name,
 				GUILayout.Width(this.defWidth),
-				GUILayout.Height(this.defHeight),
-				GUILayout.ExpandWidth(true),
-				GUILayout.ExpandHeight(true)
+				GUILayout.Height(this.defHeight)
 			);
 
 			bool cursorInWindow = _Pos.Contains(Mouse.screenPos);
 
+			if (cursorInWindow)
+			{
+				this.setUILock();
+			}
+			else
+			{
+				this.removeUILock();
+			}
+
+			if (HighLogic.LoadedSceneIsEditor)
+			{
+				_Pos = WindowTools.ClampRectToEditorPad(_Pos);
+			}
+			else
+			{
+				_Pos = WindowTools.ClampRectToScreen(_Pos);
+			}
+
+			if (_Pos != this.WindowPos)
+			{
+				this.WindowPos = _Pos;
+				this.core.configDirty = true;
+			}
+		}
+
+		protected void setUILock()
+		{
 			switch (HighLogic.LoadedScene)
 			{
 				case GameScenes.EDITOR:
-					if (cursorInWindow)
-					{
-						InputLockManager.SetControlLock(
-							ControlTypes.EDITOR_ICON_HOVER | ControlTypes.EDITOR_ICON_PICK |
-							ControlTypes.EDITOR_PAD_PICK_COPY | ControlTypes.EDITOR_PAD_PICK_COPY,
-							this.inputLockName
-						);
-						EditorLogic.fetch.Lock(false, false, false, this.inputLockName);
-					}
-					else
-					{
-						EditorLogic.fetch.Unlock(this.inputLockName);
-					}
+					InputLockManager.SetControlLock(
+						ControlTypes.EDITOR_ICON_HOVER | ControlTypes.EDITOR_ICON_PICK |
+						ControlTypes.EDITOR_PAD_PICK_COPY | ControlTypes.EDITOR_PAD_PICK_COPY,
+						this.inputLockName
+					);
+					EditorLogic.fetch.Lock(false, false, false, this.inputLockName);
 					break;
 				case GameScenes.FLIGHT:
-					if (cursorInWindow)
-					{
-						InputLockManager.SetControlLock(ControlTypes.CAMERACONTROLS, this.inputLockName);
-					}
-					else if (InputLockManager.GetControlLock(this.inputLockName) != ControlTypes.None)
-					{
-						InputLockManager.RemoveControlLock(this.inputLockName);
-					}
+					InputLockManager.SetControlLock(ControlTypes.CAMERACONTROLS, this.inputLockName);
 					break;
 				case GameScenes.SPACECENTER:
-					if (cursorInWindow)
-					{
-						InputLockManager.SetControlLock(
-							ControlTypes.KSC_FACILITIES | ControlTypes.CAMERACONTROLS,
-							this.inputLockName
-						);
-					}
-					else if (InputLockManager.GetControlLock(this.inputLockName) != ControlTypes.None)
-					{
-						InputLockManager.RemoveControlLock(this.inputLockName);
-					}
+					InputLockManager.SetControlLock(
+						ControlTypes.KSC_FACILITIES | ControlTypes.CAMERACONTROLS,
+						this.inputLockName
+					);
 					break;
 			}
-
-			if (HighLogic.LoadedSceneIsEditor)
-			{
-				_Pos = Tools.ClampRectToEditorPad(_Pos);
-			}
-			else
-			{
-				_Pos = Tools.ClampRectToScreen(_Pos);
-			}
-
-			if (_Pos != this.WindowPos)
-			{
-				this.WindowPos = _Pos;
-				this.core.configDirty = true;
+		}
+
+		protected void removeUILock()
+		{
+			switch (HighLogic.LoadedScene)
+			{
+				case GameScenes.EDITOR:
+					EditorLogic.fetch.Unlock(this.inputLockName);
+					break;
+				case GameScenes.FLIGHT:
+					InputLockManager.RemoveControlLock(this.inputLockName);
+					break;
+				case GameScenes.SPACECENTER:
+					InputLockManager.RemoveControlLock(this.inputLockName);
+					break;
 			}
 		}
 	}

--- /dev/null
+++ b/API/VOID_SingletonCore.cs
@@ -1,1 +1,71 @@
+// VOID
+//
+// VOID_SingletonModule.cs
+//
+// Copyright © 2015, toadicus
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+//    this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used
+//    to endorse or promote products derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+using System;
+using UnityEngine;
+
+namespace VOID
+{
+	public abstract class VOID_SingletonCore<T> : VOIDCore, IVOID_Module, IDisposable
+		where T : VOID_Module, new()
+	{
+		#region Singleton Members
+		/*
+		 * Static Members
+		 * */
+		protected static bool _initialized = false;
+
+		public static bool Initialized
+		{
+			get
+			{
+				return _initialized;
+			}
+		}
+
+		protected static T _instance;
+
+		public static T Instance
+		{
+			get
+			{
+				if (_instance == null)
+				{
+					_instance = new T();
+					_initialized = true;
+				}
+				return _instance;
+			}
+		}
+
+		public abstract void Dispose();
+		#endregion
+	}
+}
+
+

--- a/API/VOID_SingletonModule.cs
+++ /dev/null
@@ -1,67 +1,1 @@
-// VOID
-//
-// VOID_SingletonModule.cs
-//
-// Copyright © 2015, toadicus
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice,
-//    this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice,
-//    this list of conditions and the following disclaimer in the documentation and/or other
-//    materials provided with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its contributors may be used
-//    to endorse or promote products derived from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-using System;
 
-namespace VOID
-{
-	public abstract class VOID_SingletonModule<T> : VOIDCore, IVOID_Module
-		where T : VOID_Module, new()
-	{
-		#region Singleton Members
-		/*
-		 * Static Members
-		 * */
-		protected static bool _initialized = false;
-
-		public static bool Initialized
-		{
-			get
-			{
-				return _initialized;
-			}
-		}
-
-		protected static T _instance;
-
-		public static T Instance
-		{
-			get
-			{
-				if (_instance == null)
-				{
-					_instance = new T();
-					_initialized = true;
-				}
-				return _instance;
-			}
-		}
-		#endregion
-	}
-}
-
-

--- /dev/null
+++ b/API/VOID_SingletonWindow.cs
@@ -1,1 +1,73 @@
+// VOID
+//
+// VOID_SingletonModule.cs
+//
+// Copyright © 2015, toadicus
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+//    this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used
+//    to endorse or promote products derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+using System;
 
+namespace VOID
+{
+	public abstract class VOID_SingletonWindow<T> : VOID_WindowModule, IVOID_Module, IDisposable
+		where T : VOID_WindowModule, new()
+	{
+		#region Singleton Members
+		/*
+		 * Static Members
+		 * */
+		protected static bool _initialized = false;
+
+		public static bool Initialized
+		{
+			get
+			{
+				return _initialized;
+			}
+		}
+
+		protected static T _instance;
+
+		public static T Instance
+		{
+			get
+			{
+				if (_instance == null)
+				{
+					_instance = new T();
+					_initialized = true;
+				}
+				return _instance;
+			}
+		}
+
+		public virtual void Dispose()
+		{
+			_instance = null;
+			_initialized = false;
+		}
+		#endregion
+	}
+}
+
+

--- a/Properties/AssemblyInfo.cs
+++ b/Properties/AssemblyInfo.cs
@@ -39,10 +39,9 @@
 // The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
 // The form "{Major}.{Minor}.*" will automatically update the build and revision,
 // and "{Major}.{Minor}.{Build}.*" will update just the revision.
-[assembly: AssemblyVersion("0.16.4.*")]
+[assembly: AssemblyVersion("0.19.0.*")]
 // The following attributes are used to specify the signing key for the assembly,
 // if desired. See the Mono documentation for more information about signing.
 //[assembly: AssemblyDelaySign(false)]
 //[assembly: AssemblyKeyFile("")]
 
-

--- a/Tools/VOID_DataValue.cs
+++ b/Tools/VOID_DataValue.cs
@@ -26,8 +26,11 @@
 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// TODO: Remove ToadicusTools. prefixes after refactor is done.
+
 using System;
-using ToadicusTools;
+using ToadicusTools.MuMechTools;
+using ToadicusTools.Text;
 using UnityEngine;
 
 namespace VOID
@@ -71,8 +74,8 @@
 			get
 			{
 				if (
-					(VOID_Data.Core.updateTimer - this.lastUpdate > VOID_Data.Core.updatePeriod) ||
-					(this.lastUpdate > VOID_Data.Core.updateTimer)
+					(VOID_Data.Core.UpdateTimer - this.lastUpdate > VOID_Data.Core.UpdatePeriod) ||
+					(this.lastUpdate > VOID_Data.Core.UpdateTimer)
 				)
 				{
 					this.Refresh();
@@ -97,7 +100,7 @@
 		public void Refresh()
 		{
 			this.cache = this.ValueFunc.Invoke ();
-			this.lastUpdate = VOID_Data.Core.updateTimer;
+			this.lastUpdate = VOID_Data.Core.UpdateTimer;
 		}
 
 		public T GetFreshValue()
@@ -106,8 +109,26 @@
 			return (T)this.cache;
 		}
 
-		public virtual string ValueUnitString() {
-			return this.Value.ToString() + this.Units;
+		public virtual string ValueUnitString()
+		{
+			if (this.Value == null || this.Units == null)
+			{
+				using (PooledStringBuilder sb = PooledStringBuilder.Get())
+				{
+					if (this.Value == null)
+					{
+						sb.AppendFormat("{0}: Value is null during ValueUnitString\n", this.Label);
+					}
+					if (this.Units == null)
+					{
+						sb.AppendFormat("{0}: Units is null during ValueUnitString\n", this.Label);
+					}
+
+					ToadicusTools.Logging.PostErrorMessage(sb.ToString());
+				}
+			}
+
+			return string.Format("{0}{1}", this.Value == null ? "NULL" : this.Value.ToString(), this.Units);
 		}
 
 		public virtual void DoGUIHorizontal()
@@ -148,7 +169,7 @@
 	public abstract class VOID_NumValue<T> : VOID_DataValue<T>, IFormattable
 		where T : IFormattable, IConvertible, IComparable
 	{
-		public static IFormatProvider formatProvider = Tools.SIFormatter;
+		public static IFormatProvider formatProvider = SIFormatProvider.SIFormatter;
 
 		public static implicit operator Double(VOID_NumValue<T> v)
 		{
@@ -218,7 +239,7 @@
 		{
 			return string.Format (
 				"{0}{1}",
-				Tools.MuMech_ToSI (this, digits, MinMagnitude, MaxMagnitude),
+				MuMechTools.MuMech_ToSI (this, digits, MinMagnitude, MaxMagnitude),
 				this.Units
 			);
 		}
@@ -229,12 +250,12 @@
 		}
 		
 		public virtual string ValueUnitString(int digits) {
-			return Tools.MuMech_ToSI(this, digits) + this.Units;
+			return string.Format("{0}{1}", SIFormatProvider.ToSI(this, digits), Units);
 		}
 
 		public virtual string ValueUnitString(int digits, int MinMagnitude, int MaxMagnitude)
 		{
-			return Tools.MuMech_ToSI(this, digits, MinMagnitude, MaxMagnitude) + this.Units;
+			return MuMechTools.MuMech_ToSI(this, digits, MinMagnitude, MaxMagnitude) + this.Units;
 		}
 
 		public virtual void DoGUIHorizontal(string format)
@@ -264,26 +285,17 @@
 
 		public virtual int DoGUIHorizontalPrec(int digits)
 		{
-			double magnitude;
-			double magLimit;
-
-			magnitude = Math.Log10(Math.Abs((double)this));
-
-			magLimit = Math.Max(Math.Abs(magnitude), 3d) + 3d;
-			magLimit = Math.Round(Math.Ceiling(magLimit / 3f)) * 3d;
+			if (digits < 0 || digits > 8)
+			{
+				digits = 5;
+			}
 
 			GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 			GUILayout.Label(this.Label + "ⁱ:", GUILayout.ExpandWidth(true));
 			GUILayout.FlexibleSpace();
 
-			if (magnitude >= 0)
-			{
-				GUILayout.Label(this.ValueUnitString(3, int.MinValue, (int)magnitude - digits), GUILayout.ExpandWidth(false));
-			}
-			else
-			{
-				GUILayout.Label(this.ValueUnitString(3, (int)magnitude + digits, int.MaxValue), GUILayout.ExpandWidth(false));
-			}
+			GUILayout.Label(this.ValueUnitString(digits), GUILayout.ExpandWidth(false));
+
 			GUILayout.EndHorizontal();
 
 			if (Event.current.type == EventType.mouseUp)
@@ -291,33 +303,28 @@
 				Rect lastRect = GUILayoutUtility.GetLastRect();
 				if (lastRect.Contains(Event.current.mousePosition))
 				{
-					Tools.PostDebugMessage(string.Format("{0}: Changing digits from {1} within magLimit {2}.",
+					ToadicusTools.Logging.PostDebugMessage(string.Format("{0}: Changing digits from {1}",
 						this.GetType().Name,
-						digits,
-						magLimit));
+						digits
+					));
 
 					if (Event.current.button == 0)
 					{
-						digits = (digits + 3) % (int)magLimit;
+						digits = (digits + 3) % 9;
 					}
 					else if (Event.current.button == 1)
 					{
-						digits = (digits - 3) % (int)magLimit;
+						digits = (digits - 3) % 9;
 					}
 
 					if (digits < 0)
 					{
-						digits += (int)magLimit;
-					}
-
-					Tools.PostDebugMessage(string.Format("{0}: Changed digits to {1}." +
-						"\n\tNew minMagnitude: {2}, maxMagnitude: {3}" +
-						"\n\tMagnitude: {4}",
+						digits += 9;
+					}
+
+					ToadicusTools.Logging.PostDebugMessage(string.Format("{0}: Changed digits to {1}.",
 						this.GetType().Name,
-						digits,
-						magnitude >= 0 ? int.MinValue : (int)magnitude - 4 + digits,
-						magnitude >= 0 ? (int)magnitude - digits : int.MaxValue,
-						magnitude
+						digits
 					));
 				}
 			}
@@ -346,9 +353,9 @@
 		public VOID_StrValue(string Label, Func<string> ValueFunc) : base(Label, ValueFunc, "") {}
 	}
 
-	public class VOID_Vector3dValue : VOID_DataValue<Vector3d>
-	{
-		public VOID_Vector3dValue(string Label, Func<Vector3d> ValueFunc, string Units)
+	public class VOID_Vector3Value : VOID_DataValue<Vector3>
+	{
+		public VOID_Vector3Value(string Label, Func<Vector3> ValueFunc, string Units)
 			: base(Label, ValueFunc, Units)
 		{}
 

--- /dev/null
+++ b/Tools/VOID_Localization.cs
@@ -1,1 +1,36 @@
+// VOID
+//
+// VOID_Localization.cs
+//
+// Copyright © 2014, toadicus
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+//    this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used
+//    to endorse or promote products derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+public static class VOID_Localization
+{
+	public static string void_primary = "Primary";
+	public static string void_altitude_asl = "Altitude (ASL)";
+	public static string void_velocity = "Velocity";
+	public static string void_apoapsis = "Apoapsis";
+	public static string void_periapsis = "Periapsis";
+}

--- a/Tools/VOID_SaveValue.cs
+++ b/Tools/VOID_SaveValue.cs
@@ -26,10 +26,11 @@
 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// TODO: Remove ToadicusTools. prefixes after refactor is done.
+
 using KSP;
 using System;
 using System.Collections.Generic;
-using ToadicusTools;
 using UnityEngine;
 
 namespace VOID
@@ -65,12 +66,11 @@
 			{
 				if (this.Core != null && !System.Object.Equals(this._value, value))
 				{
-					Tools.PostDebugMessage (string.Format (
-						"VOID: Dirtying config for type {0} in method {1}." +
-						"\n\t Old Value: {2}, New Value: {3}" +
-						"\n\t Object.Equals(New, Old): {4}",
+					ToadicusTools.Logging.PostDebugMessage (string.Format (
+						"VOID: Dirtying config for type {0}." +
+						"\n\t Old Value: {1}, New Value: {2}" +
+						"\n\t Object.Equals(New, Old): {3}\n" +
 						this._type,
-						new System.Diagnostics.StackTrace().GetFrame(1).GetMethod(),
 						this._value,
 						value,
 						System.Object.Equals(this._value, value)
@@ -107,7 +107,7 @@
 			return (T)v.value;
 		}
 
-		public static implicit operator VOID_SaveValue<T>(T v)
+		public static explicit operator VOID_SaveValue<T>(T v)
 		{
 			VOID_SaveValue<T> r = new VOID_SaveValue<T>();
 			r.type = v.GetType();

--- /dev/null
+++ b/Tools/VOID_StageExtensions.cs
@@ -1,1 +1,38 @@
+// VOID © 2015 toadicus
+//
+// This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a
+// copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/
 
+using KerbalEngineer.VesselSimulator;
+using KSP;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace VOID
+{
+	public static class VOID_StageExtensions
+	{
+		public static double NominalThrust(this Stage stage)
+		{
+			if (stage.actualThrust == 0d)
+			{
+				return stage.thrust;
+			}
+			else
+			{
+				return stage.actualThrust;
+			}
+		}
+
+		public static double MassFlow(this Stage stage)
+		{
+			double stageIsp = VOID_Data.Core.LastStage.isp;
+			double stageThrust = stage.NominalThrust();
+
+			return stageThrust / (stageIsp * VOID_Data.KerbinGee);
+		}
+	}
+}
+
+

--- a/Tools/VOID_Tools.cs
+++ b/Tools/VOID_Tools.cs
@@ -316,6 +316,7 @@
 		}
 		#endregion
 
+		#region WINDOW_UTILS
 		private static Dictionary<int, GUI.WindowFunction> functionCache;
 		public static UnityEngine.GUI.WindowFunction GetWindowHandler(Action<int> func)
 		{
@@ -334,21 +335,16 @@
 					{
 						func(id);
 					}
-					#if DEBUG
+					#if !DEBUG
 					catch (ArgumentException)
-					#else
-					catch (ArgumentException)
-					#endif
 					{
 						Debug.LogWarning(
-							string.Format("[{0}]: ArgumentException caught during window call.  This is not a bug.",
+							string.Format("[{0}]: ArgumentException caught during window call." +
+								"  This may not be a bug when occuring during scene changes.",
 								func.Target.GetType().Name
 							));
-
-						/*#if DEBUG
-						Debug.LogException(ex);
-						#endif*/
 					}
+					#endif
 					catch (Exception ex)
 					{
 						Debug.LogError(
@@ -365,6 +361,21 @@
 			return functionCache[hashCode];
 		}
 
+		public static void UncacheWindow(Action<int> func)
+		{
+			if (functionCache != null)
+			{
+				int hashCode = func.GetHashCode();
+
+				if (functionCache.ContainsKey(hashCode))
+				{
+					functionCache.Remove(hashCode);
+				}
+			}
+		}
+		#endregion
+
+		#region TIME_UTILS
 		/// <summary>
 		/// Formats the interval given in seconds as a human-friendly
 		/// time period in [[[[years, ]days, ]hours, ]minutes, and ]seconds.
@@ -398,28 +409,55 @@
 			{
 				get
 				{
-					if (GameSettings.KERBIN_TIME)
+					VOID_TimeScale flags = VOID_Data.Core.TimeScale &
+						(VOID_TimeScale.KERBIN_TIME | VOID_TimeScale.SOLAR_DAY | VOID_TimeScale.ROUNDED_SCALE);
+
+					switch (flags)
 					{
-						return 21600d;
+						// Earth day, sidereal
+						case 0:
+							return 86164.1d;
+						// Earth day, solar (also rounded)
+						case VOID_TimeScale.ROUNDED_SCALE | VOID_TimeScale.SOLAR_DAY:
+						case VOID_TimeScale.ROUNDED_SCALE:
+						case VOID_TimeScale.SOLAR_DAY:
+							return 86400d;
+						// Kerbin day, solar
+						case VOID_TimeScale.KERBIN_TIME | VOID_TimeScale.SOLAR_DAY:
+							return 21650.813d;
+						// Kerbin day, sidereal (also rounded)
+						default:
+							return 21600d;
 					}
-					else
+				}
+			}
+
+			public static double SecondsPerYear
+			{
+				get
+				{
+					VOID_TimeScale flags = VOID_Data.Core.TimeScale &
+						(VOID_TimeScale.KERBIN_TIME | VOID_TimeScale.SOLAR_DAY | VOID_TimeScale.ROUNDED_SCALE);
+
+					switch (flags)
 					{
-						return 86164.1d;
-					}
-				}
-			}
-
-			public static double SecondsPerYear
-			{
-				get
-				{
-					if (GameSettings.KERBIN_TIME)
-					{
-						return 9203545d;
-					}
-					else
-					{
-						return 31558149d;
+						// Earth year, rounded
+						case VOID_TimeScale.SOLAR_DAY | VOID_TimeScale.ROUNDED_SCALE:
+						case VOID_TimeScale.ROUNDED_SCALE:
+							return 60 * 60 * 24 * 365;
+						// Kerbin year, rounded
+						case VOID_TimeScale.KERBIN_TIME | VOID_TimeScale.SOLAR_DAY | VOID_TimeScale.ROUNDED_SCALE:
+						case VOID_TimeScale.KERBIN_TIME | VOID_TimeScale.ROUNDED_SCALE:
+							return 60 * 60 * 6 * 426;
+						// Earth year, solar time
+						case VOID_TimeScale.SOLAR_DAY:
+							return 31556925.2507328;
+						// Earth year, sidereal time
+						case 0:
+							return 31558149.7635456d;
+						// Kerbin year, solar & sidereal time
+						default:
+							return 9203544.61750141d;
 					}
 				}
 			}
@@ -532,6 +570,7 @@
 
 			public UnpackedTime() : this(0, 0, 0, 0, 0d) {}
 		}
+		#endregion
 
 		public static string UppercaseFirst(string s)
 		{
@@ -665,8 +704,8 @@
 
 		public static double mrenigma03_calcphase(Vessel vessel, CelestialBody target)   //calculates phase angle between the current body and target body
 		{
-			Vector3d vecthis = new Vector3d();
-			Vector3d vectarget = new Vector3d();
+			Vector3 vecthis = new Vector3();
+			Vector3 vectarget = new Vector3();
 			vectarget = target.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime());
 
 			if ((vessel.mainBody.name == "Sun") || (vessel.mainBody.referenceBody.referenceBody.name == "Sun"))
@@ -678,15 +717,15 @@
 				vecthis = vessel.mainBody.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime());
 			}
 
-			vecthis = Vector3d.Project(new Vector3d(vecthis.x, 0, vecthis.z), vecthis);
-			vectarget = Vector3d.Project(new Vector3d(vectarget.x, 0, vectarget.z), vectarget);
-
-			Vector3d prograde = new Vector3d();
-			prograde = Quaternion.AngleAxis(90, Vector3d.forward) * vecthis;
-
-			double phase = Vector3d.Angle(vecthis, vectarget);
-
-			if (Vector3d.Angle(prograde, vectarget) > 90)
+			vecthis = Vector3.Project(new Vector3(vecthis.x, 0, vecthis.z), vecthis);
+			vectarget = Vector3.Project(new Vector3(vectarget.x, 0, vectarget.z), vectarget);
+
+			Vector3 prograde = new Vector3();
+			prograde = Quaternion.AngleAxis(90, Vector3.forward) * vecthis;
+
+			double phase = Vector3.Angle(vecthis, vectarget);
+
+			if (Vector3.Angle(prograde, vectarget) > 90)
 				phase = 360 - phase;
 
 			return (phase + 360) % 360;
@@ -978,75 +1017,75 @@
 	{
 		public int Compare(CelestialBody bodyA, CelestialBody bodyB)
 		{
-			Tools.PostDebugMessage(this, "got bodyA: {0} & bodyB: {1}", bodyA, bodyB);
+			Logging.PostDebugMessage(this, "got bodyA: {0} & bodyB: {1}", bodyA, bodyB);
 
 			if (bodyA == null && bodyB == null)
 			{
-				Tools.PostDebugMessage(this, "both bodies are null, returning 0");
+				Logging.PostDebugMessage(this, "both bodies are null, returning 0");
 				return 0;
 			}
 			if (bodyA == null)
 			{
-				Tools.PostDebugMessage(this, "bodyA is null, returning -1");
+				Logging.PostDebugMessage(this, "bodyA is null, returning -1");
 				return -1;
 			}
 			if (bodyB == null)
 			{
-				Tools.PostDebugMessage(this, "bodyB is null, returning 1");
+				Logging.PostDebugMessage(this, "bodyB is null, returning 1");
 				return 1;
 			}
 
-			Tools.PostDebugMessage(this, "bodies are not null, carrying on");
+			Logging.PostDebugMessage(this, "bodies are not null, carrying on");
 
 			if (object.ReferenceEquals(bodyA, bodyB))
 			{
-				Tools.PostDebugMessage(this, "bodies are equal, returning 0");
+				Logging.PostDebugMessage(this, "bodies are equal, returning 0");
 				return 0;
 			}
 
-			Tools.PostDebugMessage(this, "bodies are not equal, carrying on");
+			Logging.PostDebugMessage(this, "bodies are not equal, carrying on");
 
 			if (bodyA.orbitDriver == null)
 			{
-				Tools.PostDebugMessage(this, "bodyA.orbit is null (bodyA is the sun, returning 1");
+				Logging.PostDebugMessage(this, "bodyA.orbit is null (bodyA is the sun, returning 1");
 				return 1;
 			}
 			if (bodyB.orbitDriver == null)
 			{
-				Tools.PostDebugMessage(this, "bodyB.orbit is null (bodyB is the sun, returning -1");
+				Logging.PostDebugMessage(this, "bodyB.orbit is null (bodyB is the sun, returning -1");
 				return -1;
 			}
 
-			Tools.PostDebugMessage(this, "orbits are not null, carrying on");
+			Logging.PostDebugMessage(this, "orbits are not null, carrying on");
 
 			if (bodyA.orbit.referenceBody == bodyB.orbit.referenceBody)
 			{
-				Tools.PostDebugMessage(this, "bodies share a parent, comparing SMAs");
+				Logging.PostDebugMessage(this, "bodies share a parent, comparing SMAs");
 				return -bodyA.orbit.semiMajorAxis.CompareTo(bodyB.orbit.semiMajorAxis);
 			}
 
-			Tools.PostDebugMessage(this, "orbits do not share a parent, carrying on");
+			Logging.PostDebugMessage(this, "orbits do not share a parent, carrying on");
 
 			if (bodyA.hasAncestor(bodyB))
 			{
-				Tools.PostDebugMessage(this, "bodyA is a moon or sub-moon of bodyB, returning -1");
+				Logging.PostDebugMessage(this, "bodyA is a moon or sub-moon of bodyB, returning -1");
 				return -1;
 			}
 			if (bodyB.hasAncestor(bodyA))
 			{
-				Tools.PostDebugMessage(this, "bodyA is a moon or sub-moon of bodyB, returning 1");
+				Logging.PostDebugMessage(this, "bodyA is a moon or sub-moon of bodyB, returning 1");
 				return 1;
 			}
 
-			Tools.PostDebugMessage(this, "bodies do not have an obvious relationship, searching for one");
+			Logging.PostDebugMessage(this, "bodies do not have an obvious relationship, searching for one");
 
 			if (VOID_Tools.NearestRelatedParents(ref bodyA, ref bodyB))
 			{
-				Tools.PostDebugMessage(this, "good relation {0} and {1}, comparing", bodyA.bodyName, bodyB.bodyName);
+				Logging.PostDebugMessage(this, "good relation {0} and {1}, comparing", bodyA.bodyName, bodyB.bodyName);
 				return this.Compare(bodyA, bodyB);
 			}
 
-			Tools.PostDebugMessage(this, "bad relation {0} and {1}, giving up", bodyA.bodyName, bodyB.bodyName);
+			Logging.PostDebugMessage(this, "bad relation {0} and {1}, giving up", bodyA.bodyName, bodyB.bodyName);
 
 			return 0;
 		}

--- a/VOID.csproj
+++ b/VOID.csproj
@@ -83,7 +83,6 @@
     <Compile Include="VOID_VesselRegister.cs" />
     <Compile Include="VOID_DataLogger.cs" />
     <Compile Include="VOID_EditorHUD.cs" />
-    <Compile Include="VOID_Localization.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="VOID_HUDAdvanced.cs" />
     <Compile Include="VOID_TWR.cs" />
@@ -107,11 +106,16 @@
     <Compile Include="Tools\VOID_DataValue.cs" />
     <Compile Include="Tools\VOID_SaveValue.cs" />
     <Compile Include="API\VOID_HUDModule.cs" />
-    <Compile Include="API\VOID_SingletonModule.cs" />
     <Compile Include="API\Attributes\VOID_ScenesAttribute.cs" />
     <Compile Include="API\Attributes\AVOID_SaveValue.cs" />
     <Compile Include="API\VOIDMaster.cs" />
     <Compile Include="API\Attributes\VOID_GameModesAttribute.cs" />
+    <Compile Include="VOID_ConfigWindow.cs" />
+    <Compile Include="Tools\VOID_Localization.cs" />
+    <Compile Include="Tools\VOID_StageExtensions.cs" />
+    <Compile Include="API\VOID_SingletonCore.cs" />
+    <Compile Include="API\VOID_SingletonWindow.cs" />
+    <Compile Include="API\Enums.cs" />
   </ItemGroup>
   <ProjectExtensions>
     <MonoDevelop>
@@ -131,6 +135,15 @@
     </Reference>
     <Reference Include="UnityEngine">
       <HintPath>..\_KSPAssemblies\UnityEngine.dll</HintPath>
+    </Reference>
+    <Reference Include="KSPUtil">
+      <HintPath>..\_KSPAssemblies\KSPUtil.dll</HintPath>
+    </Reference>
+    <Reference Include="UnityEngine.UI">
+      <HintPath>..\_KSPAssemblies\UnityEngine.UI.dll</HintPath>
+    </Reference>
+    <Reference Include="Assembly-CSharp-firstpass">
+      <HintPath>..\_KSPAssemblies\Assembly-CSharp-firstpass.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>

--- a/VOIDCore_Editor.cs
+++ b/VOIDCore_Editor.cs
@@ -30,8 +30,6 @@
 using KSP;
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using ToadicusTools;
 using UnityEngine;
 
 namespace VOID
@@ -39,10 +37,14 @@
 	[VOID_Scenes(GameScenes.EDITOR)]
 	public class VOIDCore_Editor : VOIDCore_Generic<VOIDCore_Editor>
 	{
-		public VOIDCore_Editor() : base()
+		public override string SceneKey
 		{
-			this.Name = "VOID Core: Editor";
+			get
+			{
+				return "EDITOR";
+			}
 		}
+
 
 		public override void FixedUpdate() {}
 	}

--- a/VOIDCore_Flight.cs
+++ b/VOIDCore_Flight.cs
@@ -29,23 +29,27 @@
 using KSP;
 using System;
 using UnityEngine;
-using ToadicusTools;
+using ToadicusTools.GUIUtils;
 
 namespace VOID
 {
 	[VOID_Scenes(GameScenes.FLIGHT)]
 	public class VOIDCore_Flight : VOIDCore_Generic<VOIDCore_Flight>
 	{
-		public VOIDCore_Flight()
+		public override string SceneKey
 		{
-			base.Name = "VOID Core: Flight";
+			get
+			{
+				return "FLIGHT";
+			}
 		}
+
 
 		public override void DrawConfigurables()
 		{
 			if (HighLogic.LoadedSceneIsFlight)
 			{
-				this.consumeResource.value = GUITools.Toggle(this.consumeResource, "Consume Resources");
+				this.consumeResource.value = Layout.Toggle(this.consumeResource, "Consume Resources");
 			}
 
 			base.DrawConfigurables();

--- a/VOIDCore_Generic.cs
+++ b/VOIDCore_Generic.cs
@@ -26,18 +26,24 @@
 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+using KerbalEngineer.Editor;
+using KerbalEngineer.Helpers;
 using KerbalEngineer.VesselSimulator;
 using KSP;
+using KSP.UI.Screens;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Text;
 using ToadicusTools;
+using ToadicusTools.DebugTools;
+using ToadicusTools.Extensions;
+using ToadicusTools.GUIUtils;
+using ToadicusTools.Wrappers;
 using UnityEngine;
 
 namespace VOID
 {
-	public abstract class VOIDCore_Generic<T> : VOID_SingletonModule<T>, IVOID_Module, IDisposable
+	public abstract class VOIDCore_Generic<T> : VOID_SingletonCore<T>, IVOID_Module, IDisposable
 		where T : VOID_Module, new()
 	{
 		/*
@@ -47,21 +53,10 @@
 		protected string VoidVersion;
 
 		[AVOID_SaveValue("configValue")]
-		protected VOID_SaveValue<int> _configVersion = VOIDCore.CONFIG_VERSION;
-
-		protected List<IVOID_Module> _modules = new List<IVOID_Module>();
-		protected bool _modulesLoaded = false;
-
-		[AVOID_SaveValue("mainWindowPos")]
-		protected VOID_SaveValue<Rect> mainWindowPos = new Rect(475, 575, 10f, 10f);
-		[AVOID_SaveValue("mainGuiMinimized")]
-		protected VOID_SaveValue<bool> mainGuiMinimized = false;
-
-		[AVOID_SaveValue("configWindowPos")]
-		protected VOID_SaveValue<Rect> configWindowPos = new Rect(825, 625, 10f, 10f);
-		[AVOID_SaveValue("configWindowMinimized")]
-
-		protected VOID_SaveValue<bool> configWindowMinimized = true;
+		protected VOID_SaveValue<int> configVersion = (VOID_SaveValue<int>)VOIDCore.CONFIG_VERSION;
+
+		protected List<IVOID_Module> modules = new List<IVOID_Module>();
+		protected bool modulesLoaded = false;
 
 		protected Texture2D VOIDIconTexture;
 		protected string VOIDIconOnActivePath;
@@ -69,48 +64,54 @@
 		protected string VOIDIconOffActivePath;
 		protected string VOIDIconOffInactivePath;
 
+		[AVOID_SaveValue("useToolbarManager")]
+		protected VOID_SaveValue<bool> useToolbarManager;
+
 		protected GUIStyle iconStyle;
 
 		protected int windowBaseID = -96518722;
-		protected int _windowID = 0;
+		protected int windowID = 0;
 
 		protected bool GUIStylesLoaded = false;
 
-		protected CelestialBody _homeBody;
+		protected CelestialBody homeBody;
 
 		[AVOID_SaveValue("togglePower")]
-		public VOID_SaveValue<bool> togglePower = true;
+		public VOID_SaveValue<bool> togglePower = (VOID_SaveValue<bool>)true;
 
 		public override bool powerAvailable { get; protected set; }
 
 		[AVOID_SaveValue("consumeResource")]
-		protected VOID_SaveValue<bool> consumeResource = false;
+		protected VOID_SaveValue<bool> consumeResource = (VOID_SaveValue<bool>)false;
 
 		[AVOID_SaveValue("resourceName")]
-		protected VOID_SaveValue<string> resourceName = "ElectricCharge";
+		protected VOID_SaveValue<string> resourceName = (VOID_SaveValue<string>)"ElectricCharge";
 
 		[AVOID_SaveValue("resourceRate")]
-		protected VOID_SaveValue<float> resourceRate = 0.2f;
+		protected VOID_SaveValue<float> resourceRate = (VOID_SaveValue<float>)0.2f;
 
 		[AVOID_SaveValue("updatePeriod")]
-		protected VOID_SaveValue<double> _updatePeriod = 1001f / 15000f;
+		protected VOID_SaveValue<double> updatePeriod = (VOID_SaveValue<double>)(1001f / 15000f);
 		protected string stringFrequency;
 
 		[AVOID_SaveValue("vesselSimActive")]
 		protected VOID_SaveValue<bool> vesselSimActive;
 
-		// Vessel Type Housekeeping
-		protected List<VesselType> _allVesselTypes = new List<VesselType>();
+		[AVOID_SaveValue("timeScaleFlags")]
+		protected VOID_SaveValue<UInt32> timeScaleFlags;
+
+		// Load-up housekeeping
 		protected bool vesselTypesLoaded = false;
+		protected bool simManagerLoaded = false;
 
 		protected string defaultSkin = "KSP window 2";
 
 		[AVOID_SaveValue("defaultSkin")]
-		protected VOID_SaveValue<string> _skinName;
-		protected int _skinIdx;
+		protected VOID_SaveValue<string> skinName;
+		protected int skinIdx;
 
 		protected Dictionary<string, GUISkin> validSkins;
-		protected string[] skinNames;
+		protected List<string> skinNames;
 		protected string[] forbiddenSkins =
 			{
 				"PlaqueDialogSkin",
@@ -119,6 +120,7 @@
 				"ExperimentsDialogSkin",
 				"ExpRecoveryDialogSkin",
 				"KSP window 1",
+				"KSP window 3",
 				"KSP window 5",
 				"KSP window 6",
 				"PartTooltipSkin",
@@ -128,32 +130,71 @@
 
 		public override bool configDirty { get; set; }
 
-		internal IButton ToolbarButton;
-
-		internal ApplicationLauncherButton AppLauncherButton;
+		protected IButton ToolbarButton;
+		protected ApplicationLauncherButton AppLauncherButton;
+		protected IconState iconState;
 
 		/*
 		 * Properties
 		 * */
-		public override int configVersion
+		public override bool Active
 		{
 			get
 			{
-				return this._configVersion;
-			}
-		}
-
-		public bool factoryReset
+				return base.Active;
+			}
+			set
+			{
+				if (value != base.Active)
+				{
+					this.SetIconTexture(this.powerState | this.activeState);
+				}
+
+				base.Active = value;
+			}
+		}
+
+		public override VesselType[] AllVesselTypes
 		{
 			get;
 			protected set;
 		}
 
-		public override List<IVOID_Module> Modules
+		public override int ConfigVersion
 		{
 			get
 			{
-				return this._modules;
+				return this.configVersion;
+			}
+		}
+
+		public bool FactoryReset
+		{
+			get;
+			protected set;
+		}
+
+		public override CelestialBody HomeBody
+		{
+			get
+			{
+				if (this.homeBody == null)
+				{
+					if (Planetarium.fetch != null)
+					{
+						this.homeBody = Planetarium.fetch.Home;
+					}
+				}
+
+				return this.homeBody;
+			}
+		}
+
+		public override IList<IVOID_Module> Modules
+		{
+			get
+			{
+				return this.modules.AsReadOnly();
 			}
 		}
 
@@ -165,7 +206,7 @@
 				{
 					try
 					{
-						return this.validSkins[this._skinName];
+						return this.validSkins[this.skinName];
 					}
 					catch
 					{
@@ -176,68 +217,35 @@
 			}
 		}
 
-		public override int windowID
-		{
-			get
-			{
-				if (this._windowID == 0)
-				{
-					this._windowID = this.windowBaseID;
-				}
-				return this._windowID++;
-			}
-		}
-
-		public override List<CelestialBody> allBodies
-		{
-			get
-			{
-				return FlightGlobals.Bodies;
-			}
-		}
-
-		public override List<CelestialBody> sortedBodyList
+		public override List<CelestialBody> SortedBodyList
 		{
 			get;
 			protected set;
 		}
 
-		public override CelestialBody HomeBody
+		public override double UpdatePeriod
 		{
 			get
 			{
-				if (this._homeBody == null)
-				{
-					if (Planetarium.fetch != null)
-					{
-						this._homeBody = Planetarium.fetch.Home;
-					}
-				}
-
-				return this._homeBody;
-			}
-		}
-
-		public override List<VesselType> allVesselTypes
-		{
-			get
-			{
-				return this._allVesselTypes;
-			}
-		}
-
-		public override float updateTimer
+				return this.updatePeriod;
+			}
+		}
+
+		public override float UpdateTimer
 		{
 			get;
 			protected set;
 		}
 
-
-		public override double updatePeriod
+		public override int WindowID
 		{
 			get
 			{
-				return this._updatePeriod;
+				if (this.windowID == 0)
+				{
+					this.windowID = this.windowBaseID;
+				}
+				return this.windowID++;
 			}
 		}
 
@@ -253,6 +261,34 @@
 			protected set;
 		}
 
+		public override VOID_TimeScale TimeScale
+		{
+			get
+			{
+				return (VOID_TimeScale)this.timeScaleFlags.value;
+			}
+			protected set
+			{
+				this.timeScaleFlags.value = (UInt32)value;
+			}
+		}
+
+		protected IconState activeState
+		{
+			get
+			{
+				if (this.Active)
+				{
+					return IconState.Inactive;
+				}
+				else
+				{
+					return IconState.Active;
+				}
+
+			}
+		}
+
 		protected IconState powerState
 		{
 			get
@@ -266,55 +302,6 @@
 					return IconState.PowerOff;
 				}
 
-			}
-		}
-
-		protected IconState activeState
-		{
-			get
-			{
-				if (this.mainGuiMinimized)
-				{
-					return IconState.Inactive;
-				}
-				else
-				{
-					return IconState.Active;
-				}
-
-			}
-		}
-
-		protected bool UseToolbarManager
-		{
-			get
-			{
-				return useToolbarManager & ToolbarManager.ToolbarAvailable;
-			}
-			set
-			{
-				if (useToolbarManager == value)
-				{
-					return;
-				}
-
-				if (value == false && this.ToolbarButton != null)
-				{
-					this.ToolbarButton.Destroy();
-					this.ToolbarButton = null;
-				}
-				if (value == true)
-				{
-					if (this.AppLauncherButton != null)
-					{
-						ApplicationLauncher.Instance.RemoveModApplication(this.AppLauncherButton);
-						this.AppLauncherButton = null;
-					}
-
-					this.InitializeToolbarButton();
-				}
-
-				useToolbarManager = value;
 			}
 		}
 
@@ -329,19 +316,28 @@
 		/*
 		 * Events
 		 * */
+		// public 
 		public override event VOIDEventHandler onApplicationQuit;
 		public override event VOIDEventHandler onSkinChanged;
+		public override event VOIDEventHandler onUpdate;
+
+		public override event VOIDEventHandler onPreForEach;
+		public override event VOIDForEachPartHandler onForEachPart;
+		public override event VOIDForEachPartModuleHandler onForEachModule;
+		public override event VOIDEventHandler onPostForEach;
 
 		/*
 		 * Methods
 		 * */
-		public override void DrawGUI()
-		{
-			this._windowID = this.windowBaseID;
-
-			if (!this._modulesLoaded)
+		public override void DrawGUI(object sender)
+		{
+			this.windowID = this.windowBaseID;
+
+			if (!this.modulesLoaded)
 			{
 				this.LoadModulesOfType<IVOID_Module>();
+
+				FireOnModulesLoaded(this);
 			}
 
 			if (!this.skinsLoaded)
@@ -355,92 +351,26 @@
 			{
 				this.LoadGUIStyles();
 
-				Tools.PostDebugMessage(
+				Logging.PostDebugMessage(
 					this,
 					"ToolbarAvailable: {0}, UseToobarManager: {1}",
 					ToolbarManager.ToolbarAvailable,
-					this.UseToolbarManager);
-			}
-
-			if (!this.UseToolbarManager)
-			{
-				if (this.AppLauncherButton == null)
-				{
-					Tools.PostDebugMessage(this,
-						"UseToolbarManager = false (ToolbarAvailable = {0}) and " +
-						"AppLauncherButton is null, making AppLauncher button.",
-						ToolbarManager.ToolbarAvailable
-					);
-					this.InitializeAppLauncherButton();
-				}
-			}
-			else if (this.ToolbarButton == null)
-			{
-				Tools.PostDebugMessage(this,
-					"UseToolbarManager = true (ToolbarAvailable = {0}) and " +
-					"ToolbarButton is null, making Toolbar button.",
-					ToolbarManager.ToolbarAvailable
-				);
-				this.InitializeToolbarButton();
-			}
-
-			if (!this.mainGuiMinimized)
-			{
-
-				Rect _mainWindowPos = this.mainWindowPos;
-
-				_mainWindowPos = GUILayout.Window(
-					this.windowID,
-					_mainWindowPos,
-					VOID_Tools.GetWindowHandler(this.VOIDMainWindow),
-					string.Join(" ", new string[] { this.VoidName, this.VoidVersion }),
-					GUILayout.Width(250f),
-					GUILayout.Height(50f),
-					GUILayout.ExpandWidth(true),
-					GUILayout.ExpandHeight(true)
-				);
-
-				if (HighLogic.LoadedSceneIsEditor)
-				{
-					_mainWindowPos = Tools.ClampRectToEditorPad(_mainWindowPos);
-				}
-				else
-				{
-					_mainWindowPos = Tools.ClampRectToScreen(_mainWindowPos);
-				}
-
-				if (_mainWindowPos != this.mainWindowPos)
-				{
-					this.mainWindowPos = _mainWindowPos;
-				}
-			}
-
-			if (!this.configWindowMinimized && !this.mainGuiMinimized)
-			{
-				Rect _configWindowPos = this.configWindowPos;
-
-				_configWindowPos = GUILayout.Window(
-					this.windowID,
-					_configWindowPos,
-					VOID_Tools.GetWindowHandler(this.VOIDConfigWindow),
-					string.Join(" ", new string[] { this.VoidName, "Configuration" }),
-					GUILayout.Width(250),
-					GUILayout.Height(50)
-				);
-
-				if (HighLogic.LoadedSceneIsEditor)
-				{
-					_configWindowPos = Tools.ClampRectToEditorPad(_configWindowPos);
-				}
-				else
-				{
-					_configWindowPos = Tools.ClampRectToScreen(_configWindowPos);
-				}
-
-				if (_configWindowPos != this.configWindowPos)
-				{
-					this.configWindowPos = _configWindowPos;
-				}
+					this.useToolbarManager);
+			}
+
+			if (
+				this.iconState != (this.powerState | this.activeState) ||
+				(this.VOIDIconTexture == null && this.AppLauncherButton != null)
+			)
+			{
+				this.iconState = this.powerState | this.activeState;
+
+				this.SetIconTexture(this.iconState);
+			}
+
+			if (this.Active)
+			{
+				base.DrawGUI(sender);
 			}
 		}
 
@@ -451,7 +381,7 @@
 			if (
 				this.vesselSimActive &&
 				(
-					this.vessel != null ||
+					this.Vessel != null ||
 					(
 						HighLogic.LoadedSceneIsEditor &&
 						EditorLogic.RootPart != null &&
@@ -460,21 +390,76 @@
 				)
 			)
 			{
-				Tools.PostDebugMessage(this, "Updating SimManager.");
+				Logging.PostDebugMessage(this, "Updating SimManager.");
 				this.UpdateSimManager();
-			}
-
-			if (!this.guiRunning)
+
+				VOIDForEachPartArgs partArgs;
+				VOIDForEachPartModuleArgs moduleArgs;
+
+				Part part;
+				PartModule partModule;
+
+				bool doForEachPart = this.onForEachPart != null;
+				bool doForEachModule = this.onForEachModule != null;
+
+				if (
+					(doForEachPart || doForEachModule) &&
+					(this.Vessel != null) &&
+					(this.Vessel.parts != null) &&
+					this.timeToUpdate
+				)
+				{
+					if (this.onPreForEach != null)
+					{
+						this.onPreForEach(this);
+					}
+
+					for (int pIdx = 0; pIdx < this.Vessel.parts.Count; pIdx++)
+					{
+						part = this.Vessel.parts[pIdx];
+						partArgs = new VOIDForEachPartArgs(part);
+
+						if (doForEachPart)
+						{
+							this.onForEachPart(this, partArgs);
+						}
+
+						if (doForEachModule && part.Modules != null)
+						{
+							for (int mIdx = 0; mIdx < part.Modules.Count; mIdx++)
+							{
+								partModule = part.Modules[mIdx];
+								moduleArgs = new VOIDForEachPartModuleArgs(partModule);
+
+								if (doForEachModule)
+								{
+									this.onForEachModule(this, moduleArgs);
+								}
+							}
+						}
+					}
+
+					if (this.onPostForEach!= null)
+					{
+						this.onPostForEach(this);
+					}
+				}
+			}
+
+			if (!this.GUIRunning && !this.gameUIHidden)
 			{
 				this.StartGUI();
 			}
 
-			foreach (IVOID_Module module in this.Modules)
-			{
+			IVOID_Module module;
+			for (int idx = 0; idx < this.modules.Count; idx++)
+			{
+				module = this.modules[idx];
+
 				if (
-					!module.guiRunning &&
-					module.toggleActive &&
-					module.inValidScene &&
+					!module.GUIRunning &&
+					module.Active &&
+					module.InValidScene &&
 					(
 						!HighLogic.LoadedSceneIsEditor ||
 						(EditorLogic.RootPart != null && EditorLogic.SortedShipList.Count > 0)
@@ -484,12 +469,12 @@
 					module.StartGUI();
 				}
 				if (
-					module.guiRunning &&
+					module.GUIRunning &&
 					(
-						!module.toggleActive ||
+						!module.Active ||
 					    !this.togglePower ||
-						!module.inValidScene ||
-					    this.factoryReset ||
+						!module.InValidScene ||
+					    this.FactoryReset ||
 						(
 							HighLogic.LoadedSceneIsEditor &&
 							(EditorLogic.RootPart == null || EditorLogic.SortedShipList.Count == 0)
@@ -506,8 +491,85 @@
 				}
 			}
 
-			this.CheckAndSave();
-			this.updateTimer += Time.deltaTime;
+			if (ToolbarManager.ToolbarAvailable && this.useToolbarManager)
+			{
+				if (this.ToolbarButton == null)
+				{
+					this.ToolbarButton = ToolbarManager.Instance.add(this.VoidName, "coreToggle");
+					this.ToolbarButton.Text = this.VoidName;
+					this.SetIconTexture(this.powerState | this.activeState);
+
+					this.ToolbarButton.Visible = true;
+
+					this.ToolbarButton.OnClick += 
+						(e) =>
+						{
+							this.ToggleMainWindow();
+						};
+
+					Logging.PostDebugMessage(string.Format("{0}: Toolbar Button initialized.", this.GetType().Name));
+				}
+
+				if (this.AppLauncherButton != null)
+				{
+					ApplicationLauncher.Instance.RemoveModApplication(this.AppLauncherButton);
+					this.AppLauncherButton = null;
+				}
+			}
+			else
+			{
+				if (this.AppLauncherButton == null)
+				{
+					if (ApplicationLauncher.Instance != null)
+					{
+						this.AppLauncherButton = ApplicationLauncher.Instance.AddModApplication(
+							this.ToggleMainWindow, this.ToggleMainWindow,
+							this.appIconVisibleScenes,
+							this.VOIDIconTexture
+						);
+
+						Logging.PostDebugMessage(
+							this,
+							"AppLauncherButton initialized in {0}",
+							Enum.GetName(
+								typeof(GameScenes),
+								HighLogic.LoadedScene
+							)
+						);
+					}
+				}
+
+				if (this.ToolbarButton != null)
+				{
+					this.ToolbarButton.Destroy();
+					this.ToolbarButton = null;
+				}
+			}
+
+			if (this.onUpdate != null)
+			{
+				this.onUpdate(this);
+			}
+
+			this.saveTimer += Time.deltaTime;
+
+			if (this.modulesLoaded && this.saveTimer > 2f)
+			{
+				if (this.configDirty)
+				{
+
+					Logging.PostDebugMessage(string.Format(
+							"{0}: Time to save, checking if configDirty: {1}",
+							this.GetType().Name,
+							this.configDirty
+						));
+
+					this.SaveConfig();
+					this.saveTimer = 0;
+				}
+			}
+
+			this.UpdateTimer += Time.deltaTime;
 		}
 
 		public virtual void FixedUpdate()
@@ -515,10 +577,10 @@
 			bool newPowerState = this.powerAvailable;
 
 			if (this.togglePower && this.consumeResource &&
-			    this.vessel.vesselType != VesselType.EVA &&
+			    this.Vessel.vesselType != VesselType.EVA &&
 			    TimeWarp.deltaTime != 0)
 			{
-				float powerReceived = this.vessel.rootPart.RequestResource(
+				float powerReceived = this.Vessel.rootPart.RequestResource(
 					this.resourceName,
 					this.resourceRate * TimeWarp.fixedDeltaTime
 				);
@@ -535,12 +597,14 @@
 				if (this.powerAvailable != newPowerState)
 				{
 					this.powerAvailable = newPowerState;
-					this.SetIconTexture(this.powerState | this.activeState);
-				}
-			}
-
-			foreach (IVOID_Module module in this.Modules)
-			{
+				}
+			}
+
+			IVOID_Module module;
+			for (int idx = 0; idx < this.modules.Count; idx++)
+			{
+				module = this.modules[idx];
+
 				if (module is IVOID_BehaviorModule)
 				{
 					((IVOID_BehaviorModule)module).FixedUpdate();
@@ -550,14 +614,19 @@
 
 		public void OnDestroy()
 		{
-			foreach (IVOID_Module module in this.Modules)
-			{
+			IVOID_Module module;
+			for (int idx = 0; idx < this.modules.Count; idx++)
+			{
+				module = this.modules[idx];
+
 				if (module is IVOID_BehaviorModule)
 				{
 					((IVOID_BehaviorModule)module).OnDestroy();
 				}
 			}
 
+			FireOnModulesDestroyed(this);
+
 			this.Dispose();
 		}
 
@@ -571,12 +640,24 @@
 			this.OnDestroy();
 		}
 
+		public override void StartGUI()
+		{
+			if (!this.GUIRunning)
+			{
+				Logging.PostDebugMessage(this, "Adding DrawGUI to onGui");
+				this.onPostRender += this.DrawGUI;
+			}
+		}
+
 		public void ResetGUI()
 		{
 			this.StopGUI();
 
-			foreach (IVOID_Module module in this.Modules)
-			{
+			IVOID_Module module;
+			for (int idx = 0; idx < this.modules.Count; idx++)
+			{
+				module = this.modules[idx];
+
 				module.StopGUI();
 				module.StartGUI();
 			}
@@ -584,7 +665,7 @@
 			this.StartGUI();
 		}
 
-		public void VOIDMainWindow(int _)
+		public override void ModuleWindow(int id)
 		{
 			GUILayout.BeginVertical();
 
@@ -598,15 +679,22 @@
 					if (GUILayout.Button("Power " + str))
 					{
 						togglePower.value = !togglePower;
-						this.SetIconTexture(this.powerState | this.activeState);
 					}
 				}
 
 				if (togglePower || !HighLogic.LoadedSceneIsFlight)
 				{
-					foreach (IVOID_Module module in this.Modules)
+					IVOID_Module module;
+					for (int idx = 0; idx < this.modules.Count; idx++)
 					{
-						module.toggleActive = GUITools.Toggle(module.toggleActive, module.Name);
+						module = this.modules[idx];
+
+						if (module is VOID_ConfigWindow)
+						{
+							continue;
+						}
+
+						module.Active = Layout.Toggle(module.Active, module.Name);
 					}
 				}
 			}
@@ -615,30 +703,75 @@
 				GUILayout.Label("-- POWER LOST --", VOID_Styles.labelRed);
 			}
 
-			this.configWindowMinimized.value = !GUITools.Toggle(!this.configWindowMinimized, "Configuration");
+			VOID_ConfigWindow.Instance.Active = Layout.Toggle(
+				VOID_ConfigWindow.Instance.Active,
+				"Configuration"
+			);
 
 			GUILayout.EndVertical();
-			GUI.DragWindow();
-		}
-
-		public void VOIDConfigWindow(int _)
-		{
-			GUILayout.BeginVertical();
-
-			this.DrawConfigurables();
-
-			GUILayout.EndVertical();
-			GUI.DragWindow();
+
+			base.ModuleWindow(id);
 		}
 
 		public override void DrawConfigurables()
 		{
 			GUIContent _content;
 
-			this.UseToolbarManager = GUITools.Toggle(this.UseToolbarManager, "Use Blizzy's Toolbar If Available");
-
-			this.vesselSimActive.value = GUITools.Toggle(this.vesselSimActive.value,
+			this.useToolbarManager.value = Layout.Toggle(this.useToolbarManager, "Use Blizzy's Toolbar If Available");
+
+			this.vesselSimActive.value = Layout.Toggle(this.vesselSimActive.value,
 				"Enable Engineering Calculations");
+
+			bool useEarthTime = (this.TimeScale & VOID_TimeScale.KERBIN_TIME) == 0u;
+			bool useSiderealTime = (this.TimeScale & VOID_TimeScale.SOLAR_DAY) == 0u;
+			bool useRoundedScale = (this.TimeScale & VOID_TimeScale.ROUNDED_SCALE) != 0u;
+
+			useEarthTime = Layout.Toggle(useEarthTime, "Use Earth Time (changes KSP option)");
+
+			GameSettings.KERBIN_TIME = !useEarthTime;
+
+			useSiderealTime = Layout.Toggle(
+				useSiderealTime,
+				string.Format(
+					"Time Scale: {0}",
+					useSiderealTime ? "Sidereal" : "Solar"
+				)
+			);
+
+			useRoundedScale = Layout.Toggle(
+				useRoundedScale,
+				string.Format(
+					"Time Scale: {0}",
+					useRoundedScale ? "Rounded" : "True"
+				)
+			);
+
+			if (useEarthTime)
+			{
+				this.TimeScale &= ~VOID_TimeScale.KERBIN_TIME;
+			}
+			else
+			{
+				this.TimeScale |= VOID_TimeScale.KERBIN_TIME;
+			}
+
+			if (useSiderealTime)
+			{
+				this.TimeScale &= ~VOID_TimeScale.SOLAR_DAY;
+			}
+			else
+			{
+				this.TimeScale |= VOID_TimeScale.SOLAR_DAY;
+			}
+
+			if (useRoundedScale)
+			{
+				this.TimeScale |= VOID_TimeScale.ROUNDED_SCALE;
+			}
+			else
+			{
+				this.TimeScale &= ~VOID_TimeScale.ROUNDED_SCALE;
+			}
 
 			GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 
@@ -650,11 +783,11 @@
 			_content.tooltip = "Select previous skin";
 			if (GUILayout.Button(_content, GUILayout.ExpandWidth(true)))
 			{
-				this._skinIdx--;
-				Tools.PostDebugMessage(string.Format(
-					"{0}: new this._skinIdx = {1} :: skin_list.Count = {2}",
+				this.skinIdx--;
+				Logging.PostDebugMessage(string.Format(
+					"{0}: new this.skinIdx = {1} :: skin_list.Count = {2}",
 					this.GetType().Name,
-					this._skinName,
+					this.skinName,
 					this.validSkins.Count
 				));
 			}
@@ -667,24 +800,24 @@
 			_content.tooltip = "Select next skin";
 			if (GUILayout.Button(_content, GUILayout.ExpandWidth(true)))
 			{
-				this._skinIdx++;
-				Tools.PostDebugMessage(string.Format(
-					"{0}: new this._skinIdx = {1} :: skin_list.Count = {2}",
+				this.skinIdx++;
+				Logging.PostDebugMessage(string.Format(
+					"{0}: new this.skinIdx = {1} :: skin_list.Count = {2}",
 					this.GetType().Name,
-					this._skinName,
+					this.skinName,
 					this.validSkins.Count
 				));
 			}
 
-			this._skinIdx %= this.skinNames.Length;
-			if (this._skinIdx < 0)
-			{
-				this._skinIdx += this.skinNames.Length;
-			}
-
-			if (this._skinName != skinNames[this._skinIdx])
-			{
-				this._skinName.value = skinNames[this._skinIdx];
+			this.skinIdx %= this.skinNames.Count;
+			if (this.skinIdx < 0)
+			{
+				this.skinIdx += this.skinNames.Count;
+			}
+
+			if (this.skinName != skinNames[this.skinIdx])
+			{
+				this.skinName.value = skinNames[this.skinIdx];
 				this.GUIStylesLoaded = false;
 			}
 
@@ -694,161 +827,137 @@
 			GUILayout.Label("Update Rate (Hz):");
 			if (this.stringFrequency == null)
 			{
-				this.stringFrequency = (1f / this.updatePeriod).ToString();
+				this.stringFrequency = (1f / this.UpdatePeriod).ToString();
 			}
 			this.stringFrequency = GUILayout.TextField(this.stringFrequency.ToString(), 5, GUILayout.ExpandWidth(true));
 
 			if (GUILayout.Button("Apply"))
 			{
-				double updateFreq = 1f / this.updatePeriod;
+				double updateFreq = 1f / this.UpdatePeriod;
 				double.TryParse(stringFrequency, out updateFreq);
-				this._updatePeriod = 1 / updateFreq;
+				this.updatePeriod.value = 1 / updateFreq;
 			}
 			GUILayout.EndHorizontal();
 
-			foreach (IVOID_Module mod in this.Modules)
-			{
-				mod.DrawConfigurables();
-			}
-
-			this.factoryReset = GUITools.Toggle(this.factoryReset, "Factory Reset");
+			IVOID_Module module;
+			for (int idx = 0; idx < this.modules.Count; idx++)
+			{
+				module = this.modules[idx];
+
+				module.DrawConfigurables();
+			}
+
+			this.FactoryReset = Layout.Toggle(this.FactoryReset, "Factory Reset");
 		}
 
 		protected void UpdateSimManager()
 		{
-			if (SimManager.ResultsReady())
-			{
-				Tools.PostDebugMessage(this, "VesselSimulator results ready, setting Stages.");
-
-				this.Stages = SimManager.Stages;
-
-				if (this.Stages != null)
-				{
-					this.LastStage = this.Stages.Last();
-				}
-
-				if (HighLogic.LoadedSceneIsEditor)
-				{
-					SimManager.Gravity = VOID_Data.KerbinGee;
-				}
-				else
-				{
-					double radius = this.vessel.Radius();
-					SimManager.Gravity = this.vessel.mainBody.gravParameter / (radius * radius);
-				}
-
-				SimManager.minSimTime = new TimeSpan(0, 0, 0, 0, (int)(this.updatePeriod * 1000d));
-
-				SimManager.TryStartSimulation();
-			}
+			if (HighLogic.LoadedSceneIsFlight)
+			{
+				double radius = this.Vessel.Radius();
+				SimManager.Gravity = this.Vessel.mainBody.gravParameter / (radius * radius);
+				SimManager.Atmosphere = this.Vessel.staticPressurekPa * PhysicsGlobals.KpaToAtmospheres;
+				SimManager.Mach = this.Vessel.mach;
+				BuildAdvanced.Altitude = this.Vessel.altitude;
+				CelestialBodies.SelectedBody = this.Vessel.mainBody;
+			}
+
 			#if DEBUG
-			else
-			{
-				Tools.PostDebugMessage(this, "VesselSimulator results not ready.");
-			}
+			SimManager.logOutput = true;
 			#endif
+
+			SimManager.TryStartSimulation();
+
+			Logging.PostDebugMessage(this, "Started Engineer simulation with Atmosphere={0} atm and Gravity={1} m/s²",
+				SimManager.Atmosphere,
+				SimManager.Gravity
+			);
+		}
+
+		protected void GetSimManagerResults()
+		{
+			Logging.PostDebugMessage(this, "VesselSimulator results ready, setting Stages.");
+
+			this.Stages = SimManager.Stages;
+
+			if (this.Stages != null && this.Stages.Length > 0)
+			{
+				this.LastStage = this.Stages[this.Stages.Length - 1];
+			}
 		}
 
 		protected void LoadModulesOfType<U>()
 		{
-			Tools.DebugLogger sb = Tools.DebugLogger.New(this);
-			sb.AppendLine("Loading modules...");
-
-			foreach (AssemblyLoader.LoadedAssembly assy in AssemblyLoader.loadedAssemblies)
-			{
-				foreach (Type loadedType in assy.assembly.GetExportedTypes())
-				{
-					if (
-						loadedType.IsInterface ||
-						loadedType.IsAbstract ||
-						!typeof(U).IsAssignableFrom(loadedType) ||
-						typeof(VOIDCore).IsAssignableFrom(loadedType)
-					)
+			using (PooledDebugLogger sb = PooledDebugLogger.New(this))
+			{
+				sb.AppendLine("Loading modules...");
+
+				AssemblyLoader.LoadedAssembly assy;
+				for (int aIdx = 0; aIdx < AssemblyLoader.loadedAssemblies.Count; aIdx++)
+				{
+					assy = AssemblyLoader.loadedAssemblies[aIdx];
+
+					Type[] loadedTypes = assy.assembly.GetExportedTypes();
+					Type loadedType;
+					for (int tIdx = 0; tIdx < loadedTypes.Length; tIdx++)
 					{
-						continue;
-					}
-
-					sb.AppendFormat("Checking IVOID_Module type {0}...", loadedType.Name);
-
-					GameScenes[] validScenes = null;
-
-					foreach (var attr in loadedType.GetCustomAttributes(true))
-					{
-						if (attr is VOID_ScenesAttribute)
+						loadedType = loadedTypes[tIdx];
+
+						if (
+							loadedType.IsInterface ||
+							loadedType.IsAbstract ||
+							!typeof(U).IsAssignableFrom(loadedType) ||
+							typeof(VOIDCore).IsAssignableFrom(loadedType))
 						{
-							validScenes = ((VOID_ScenesAttribute)attr).ValidScenes;
-
-							sb.Append("VOID_ScenesAttribute found;");
-
-							break;
+							continue;
+						}
+
+						sb.AppendFormat("Checking IVOID_Module type {0}...", loadedType.Name);
+
+						try
+						{
+							this.LoadModule(loadedType);
+							sb.AppendLine("Success.");
+						}
+						catch (Exception ex)
+						{
+							sb.AppendFormat("Failed, caught {0}\n", ex.GetType().Name);
+
+							#if DEBUG
+						Debug.LogException(ex);
+							#endif
 						}
 					}
-
-					if (validScenes == null)
-					{
-						validScenes = new GameScenes[] { GameScenes.FLIGHT };
-
-
-						sb.Append("VOID_ScenesAttribute not found;");
-
-					}
-
-					sb.AppendFormat(
-						" validScenes set to {0}.",
-						string.Join(
-							", ",
-							validScenes.Select(s => Enum.GetName(typeof(GameScenes), s)).ToArray()
-						)
-					);
-
-					if (!validScenes.Contains(HighLogic.LoadedScene))
-					{
-						sb.AppendFormat("  {0} not found in validScenes, skipping.",
-							Enum.GetName(typeof(GameScenes), HighLogic.LoadedScene));
-						continue;
-					}
-
-					sb.AppendFormat("Loading IVOID_Module type {0}...", loadedType.Name);
-
-					try
-					{
-						this.LoadModule(loadedType);
-						sb.AppendLine("Success.");
-					}
-					catch (Exception ex)
-					{
-						sb.AppendFormat("Failed, caught {0}\n", ex.GetType().Name);
-
-						#if DEBUG
-						Debug.LogException(ex);
-						#endif
-					}
-				}
-			}
-
-			this._modulesLoaded = true;
-
-			sb.AppendFormat("Loaded {0} modules.\n", this.Modules.Count);
-
-			sb.Print();
+				}
+
+				this.LoadConfig();
+
+				this.modulesLoaded = true;
+
+				sb.AppendFormat("Loaded {0} modules.\n", this.Modules.Count);
+
+				sb.Print();
+			}
 		}
 
 		protected void LoadModule(Type T)
 		{
-			var existingModules = this._modules.Where(mod => mod.GetType().Name == T.Name);
-			if (existingModules.Any())
-			{
-				Tools.PostDebugMessage(string.Format(
-					"{0}: refusing to load {1}: already loaded",
-					this.GetType().Name,
-					T.Name
-				));
-				return;
+			/*var existingModules = this.modules.Where(mod => mod.GetType().Name == T.Name);
+			if (existingModules.Any())*/
+			for (int mIdx = 0; mIdx < this.modules.Count; mIdx++)
+			{
+				if (this.modules[mIdx].Name == T.Name)
+				{
+					Logging.PostErrorMessage("{0}: refusing to load {1}: already loaded", this.GetType().Name, T.Name);
+					return;
+				}
 			}
 
 			var InstanceProperty = T.GetProperty(
 				"Instance",
-				System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public
+				System.Reflection.BindingFlags.Static |
+				System.Reflection.BindingFlags.Public |
+				System.Reflection.BindingFlags.FlattenHierarchy
 			);
 
 			object modInstance = null;
@@ -868,69 +977,78 @@
 				module = Activator.CreateInstance(T) as IVOID_Module;
 			}
 
-			module.LoadConfig();
-			this._modules.Add(module);
-
-			Tools.PostDebugMessage(string.Format(
-				"{0}: loaded module {1}.",
-				this.GetType().Name,
-				T.Name
-			));
+			if (module.InValidGame && module.InValidScene)
+			{
+				this.modules.Add(module);
+
+				Logging.PostDebugMessage(string.Format(
+						"{0}: loaded module {1}.",
+						this.GetType().Name,
+						T.Name
+					));
+			}
+			else
+			{
+				if (module is IDisposable)
+				{
+					(module as IDisposable).Dispose();
+				}
+			}
 		}
 
 		protected void LoadSkins()
 		{
-			Tools.PostDebugMessage("AssetBase has skins: \n" +
-				string.Join("\n\t",
-					Resources.FindObjectsOfTypeAll(typeof(GUISkin))
-					.Select(s => s.ToString())
-					.ToArray()
-				)
-			);
-
-			this.validSkins = Resources.FindObjectsOfTypeAll(typeof(GUISkin))
-				.Where(s => !this.forbiddenSkins.Contains(s.name))
-				.Select(s => s as GUISkin)
-				.GroupBy(s => s.name)
-				.Select(g => g.First())
-				.ToDictionary(s => s.name);
-
-			Tools.PostDebugMessage(string.Format(
+			this.validSkins = new Dictionary<string, GUISkin>();
+			this.skinNames = new List<string>();
+
+			UnityEngine.Object[] skins = Resources.FindObjectsOfTypeAll(typeof(GUISkin));
+			GUISkin skin;
+			for (int sIdx = 0; sIdx < skins.Length; sIdx++)
+			{
+				skin = (GUISkin)skins[sIdx];
+
+				if (!this.forbiddenSkins.Contains(skin.name))
+				{
+					this.validSkins[skin.name] = skin;
+					this.skinNames.Add(skin.name);
+				}
+			}
+
+			Logging.PostDebugMessage(string.Format(
 				"{0}: loaded {1} GUISkins.",
 				this.GetType().Name,
 				this.validSkins.Count
 			));
 
-			this.skinNames = this.validSkins.Keys.ToArray();
-			Array.Sort(this.skinNames);
+			this.skinNames.Sort();
 
 			int defaultIdx = int.MinValue;
 
-			for (int i = 0; i < this.skinNames.Length; i++)
-			{
-				if (this.skinNames[i] == this._skinName)
-				{
-					this._skinIdx = i;
+			for (int i = 0; i < this.skinNames.Count; i++)
+			{
+				if (this.skinNames[i] == this.skinName)
+				{
+					this.skinIdx = i;
 				}
 				if (this.skinNames[i] == this.defaultSkin)
 				{
 					defaultIdx = i;
 				}
-				if (this._skinIdx != int.MinValue && defaultIdx != int.MinValue)
+				if (this.skinIdx != int.MinValue && defaultIdx != int.MinValue)
 				{
 					break;
 				}
 			}
 
-			if (this._skinIdx == int.MinValue)
-			{
-				this._skinIdx = defaultIdx;
-			}
-
-			Tools.PostDebugMessage(string.Format(
+			if (this.skinIdx == int.MinValue)
+			{
+				this.skinIdx = defaultIdx;
+			}
+
+			Logging.PostDebugMessage(string.Format(
 				"{0}: _skinIdx = {1}.",
 				this.GetType().Name,
-				this._skinName.ToString()
+				this.skinName.ToString()
 			));
 
 			this.skinsLoaded = true;
@@ -948,79 +1066,45 @@
 			this.GUIStylesLoaded = true;
 		}
 
-		protected void LoadVesselTypes()
-		{
-			this._allVesselTypes = Enum.GetValues(typeof(VesselType)).OfType<VesselType>().ToList();
-			this.vesselTypesLoaded = true;
-		}
-
 		protected void LoadBeforeUpdate()
 		{
 			if (!this.vesselTypesLoaded)
 			{
-				this.LoadVesselTypes();
-			}
-
-			if (this.sortedBodyList == null && FlightGlobals.Bodies != null && FlightGlobals.Bodies.Count > 0)
-			{
-				this.sortedBodyList = new List<CelestialBody>(FlightGlobals.Bodies);
-				this.sortedBodyList.Sort(new CBListComparer());
-				this.sortedBodyList.Reverse();
-
-				Debug.Log(string.Format("sortedBodyList: {0}", string.Join("\n\t", this.sortedBodyList.Select(b => b.bodyName).ToArray())));
-			}
-
-		}
-
-		protected void InitializeToolbarButton()
-		{
-			// Do nothing if (the Toolbar is not available.
-			if (!ToolbarManager.ToolbarAvailable)
-			{
-				Tools.PostDebugMessage(this, "Refusing to make a ToolbarButton: ToolbarAvailable = false");
-				return;
-			}
-
-			this.ToolbarButton = ToolbarManager.Instance.add(this.VoidName, "coreToggle");
-			this.ToolbarButton.Text = this.VoidName;
-			this.SetIconTexture(this.powerState | this.activeState);
-
-			this.ToolbarButton.Visible = true;
-
-			this.ToolbarButton.OnClick += 
-				(e) =>
-			{
-				this.ToggleMainWindow();
-			};
-
-			Tools.PostDebugMessage(string.Format("{0}: Toolbar Button initialized.", this.GetType().Name));
-		}
-
-		protected void InitializeAppLauncherButton()
-		{
-			if (ApplicationLauncher.Ready)
-			{
-				this.AppLauncherButton = ApplicationLauncher.Instance.AddModApplication(
-					this.ToggleMainWindow, this.ToggleMainWindow,
-					this.appIconVisibleScenes,
-					this.VOIDIconTexture
-				);
-
-				Tools.PostDebugMessage(
-					this,
-					"AppLauncherButton initialized in {0}",
-					Enum.GetName(
-						typeof(GameScenes),
-						HighLogic.LoadedScene
-					)
-				);
+				Array typeObjs = Enum.GetValues(typeof(VesselType));
+				this.AllVesselTypes = new VesselType[typeObjs.Length];
+
+				for (int idx = 0; idx < typeObjs.Length; idx++)
+				{
+					this.AllVesselTypes[idx] = (VesselType)typeObjs.GetValue(idx);
+				}
+
+				this.vesselTypesLoaded = true;
+			}
+
+			if (this.SortedBodyList == null && FlightGlobals.Bodies != null && FlightGlobals.Bodies.Count > 0)
+			{
+				this.SortedBodyList = new List<CelestialBody>(FlightGlobals.Bodies);
+				this.SortedBodyList.Sort(new CBListComparer());
+				this.SortedBodyList.Reverse();
+			}
+
+			// SimManager initialization that we don't necessarily want to repeat every Update.
+			if (!this.simManagerLoaded && this.HomeBody != null)
+			{
+				SimManager.Gravity = VOID_Data.KerbinGee;
+				SimManager.Atmosphere = 0d;
+				SimManager.Mach = 1d;
+				CelestialBodies.SelectedBody = this.HomeBody;
+				BuildAdvanced.Altitude = 0d;
+				SimManager.OnReady += this.GetSimManagerResults;
+
+				this.simManagerLoaded = true;
 			}
 		}
 
 		protected void ToggleMainWindow()
 		{
-			this.mainGuiMinimized = !this.mainGuiMinimized;
-			this.SetIconTexture(this.powerState | this.activeState);
+			this.Active = !this.Active;
 		}
 
 		protected void SetIconTexture(IconState state)
@@ -1046,49 +1130,55 @@
 
 		protected void SetIconTexture(string texturePath)
 		{
+			if (texturePath == null)
+			{
+				return;
+			}
+
 			if (this.ToolbarButton != null)
 			{
 				this.ToolbarButton.TexturePath = texturePath;
 			}
 
-			this.VOIDIconTexture = GameDatabase.Instance.GetTexture(texturePath.Replace("icon", "appIcon"), false);
-
 			if (this.AppLauncherButton != null)
 			{
+				this.VOIDIconTexture = GameDatabase.Instance.GetTexture(texturePath.Replace("icon", "appIcon"), false);
+
 				this.AppLauncherButton.SetTexture(VOIDIconTexture);
 			}
 		}
 
-		protected virtual void CheckAndSave()
-		{
-			this.saveTimer += Time.deltaTime;
-
-			if (this.saveTimer > 2f)
-			{
-				if (!this.configDirty)
-				{
-					return;
-				}
-
-				Tools.PostDebugMessage(string.Format(
-					"{0}: Time to save, checking if configDirty: {1}",
-					this.GetType().Name,
-					this.configDirty
-				));
-
-				this.SaveConfig();
-				this.saveTimer = 0;
-			}
-		}
-
-		public override void LoadConfig()
-		{
-			base.LoadConfig();
-
-			foreach (IVOID_Module module in this.Modules)
-			{
-				module.LoadConfig();
-			}
+		public void LoadConfig()
+		{
+
+			if (!System.IO.File.Exists(this.VOIDSettingsPath) && KSP.IO.File.Exists<VOID_Module>("config.xml"))
+			{
+				Logging.PostLogMessage(
+					"VOID: No per-save config file but old file detected; copying from old file."
+				);
+
+				System.IO.File.Copy(
+					KSP.IO.IOUtils.GetFilePathFor(typeof(VOID_Module), "config.xml"),
+					this.VOIDSettingsPath
+				);
+			}
+
+			this.LoadConfig(new PluginConfiguration(this.VOIDSettingsPath));
+		}
+
+		public override void LoadConfig(KSP.IO.PluginConfiguration config)
+		{
+			base.LoadConfig(config);
+
+			IVOID_Module module;
+			for (int idx = 0; idx < this.modules.Count; idx++)
+			{
+				module = this.modules[idx];
+
+				module.LoadConfig(config);
+			}
+
+			this.TimeScale |= GameSettings.KERBIN_TIME ? VOID_TimeScale.KERBIN_TIME : 0u;
 		}
 
 		public override void SaveConfig()
@@ -1096,17 +1186,21 @@
 			if (this.configNeedsUpdate && this is VOIDCore_Flight)
 			{
 				KSP.IO.File.Delete<T>("config.xml");
-			}
-
-			var config = KSP.IO.PluginConfiguration.CreateForType<T>();
+				System.IO.File.Delete(this.VOIDSettingsPath);
+			}
+
+			KSP.IO.PluginConfiguration config = new PluginConfiguration(this.VOIDSettingsPath);
 
 			config.load();
 
-			this._SaveToConfig(config);
-
-			foreach (IVOID_Module module in this.Modules)
-			{
-				module._SaveToConfig(config);
+			this.Save(config, this.SceneKey);
+
+			IVOID_Module module;
+			for (int idx = 0; idx < this.modules.Count; idx++)
+			{
+				module = this.modules[idx];
+
+				module.Save(config, this.SceneKey);
 			}
 
 			config.save();
@@ -1116,18 +1210,18 @@
 
 		public VOIDCore_Generic()
 		{
-			this.Name = "VOID Core";
-
 			System.Version version = this.GetType().Assembly.GetName().Version;
 
 			this.VoidVersion = string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.MajorRevision);
 
+			this.Name = string.Format("VOID {0}", this.VoidVersion.ToString());
+
 			this.powerAvailable = true;
 
-			this.toggleActive = true;
-
-			this._skinName = this.defaultSkin;
-			this._skinIdx = int.MinValue;
+			this.Active = true;
+
+			this.skinName = (VOID_SaveValue<string>)this.defaultSkin;
+			this.skinIdx = int.MinValue;
 
 			this.VOIDIconOnActivePath = "VOID/Textures/void_icon_light_glow";
 			this.VOIDIconOnInactivePath = "VOID/Textures/void_icon_dark_glow";
@@ -1135,24 +1229,23 @@
 			this.VOIDIconOffInactivePath = "VOID/Textures/void_icon_dark";
 
 			this.saveTimer = 0f;
-			this.updateTimer = 0f;
-
-			this.vesselSimActive = true;
-
-			this.UseToolbarManager = ToolbarManager.ToolbarAvailable;
-
-			this.LoadConfig();
-
-			this._configVersion = VOIDCore.CONFIG_VERSION;
-			
-			this.SetIconTexture(this.powerState | this.activeState);
-
-			this.factoryReset = false;
-		}
-
-		public virtual void Dispose()
+			this.UpdateTimer = 0f;
+
+			this.vesselSimActive = (VOID_SaveValue<bool>)true;
+
+			this.useToolbarManager = (VOID_SaveValue<bool>)ToolbarManager.ToolbarAvailable;
+
+			this.SaveGamePath = string.Format("{0}saves/{1}", IOTools.KSPRootPath, HighLogic.SaveFolder);
+			this.VOIDSettingsPath = string.Format("{0}/VOIDConfig.xml", this.SaveGamePath);
+
+			this.FactoryReset = false;
+		}
+
+		public override void Dispose()
 		{
 			this.StopGUI();
+
+			this.onSkinChanged(this);
 
 			if (this.AppLauncherButton != null)
 			{
@@ -1168,15 +1261,6 @@
 			_instance = null;
 			_initialized = false;
 		}
-
-		protected enum IconState
-		{
-			PowerOff = 1,
-			PowerOn = 2,
-			Inactive = 4,
-			Active = 8
-		}
 	}
 }
 
-

--- a/VOIDCore_SpaceCentre.cs
+++ b/VOIDCore_SpaceCentre.cs
@@ -32,9 +32,12 @@
 	[VOID_Scenes(GameScenes.SPACECENTER)]
 	public class VOIDCore_SpaceCentre : VOIDCore_Generic<VOIDCore_SpaceCentre>
 	{
-		public VOIDCore_SpaceCentre() : base()
+		public override string SceneKey
 		{
-			base.Name = "VOID Core: SpaceCentre";
+			get
+			{
+				return "SPACECENTER";
+			}
 		}
 
 		public override void FixedUpdate() {}

--- a/VOIDMaster_Editor.cs
+++ b/VOIDMaster_Editor.cs
@@ -43,7 +43,7 @@
 using KerbalEngineer.VesselSimulator;
 using KSP;
 using System;
-using ToadicusTools;
+using ToadicusTools.Extensions;
 using UnityEngine;
 
 namespace VOID
@@ -53,10 +53,10 @@
 	{
 		public override void Awake()
 		{
-			Tools.PostDebugMessage ("VOIDEditorMaster: Waking up.");
+			this.LogDebug("VOIDEditorMaster: Waking up.");
 			this.Core = VOIDCore_Editor.Instance;
 			this.Core.ResetGUI ();
-			Tools.PostDebugMessage ("VOIDEditorMaster: Awake.");
+			this.LogDebug("VOIDEditorMaster: Awake.");
 		}
 	}
 }

--- a/VOIDMaster_Flight.cs
+++ b/VOIDMaster_Flight.cs
@@ -43,7 +43,7 @@
 using System;
 using UnityEngine;
 using KerbalEngineer.VesselSimulator;
-using ToadicusTools;
+using ToadicusTools.Extensions;
 
 namespace VOID
 {

--- a/VOIDMaster_SpaceCentre.cs
+++ b/VOIDMaster_SpaceCentre.cs
@@ -43,7 +43,7 @@
 using System;
 using UnityEngine;
 using KerbalEngineer.VesselSimulator;
-using ToadicusTools;
+using ToadicusTools.Extensions;
 
 namespace VOID
 {

--- a/VOID_CBInfoBrowser.cs
+++ b/VOID_CBInfoBrowser.cs
@@ -29,7 +29,7 @@
 using KSP;
 using System;
 using System.Collections.Generic;
-using ToadicusTools;
+using ToadicusTools.Text;
 using UnityEngine;
 
 namespace VOID
@@ -37,22 +37,22 @@
 	public class VOID_CBInfoBrowser : VOID_WindowModule
 	{
 		[AVOID_SaveValue("selectedBodyIdx1")]
-		protected VOID_SaveValue<int> selectedBodyIdx1 = 1;
+		protected VOID_SaveValue<int> selectedBodyIdx1;
 
 		[AVOID_SaveValue("selectedBodyIdx2")]
-		protected VOID_SaveValue<int> selectedBodyIdx2 = 2;
+		protected VOID_SaveValue<int> selectedBodyIdx2;
 
 		protected CelestialBody selectedBody1;
 		protected CelestialBody selectedBody2;
 
 		[AVOID_SaveValue("toggleOrbital")]
-		protected VOID_SaveValue<bool> toggleOrbital = false;
+		protected VOID_SaveValue<bool> toggleOrbital;
 
 		[AVOID_SaveValue("togglePhysical")]
-		protected VOID_SaveValue<bool> togglePhysical = false;
+		protected VOID_SaveValue<bool> togglePhysical;
 
 		[AVOID_SaveValue("toggleScience")]
-		protected VOID_SaveValue<bool> toggleScience = false;
+		protected VOID_SaveValue<bool> toggleScience;
 
 		public VOID_CBInfoBrowser()
 		{
@@ -60,11 +60,24 @@
 
 			this.WindowPos.x = 10;
 			this.WindowPos.y = 85;
+
+			this.selectedBodyIdx1 = (VOID_SaveValue<int>)1;
+			this.selectedBodyIdx2 = (VOID_SaveValue<int>)2;
+
+			this.toggleOrbital = (VOID_SaveValue<bool>)false;
+			this.togglePhysical = (VOID_SaveValue<bool>)false;
+			this.toggleScience = (VOID_SaveValue<bool>)false;
 		}
 
-		public override void ModuleWindow(int _)
+		public override void ModuleWindow(int id)
 		{
 			GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
+
+			if (this.core.SortedBodyList.Count < 1)
+			{
+				GUILayout.Label("Non-positive number of CelestialBodies here, bailing out.");
+				GUILayout.EndHorizontal();
+			}
 
 			GUILayout.BeginVertical(GUILayout.Width(150));
 			GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
@@ -75,20 +88,46 @@
 
 			GUILayout.BeginVertical(GUILayout.Width(150));
 
-			selectedBody1 = this.core.allBodies[selectedBodyIdx1];
-			selectedBody2 = this.core.allBodies[selectedBodyIdx2];
+			if (selectedBodyIdx1 >= this.core.SortedBodyList.Count)
+			{
+				selectedBodyIdx1.value %= this.core.SortedBodyList.Count;
+			}
+
+			if (selectedBodyIdx1 < 0)
+			{
+				selectedBodyIdx1.value += this.core.SortedBodyList.Count;
+			}
+
+			if (selectedBodyIdx2 >= this.core.SortedBodyList.Count)
+			{
+				selectedBodyIdx2.value %= this.core.SortedBodyList.Count;
+			}
+
+			if (selectedBodyIdx2 < 0)
+			{
+				selectedBodyIdx2.value += this.core.SortedBodyList.Count;
+			}
+
+			selectedBody1 = this.core.SortedBodyList[selectedBodyIdx1];
+			selectedBody2 = this.core.SortedBodyList[selectedBodyIdx2];
 
 			GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 			if (GUILayout.Button("<", GUILayout.ExpandWidth(false)))
 			{
-				selectedBodyIdx1--;
-				if (selectedBodyIdx1 < 0) selectedBodyIdx1 = this.core.allBodies.Count - 1;
-			}
-			GUILayout.Label(this.core.allBodies[selectedBodyIdx1].bodyName, VOID_Styles.labelCenterBold, GUILayout.ExpandWidth(true));
+				selectedBodyIdx1.value--;
+				if (selectedBodyIdx1 < 0)
+				{
+					selectedBodyIdx1.value = this.core.SortedBodyList.Count - 1;
+				}
+			}
+			GUILayout.Label(this.core.SortedBodyList[selectedBodyIdx1].bodyName, VOID_Styles.labelCenterBold, GUILayout.ExpandWidth(true));
 			if (GUILayout.Button(">", GUILayout.ExpandWidth(false)))
 			{
-				selectedBodyIdx1++;
-				if (selectedBodyIdx1 > this.core.allBodies.Count - 1) selectedBodyIdx1 = 0;
+				selectedBodyIdx1.value++;
+				if (selectedBodyIdx1 > this.core.SortedBodyList.Count - 1)
+				{
+					selectedBodyIdx1.value = 0;
+				}
 			}
 			GUILayout.EndHorizontal();
 			GUILayout.EndVertical();
@@ -97,14 +136,20 @@
 			GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 			if (GUILayout.Button("<", GUILayout.ExpandWidth(false)))
 			{
-				selectedBodyIdx2--;
-				if (selectedBodyIdx2 < 0) selectedBodyIdx2 = this.core.allBodies.Count - 1;
-			}
-			GUILayout.Label(this.core.allBodies[selectedBodyIdx2].bodyName, VOID_Styles.labelCenterBold, GUILayout.ExpandWidth(true));
+				selectedBodyIdx2.value--;
+				if (selectedBodyIdx2 < 0)
+				{
+					selectedBodyIdx2.value = this.core.SortedBodyList.Count - 1;
+				}
+			}
+			GUILayout.Label(this.core.SortedBodyList[selectedBodyIdx2].bodyName, VOID_Styles.labelCenterBold, GUILayout.ExpandWidth(true));
 			if (GUILayout.Button(">", GUILayout.ExpandWidth(false)))
 			{
-				selectedBodyIdx2++;
-				if (selectedBodyIdx2 > this.core.allBodies.Count - 1) selectedBodyIdx2 = 0;
+				selectedBodyIdx2.value++;
+				if (selectedBodyIdx2 > this.core.SortedBodyList.Count - 1)
+				{
+					selectedBodyIdx2.value = 0;
+				}
 			}
 			GUILayout.EndHorizontal();
 			GUILayout.EndVertical();
@@ -184,7 +229,7 @@
 				GUILayout.Label("Natural satellites:");
 				GUILayout.Label("Artificial satellites:");
 				GUILayout.Label("Surface gravity:");
-				GUILayout.Label("Atmosphere altitude:");
+				GUILayout.Label("Atmosphere Depth:");
 				GUILayout.Label("Atmospheric O\u2082:");
 				GUILayout.Label("Has ocean:");
 
@@ -277,7 +322,7 @@
 				GUILayout.EndHorizontal();
 			}
 
-			GUI.DragWindow();
+			base.ModuleWindow(id);
 		}
 
 		private void body_OP_show_orbital_info(CelestialBody body)
@@ -354,15 +399,19 @@
 
 			GUILayout.Label(p.ToString("##,#") + "kg/m³", VOID_Styles.labelRight, GUILayout.ExpandWidth(true));
 
-			if (body.bodyName == "Sun") GUILayout.Label(Tools.MuMech_ToSI(body.sphereOfInfluence), VOID_Styles.labelRight, GUILayout.ExpandWidth(true));
-			else GUILayout.Label(Tools.MuMech_ToSI(body.sphereOfInfluence), VOID_Styles.labelRight, GUILayout.ExpandWidth(true));
+			if (body.bodyName == "Sun") GUILayout.Label(SIFormatProvider.ToSI(body.sphereOfInfluence, 3), VOID_Styles.labelRight, GUILayout.ExpandWidth(true));
+			else GUILayout.Label(SIFormatProvider.ToSI(body.sphereOfInfluence, 3), VOID_Styles.labelRight, GUILayout.ExpandWidth(true));
 
 			GUILayout.Label(body.orbitingBodies.Count.ToString(), VOID_Styles.labelRight, GUILayout.ExpandWidth(true));
 
 			//show # artificial satellites
 			int num_art_sats = 0;
-			foreach (Vessel v in FlightGlobals.Vessels)
-			{
+
+			Vessel v;
+			for (int idx = 0; idx < FlightGlobals.Vessels.Count; idx++)
+			{
+				v = FlightGlobals.Vessels[idx];
+
 				if (v.mainBody == body && v.situation.ToString() == "ORBITING") num_art_sats++;
 			}
 
@@ -370,11 +419,11 @@
 
 			double g_ASL = (VOIDCore.Constant_G * body.Mass) / (body.Radius * body.Radius);
 
-			GUILayout.Label(Tools.MuMech_ToSI(g_ASL) + "m/s²", VOID_Styles.labelRight, GUILayout.ExpandWidth(true));
+			GUILayout.Label(SIFormatProvider.ToSI(g_ASL, 3) + "m/s²", VOID_Styles.labelRight, GUILayout.ExpandWidth(true));
 
 			if (body.atmosphere)
 			{
-				GUILayout.Label("≈ " + Tools.MuMech_ToSI(body.maxAtmosphereAltitude) + "m",
+				GUILayout.Label("≈ " + SIFormatProvider.ToSI(body.atmosphereDepth, 3) + "m",
 					VOID_Styles.labelRight,
 					GUILayout.ExpandWidth(true));
 

--- a/VOID_CareerStatus.cs
+++ b/VOID_CareerStatus.cs
@@ -30,29 +30,24 @@
 using System;
 using System.Text;
 using ToadicusTools;
+using ToadicusTools.Text;
 using UnityEngine;
 
 namespace VOID
 {
 	[VOID_Scenes(GameScenes.FLIGHT, GameScenes.EDITOR, GameScenes.SPACECENTER)]
 	[VOID_GameModes(Game.Modes.CAREER, Game.Modes.SCIENCE_SANDBOX)]
-	public class VOID_CareerStatus : VOID_WindowModule
+	public class VOID_CareerStatus : VOID_SingletonWindow<VOID_CareerStatus>
 	{
-		public static VOID_CareerStatus Instance
-		{
-			get;
-			private set;
-		}
-
 		public static string formatDelta(double delta, string numberFormat)
 		{
 			if (delta > 0)
 			{
-				return string.Format("<color='lime'>{0}↑</color>", delta.ToString(numberFormat, Tools.SIFormatter));
+				return string.Format("<color='lime'>{0}↑</color>", delta.ToString(numberFormat, SIFormatProvider.SIFormatter));
 			}
 			else if (delta < 0)
 			{
-				return string.Format("<color='red'>{0}↓</color>", delta.ToString(numberFormat, Tools.SIFormatter));
+				return string.Format("<color='red'>{0}↓</color>", delta.ToString(numberFormat, SIFormatProvider.SIFormatter));
 			}
 			else
 			{
@@ -122,7 +117,7 @@
 		{
 			get
 			{
-				Tools.PostDebugMessage(
+				Logging.PostDebugMessage(
 					this,
 					"Checking init state:" +
 					"\n\tcurrentFunds={0}" +
@@ -141,17 +136,17 @@
 			}
 		}
 
-		public override void DrawGUI()
+		public override void DrawGUI(object sender)
 		{
 			if (Event.current.type != EventType.Layout && !this.currenciesInitialized)
 			{
 				this.initCurrencies();
 			}
 
-			base.DrawGUI();
-		}
-
-		public override void ModuleWindow(int _)
+			base.DrawGUI(sender);
+		}
+
+		public override void ModuleWindow(int id)
 		{
 			GUILayout.BeginVertical();
 
@@ -178,7 +173,7 @@
 
 			GUILayout.EndVertical();
 
-			GUI.DragWindow();
+			base.ModuleWindow(id);
 		}
 
 		// TODO: Update event handlers to do something useful with the new "reasons" parameter.
@@ -207,7 +202,7 @@
 
 		private void initCurrencies()
 		{
-			Tools.PostDebugMessage(
+			Logging.PostDebugMessage(
 				this,
 				"Initializing currencies." +
 				"\n\tFunding.Instance={0}" +
@@ -233,8 +228,6 @@
 		 * */
 		public VOID_CareerStatus() : base()
 		{
-			VOID_CareerStatus.Instance = this;
-
 			this.Name = "Career Status";
 
 			GameEvents.OnFundsChanged.Add(this.onFundsChange);
@@ -266,14 +259,19 @@
 			this.currentReputation = float.NaN;
 		}
 
-		~VOID_CareerStatus()
+		public override void Dispose()
 		{
 			GameEvents.OnFundsChanged.Remove(this.onFundsChange);
 			GameEvents.OnReputationChanged.Remove(this.onRepChange);
 			GameEvents.OnScienceChanged.Remove(this.onScienceChange);
 			GameEvents.onGameStateLoad.Remove(this.onGameStateLoad);
 
-			VOID_CareerStatus.Instance = null;
+			base.Dispose();
+		}
+
+		~VOID_CareerStatus()
+		{
+			this.Dispose();
 		}
 	}
 }

--- /dev/null
+++ b/VOID_ConfigWindow.cs
@@ -1,1 +1,75 @@
+// VOID
+//
+// VOID_ConfigModule.cs
+//
+// Copyright © 2015, toadicus
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+//    this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used
+//    to endorse or promote products derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+using KSP;
+using System;
+using UnityEngine;
+
+namespace VOID
+{
+	public class VOID_ConfigWindow : VOID_SingletonWindow<VOID_ConfigWindow>
+	{
+		public override bool InValidScene
+		{
+			get
+			{
+				return true;
+			}
+		}
+
+		public override bool InValidGame
+		{
+			get
+			{
+				return true;
+			}
+		}
+
+		public VOID_ConfigWindow() : base()
+		{
+			this.Name = "VOID Configuration";
+		}
+
+		public override void ModuleWindow(int id)
+		{
+			GUILayout.BeginVertical();
+
+			this.core.DrawConfigurables();
+
+			GUILayout.EndVertical();
+
+			base.ModuleWindow(id);
+		}
+
+		~VOID_ConfigWindow()
+		{
+			this.Dispose();
+		}
+	}
+}
+

--- a/VOID_Data.cs
+++ b/VOID_Data.cs
@@ -31,6 +31,8 @@
 using System;
 using System.Collections.Generic;
 using ToadicusTools;
+using ToadicusTools.Extensions;
+using ToadicusTools.MuMechTools;
 using UnityEngine;
 
 namespace VOID
@@ -38,6 +40,7 @@
 	public static class VOID_Data
 	{
 		private static Dictionary<int, IVOID_DataValue> dataValues = new Dictionary<int, IVOID_DataValue>();
+
 		public static Dictionary<int, IVOID_DataValue> DataValues
 		{
 			get
@@ -115,29 +118,29 @@
 		public static readonly VOID_DoubleValue atmDensity =
 			new VOID_DoubleValue(
 				"Atmosphere Density",
-				new Func<double>(() => Core.vessel.atmDensity * 1000f),
+				new Func<double>(() => Core.Vessel.atmDensity * 1000d),
 				"g/m³"
 			);
 
-		public static readonly VOID_FloatValue atmLimit =
-			new VOID_FloatValue(
-				"Atmosphere Limit",
-				new Func<float>(() => Core.vessel.mainBody.maxAtmosphereAltitude),
+		public static readonly VOID_DoubleValue atmLimit =
+			new VOID_DoubleValue(
+				"Atmosphere Depth",
+				new Func<double>(() => Core.Vessel.mainBody.atmosphereDepth),
 				"m"
 			);
 
 		public static readonly VOID_DoubleValue atmPressure =
 			new VOID_DoubleValue(
-				"Pressure",
-				new Func<double>(() => Core.vessel.staticPressure),
-				"atm"
-			);
-
-		public static readonly VOID_FloatValue temperature =
-			new VOID_FloatValue(
+				"Static Pressure",
+				new Func<double>(() => Core.Vessel.staticPressurekPa * 1000d),
+				"Pa"
+			);
+
+		public static readonly VOID_DoubleValue temperature =
+			new VOID_DoubleValue(
 				"Temperature",
-				new Func<float>(() => Core.vessel.flightIntegrator.getExternalTemperature()),
-				"°C"
+				new Func<double>(() => Core.Vessel.atmosphericTemperature),
+				"K"
 			);
 
 		#endregion
@@ -149,7 +152,7 @@
 				"Heading",
 				delegate()
 				{
-					double heading = Core.vessel.getSurfaceHeading();
+					double heading = Core.Vessel.getSurfaceHeading();
 					string cardinal = VOID_Tools.get_heading_text(heading);
 
 					return string.Format(
@@ -163,7 +166,7 @@
 		public static readonly VOID_DoubleValue vesselPitch =
 			new VOID_DoubleValue(
 				"Pitch",
-				() => Core.vessel.getSurfacePitch(),
+				() => Core.Vessel.getSurfacePitch(),
 				"°"
 			);
 
@@ -229,8 +232,8 @@
 		public static readonly VOID_FloatValue mainThrottle =
 			new VOID_FloatValue(
 				"Throttle",
-				new Func<float>(() => Core.vessel.ctrlState.mainThrottle * 100f),
-				"%"
+				new Func<float>(() => Core.Vessel.ctrlState.mainThrottle),
+				""
 			);
 
 		#endregion
@@ -240,7 +243,7 @@
 		public static readonly VOID_IntValue partCount =
 			new VOID_IntValue(
 				"Parts",
-				new Func<int>(() => Core.vessel.Parts.Count),
+				new Func<int>(() => Core.Vessel.Parts.Count),
 				""
 			);
 
@@ -268,22 +271,22 @@
 						return double.NaN;
 					}
 
+					return Core.LastStage.totalResourceMass;
+				},
+				"tons"
+			);
+
+		public static readonly VOID_DoubleValue stageResourceMass =
+			new VOID_DoubleValue(
+				"Resource Mass (Stage)",
+				delegate()
+				{
+					if (Core.LastStage == null)
+					{
+						return double.NaN;
+					}
+
 					return Core.LastStage.resourceMass;
-				},
-				"tons"
-			);
-
-		public static readonly VOID_DoubleValue stageResourceMass =
-			new VOID_DoubleValue(
-				"Resource Mass (Stage)",
-				delegate()
-				{
-					if (Core.LastStage == null)
-					{
-						return double.NaN;
-					}
-
-					return Core.LastStage.totalResourceMass;
 				},
 				"tons"
 			);
@@ -351,6 +354,19 @@
 				}
 			);
 
+		public static readonly VOID_DoubleValue currThrust =
+			new VOID_DoubleValue(
+				"Current Thrust",
+				delegate()
+				{
+					if (Core.Stages == null || Core.LastStage == null)
+						return double.NaN;
+
+					return Core.LastStage.actualThrust;
+				},
+				"kN"
+			);
+
 		public static readonly VOID_StrValue currmaxThrust =
 			new VOID_StrValue(
 				"Thrust (curr/max)",
@@ -380,19 +396,7 @@
 						return double.NaN;
 					}
 
-					double stageIsp = Core.LastStage.isp;
-					double stageThrust = stageNominalThrust;
-
-					Tools.PostDebugMessage(typeof(VOID_Data), "calculating stageMassFlow from:\n" +
-						"\tstageIsp: {0}\n" +
-						"\tstageThrust: {1}\n" +
-						"\tKerbinGee: {2}\n",
-						stageIsp,
-						stageThrust,
-						KerbinGee
-					);
-
-					return stageThrust / (stageIsp * KerbinGee);
+					return Core.LastStage.MassFlow();
 				},
 				"Mg/s"
 			);
@@ -407,14 +411,7 @@
 						return double.NaN;
 					}
 
-					if (Core.LastStage.actualThrust == 0d)
-					{
-						return Core.LastStage.thrust;
-					}
-					else
-					{
-						return Core.LastStage.actualThrust;
-					}
+					return Core.LastStage.NominalThrust();
 				},
 				"kN"
 			);
@@ -480,8 +477,8 @@
 
 					double maxThrust = Core.LastStage.thrust;
 					double mass = Core.LastStage.totalMass;
-					double gravity = (VOIDCore.Constant_G * Core.vessel.mainBody.Mass) /
-					               (Core.vessel.mainBody.Radius * Core.vessel.mainBody.Radius);
+					double gravity = (VOIDCore.Constant_G * Core.Vessel.mainBody.Mass) /
+					                 (Core.Vessel.mainBody.Radius * Core.Vessel.mainBody.Radius);
 					double weight = mass * gravity;
 
 					return maxThrust / weight;
@@ -489,92 +486,97 @@
 				""
 			);
 
-		public static readonly VOID_Vector3dValue vesselThrustOffset =
-			new VOID_Vector3dValue(
+		private static Vector3 thrustPos;
+		private static Vector3 thrustDir;
+		private static float thrust;
+
+		private static void thrustOffsetPreForEach(object sender)
+		{
+			thrustPos = Vector3.zero;
+			thrustDir = Vector3.zero;
+			thrust = 0;
+		}
+
+		private static void thrustOffSetPerModule(object sender, VOIDForEachPartModuleArgs args)
+		{
+			PartModule module = args.Data;
+
+			float moduleThrust = 0;
+
+			switch (module.moduleName)
+			{
+				case "ModuleEngines":
+				case "ModuleEnginesFX":
+					break;
+				default:
+					return;
+			}
+
+			if (!module.isEnabled)
+			{
+				return;
+			}
+
+			CenterOfThrustQuery cotQuery = new CenterOfThrustQuery();
+
+			if (module is ModuleEngines)
+			{
+				ModuleEngines engineModule = module as ModuleEngines;
+
+				moduleThrust = engineModule.finalThrust;
+
+				engineModule.OnCenterOfThrustQuery(cotQuery);
+			}
+			else // engine is ModuleEnginesFX
+			{
+				ModuleEnginesFX engineFXModule = module as ModuleEnginesFX;
+
+				moduleThrust = engineFXModule.finalThrust;
+
+				engineFXModule.OnCenterOfThrustQuery(cotQuery);
+			}
+
+			if (moduleThrust != 0d)
+			{
+				cotQuery.thrust = moduleThrust;
+			}
+
+			thrustPos += cotQuery.pos * cotQuery.thrust;
+			thrustDir += cotQuery.dir * cotQuery.thrust;
+			thrust += cotQuery.thrust;
+		}
+
+		public static readonly VOID_Vector3Value vesselThrustOffset =
+			new VOID_Vector3Value(
 				"Thrust Offset",
 				delegate()
 				{
-					if (Core.vessel == null)
-					{
-						return Vector3d.zero;
-					}
-
-					List<PartModule> engineModules = Core.vessel.getModulesOfType<PartModule>();
-
-					Vector3d thrustPos = Vector3d.zero;
-					Vector3d thrustDir = Vector3d.zero;
-					float thrust = 0;
-
-					foreach (PartModule engine in engineModules)
-					{
-						float moduleThrust = 0;
-
-						switch (engine.moduleName)
-						{
-							case "ModuleEngines":
-							case "ModuleEnginesFX":
-								break;
-							default:
-								continue;
-						}
-
-						if (!engine.isEnabled)
-						{
-							continue;
-						}
-
-						CenterOfThrustQuery cotQuery = new CenterOfThrustQuery();
-
-						if (engine is ModuleEngines)
-						{
-							ModuleEngines engineModule = engine as ModuleEngines;
-
-							moduleThrust = engineModule.finalThrust;
-
-							engineModule.OnCenterOfThrustQuery(cotQuery);
-						}
-						else // engine is ModuleEnginesFX
-						{
-							ModuleEnginesFX engineFXModule = engine as ModuleEnginesFX;
-
-							moduleThrust = engineFXModule.finalThrust;
-
-							engineFXModule.OnCenterOfThrustQuery(cotQuery);
-						}
-
-						if (moduleThrust != 0d)
-						{
-							cotQuery.thrust = moduleThrust;
-						}
-
-						thrustPos += cotQuery.pos * cotQuery.thrust;
-						thrustDir += cotQuery.dir * cotQuery.thrust;
-						thrust += cotQuery.thrust;
-					}
+					Vector3 pos = thrustPos;
+					Vector3 dir = thrustDir;
 
 					if (thrust != 0)
 					{
-						thrustPos /= thrust;
-						thrustDir /= thrust;
-					}
-
-					Transform vesselTransform = Core.vessel.transform;
-
-					thrustPos = vesselTransform.InverseTransformPoint(thrustPos);
-					thrustDir = vesselTransform.InverseTransformDirection(thrustDir);
-
-					Vector3d thrustOffset = VectorTools.PointDistanceToLine(
-						                      thrustPos, thrustDir.normalized, Core.vessel.findLocalCenterOfMass());
-
-					Tools.PostDebugMessage(typeof(VOID_Data), "vesselThrustOffset:\n" +
-						"\tthrustPos: {0}\n" +
-						"\tthrustDir: {1}\n" +
-						"\tthrustOffset: {2}\n" +
-						"\tvessel.CoM: {3}",
-						thrustPos,
-						thrustDir.normalized,
+						pos /= thrust;
+						dir /= thrust;
+					}
+
+					Transform vesselTransform = Core.Vessel.transform;
+
+					pos = vesselTransform.InverseTransformPoint(pos);
+					dir = vesselTransform.InverseTransformDirection(dir);
+
+					Vector3 thrustOffset = VectorTools.PointDistanceToLine(
+						pos, dir.normalized, Core.Vessel.findLocalCenterOfMass());
+
+					Logging.PostDebugMessage(typeof(VOID_Data), "vesselThrustOffset:\n" +
+					"\tthrustPos: {0}\n" +
+					"\tthrustDir: {1}\n" +
+					"\tthrustOffset: {2}\n" +
+					"\tvessel.CoM: {3}",
+						pos,
+						dir.normalized,
 						thrustOffset,
-						Core.vessel.findWorldCenterOfMass()
+						Core.Vessel.findWorldCenterOfMass()
 					);
 
 					return thrustOffset;
@@ -586,84 +588,109 @@
 
 		#region Air Breathing
 
+		private static double airFlowCurrent;
+		private static double airFlowRequired;
+		private static string intakeAirString;
+
+		private static void intakeAirPreForEach(object sender)
+		{
+			airFlowCurrent = 0d;
+			airFlowRequired = 0d;
+			intakeAirString = string.Empty;
+		}
+
+		private static void intakeAirForEachModule(object sender, VOIDForEachPartModuleArgs args)
+		{
+			PartModule module = args.Data;
+			List<Propellant> propellantList = null;
+
+			if (!module.part.enabled)
+			{
+				return;
+			}
+
+			if (module is ModuleEngines)
+			{
+				propellantList = ((ModuleEngines)module).propellants;
+			}
+			else if (module is ModuleEnginesFX)
+			{
+				propellantList = ((ModuleEnginesFX)module).propellants;
+			}
+			else if (module is ModuleResourceIntake)
+			{
+				ModuleResourceIntake intakeModule = (ModuleResourceIntake)module;
+
+				if (intakeModule.resourceName == "IntakeAir")
+				{
+					airFlowCurrent += intakeModule.airFlow;
+				}
+			}
+
+			if (propellantList != null)
+			{
+				Propellant propellant;
+				for (int propIdx = 0; propIdx < propellantList.Count; propIdx++)
+				{
+					propellant = propellantList[propIdx];
+
+					if (propellant.name == "IntakeAir")
+					{
+						airFlowRequired += propellant.currentRequirement / TimeWarp.fixedDeltaTime;
+						break;
+					}
+				}
+			}
+		}
+
+		private static void intakeAirPostForEach(object sender)
+		{
+			if (airFlowCurrent == 0 && airFlowRequired == 0)
+			{
+				intakeAirString = "N/A";
+			}
+			else
+			{
+				intakeAirString = string.Format("{0:F3} / {1:F3}", airFlowCurrent, airFlowRequired);
+			}
+		}
+
 		public static readonly VOID_StrValue intakeAirStatus =
 			new VOID_StrValue(
 				"Intake Air (Curr / Req)",
 				delegate()
 				{
-					double currentAmount;
-					double currentRequirement;
-
-					currentAmount = 0d;
-					currentRequirement = 0d;
-
-					foreach (Part part in Core.vessel.Parts)
-					{
-						if (part.enabled)
-						{
-							ModuleEngines engineModule;
-							ModuleEnginesFX enginesFXModule;
-							List<Propellant> propellantList = null;
-
-							if (part.tryGetFirstModuleOfType<ModuleEngines>(out engineModule))
-							{
-								propellantList = engineModule.propellants;
-							}
-							else if (part.tryGetFirstModuleOfType<ModuleEnginesFX>(out enginesFXModule))
-								{
-									propellantList = enginesFXModule.propellants;
-								}
-
-							if (propellantList != null)
-							{
-								foreach (Propellant propellant in propellantList)
-								{
-									if (propellant.name == "IntakeAir")
-									{
-										currentRequirement += propellant.currentRequirement / TimeWarp.fixedDeltaTime;
-										break;
-									}
-								}
-							}
-						}
-
-						ModuleResourceIntake intakeModule;
-
-						if (part.enabled && part.tryGetFirstModuleOfType<ModuleResourceIntake>(out intakeModule))
-						{
-							if (intakeModule.resourceName == "IntakeAir")
-							{
-								currentAmount += intakeModule.airFlow;
-							}
-						}
-					}
-
-					if (currentAmount == 0 && currentRequirement == 0)
-					{
-						return "N/A";
-					}
-
-					return string.Format("{0:F3} / {1:F3}", currentAmount, currentRequirement);
+					return intakeAirString;
 				}
 			);
 
 		#endregion
 
 		#region Crew
+
+		private static int crewCount;
+		private static int crewCapacity;
+
+		private static void crewCountPreForEach(object sender)
+		{
+			crewCount = 0;
+			crewCapacity = 0;
+		}
+
+		private static void crewCountPerPart(object sender, VOIDForEachPartArgs args)
+		{
+			Part part = args.Data;
+
+			crewCount += part.protoModuleCrew.Count;
+			crewCapacity += part.CrewCapacity;
+		}
 
 		public static readonly VOID_IntValue vesselCrewCount =
 			new VOID_IntValue(
 				"Crew Onboard",
 				delegate()
 				{
-					if (Core.vessel != null)
-					{
-						return Core.vessel.GetCrewCount();
-					}
-					else
-					{
-						return 0;
-					}
+					return crewCount;
 				},
 				""
 			);
@@ -673,14 +700,7 @@
 				"Crew Capacity",
 				delegate()
 				{
-					if (Core.vessel != null)
-					{
-						return Core.vessel.GetCrewCapacity();
-					}
-					else
-					{
-						return 0;
-					}
+					return crewCapacity;
 				},
 				""
 			);
@@ -700,46 +720,90 @@
 				delegate()
 				{
 
-					if (Core.vessel == null ||
-					  Planetarium.fetch == null ||
-					  Core.vessel.mainBody != Planetarium.fetch.Home)
-					{
-						return double.NaN;
-					}
-
-					double vesselLongitude = Core.vessel.longitude * Math.PI / 180d;
-					double vesselLatitude = Core.vessel.latitude * Math.PI / 180d;
-
-					double diffLon = vesselLongitude - kscLongitude;
-					double diffLat = vesselLatitude - kscLatitude;
-
-					double sinHalfDiffLat = Math.Sin(diffLat / 2d);
-					double sinHalfDiffLon = Math.Sin(diffLon / 2d);
-
-					double cosVesselLon = Math.Cos(vesselLongitude);
-					double cosKSCLon = Math.Cos(kscLongitude);
-
-					double haversine =
-						sinHalfDiffLat * sinHalfDiffLat +
-						cosVesselLon * cosKSCLon * sinHalfDiffLon * sinHalfDiffLon;
-
-					double arc = 2d * Math.Atan2(Math.Sqrt(haversine), Math.Sqrt(1d - haversine));
-
-					return Core.vessel.mainBody.Radius * arc;
+					if (Core.Vessel == null ||
+					    Planetarium.fetch == null ||
+					    Core.Vessel.mainBody != Planetarium.fetch.Home)
+					{
+						return double.NaN;
+					}
+
+					double vesselLongitude = Core.Vessel.longitude * Math.PI / 180d;
+					double vesselLatitude = Core.Vessel.latitude * Math.PI / 180d;
+
+					double diffLon = Math.Abs(vesselLongitude - kscLongitude);
+
+					double cosVesselLatitude = Math.Cos(vesselLatitude);
+					double sinDiffLon = Math.Sin(diffLon);
+
+					double term1 = cosVesselLatitude * sinDiffLon;
+
+					double cosKSCLatitude = Math.Cos(kscLatitude);
+					double sinVesselLatitude = Math.Sin(vesselLatitude);
+					double sinKSCLatitude = Math.Sin(kscLatitude);
+					double cosDiffLon = Math.Cos(diffLon);
+
+					double term2 = cosKSCLatitude * sinVesselLatitude - sinKSCLatitude * cosVesselLatitude * cosDiffLon;
+
+					double term3 = sinKSCLatitude * sinVesselLatitude + cosKSCLatitude * cosVesselLatitude * cosDiffLon;
+
+					double arc = Math.Atan2(Math.Sqrt(term1 * term1 + term2 * term2), term3);
+
+					return arc * Core.Vessel.mainBody.Radius;
 				},
 				"m"
 			);
 
-		public static readonly VOID_StrValue surfLatitude =
+		public static readonly VOID_StrValue surfLatitudeString =
 			new VOID_StrValue(
 				"Latitude",
-				new Func<string>(() => VOID_Tools.GetLatitudeString(Core.vessel))
-			);
-
-		public static readonly VOID_StrValue surfLongitude =
+				new Func<string>(() => VOID_Tools.GetLatitudeString(Core.Vessel))
+			);
+
+		public static readonly VOID_DoubleValue surfLatitude =
+			new VOID_DoubleValue(
+				"Latitude",
+				delegate()
+				{
+					if (CoreInitialized && Core.Vessel != null)
+					{
+						return Core.Vessel.latitude;
+					}
+					return double.NaN;
+				},
+				"°"
+			);
+
+		public static readonly VOID_StrValue surfLongitudeString =
 			new VOID_StrValue(
 				"Longitude",
-				new Func<string>(() => VOID_Tools.GetLongitudeString(Core.vessel))
+				new Func<string>(() => VOID_Tools.GetLongitudeString(Core.Vessel))
+			);
+
+		public static readonly VOID_DoubleValue surfLongitude =
+			new VOID_DoubleValue(
+				"Longitude",
+				delegate()
+				{
+					if (CoreInitialized && Core.Vessel != null)
+					{
+						double longitude = Core.Vessel.longitude;
+
+						longitude = VOID_Tools.FixDegreeDomain(longitude);
+
+						if (longitude < -180d)
+						{
+							longitude += 360d;
+						}
+						if (longitude >= 180)
+						{
+							longitude -= 360d;
+						}
+
+						return longitude;
+					}
+					return double.NaN;
+				},
+				"°"
 			);
 
 		public static readonly VOID_DoubleValue trueAltitude =
@@ -747,11 +811,11 @@
 				"Altitude (true)",
 				delegate()
 				{
-					double alt_true = Core.vessel.orbit.altitude - Core.vessel.terrainAltitude;
+					double alt_true = Core.Vessel.orbit.altitude - Core.Vessel.terrainAltitude;
 					// HACK: This assumes that on worlds with oceans, all water is fixed at 0 m,
 					// and water covers the whole surface at 0 m.
-					if (Core.vessel.terrainAltitude < 0 && Core.vessel.mainBody.ocean)
-						alt_true = Core.vessel.orbit.altitude;
+					if (Core.Vessel.terrainAltitude < 0 && Core.Vessel.mainBody.ocean)
+						alt_true = Core.Vessel.orbit.altitude;
 					return alt_true;
 				},
 				"m"
@@ -764,28 +828,31 @@
 		public static readonly VOID_DoubleValue geeForce =
 			new VOID_DoubleValue(
 				"G-force",
-				new Func<double>(() => Core.vessel.geeForce),
+				new Func<double>(() => Core.Vessel.geeForce),
 				"gees"
 			);
 
 		public static readonly VOID_DoubleValue horzVelocity =
 			new VOID_DoubleValue(
 				"Horizontal speed",
-				new Func<double>(() => Core.vessel.horizontalSrfSpeed),
+				delegate
+				{
+					return Core.Vessel.horizontalSrfSpeed;
+				},
 				"m/s"
 			);
 
 		public static readonly VOID_DoubleValue surfVelocity =
 			new VOID_DoubleValue(
 				"Surface velocity",
-				new Func<double>(() => Core.vessel.srf_velocity.magnitude),
+				new Func<double>(() => Core.Vessel.srf_velocity.magnitude),
 				"m/s"
 			);
 
 		public static readonly VOID_DoubleValue vertVelocity =
 			new VOID_DoubleValue(
 				"Vertical speed",
-				new Func<double>(() => Core.vessel.verticalSpeed),
+				new Func<double>(() => Core.Vessel.verticalSpeed),
 				"m/s"
 			);
 
@@ -801,9 +868,9 @@
 				"Angular Velocity",
 				delegate()
 				{
-					if (Core.vessel != null)
-					{
-						return Core.vessel.angularVelocity.magnitude;
+					if (Core.Vessel != null)
+					{
+						return Core.Vessel.angularVelocity.magnitude;
 					}
 					else
 					{
@@ -821,14 +888,14 @@
 		{
 			get
 			{
-				if (Core.vessel == null ||
-				    Core.vessel.patchedConicSolver == null ||
-				    Core.vessel.patchedConicSolver.maneuverNodes == null)
+				if (Core.Vessel == null ||
+				    Core.Vessel.patchedConicSolver == null ||
+				    Core.Vessel.patchedConicSolver.maneuverNodes == null)
 				{
 					return 0;
 				}
 
-				return Core.vessel.patchedConicSolver.maneuverNodes.Count;
+				return Core.Vessel.patchedConicSolver.maneuverNodes.Count;
 			}
 		}
 
@@ -842,7 +909,7 @@
 						return "N/A";
 					}
 
-					ManeuverNode node = Core.vessel.patchedConicSolver.maneuverNodes[0];
+					ManeuverNode node = Core.Vessel.patchedConicSolver.maneuverNodes[0];
 
 					if ((node.UT - Planetarium.GetUniversalTime()) < 0)
 					{
@@ -884,7 +951,7 @@
 						return "N/A";
 					}
 
-					ManeuverNode node = Core.vessel.patchedConicSolver.maneuverNodes[0];
+					ManeuverNode node = Core.Vessel.patchedConicSolver.maneuverNodes[0];
 
 					if ((node.UT - Planetarium.GetUniversalTime()) < 0)
 					{
@@ -923,7 +990,7 @@
 				{
 					if (upcomingManeuverNodes > 0)
 					{
-						return Core.vessel.patchedConicSolver.maneuverNodes[0].DeltaV.magnitude;
+						return Core.Vessel.patchedConicSolver.maneuverNodes[0].DeltaV.magnitude;
 					}
 					else
 					{
@@ -940,7 +1007,7 @@
 				{
 					if (upcomingManeuverNodes > 0)
 					{
-						return Core.vessel.patchedConicSolver.maneuverNodes[0].GetBurnVector(Core.vessel.orbit).magnitude;
+						return Core.Vessel.patchedConicSolver.maneuverNodes[0].GetBurnVector(Core.Vessel.orbit).magnitude;
 					}
 					else
 					{
@@ -955,14 +1022,12 @@
 				"Total Burn Time",
 				delegate()
 				{
-					if (Core.LastStage == null || currManeuverDeltaV.Value == double.NaN)
-					{
-						return double.NaN;
-					}
-
-					double stageThrust = stageNominalThrust;
-
-					return burnTime(currManeuverDeltaV.Value, totalMass, stageMassFlow, stageThrust);
+					if (currManeuverDeltaV.Value == double.NaN)
+					{
+						return double.NaN;
+					}
+
+					return realVesselBurnTime(currManeuverDeltaV.Value);
 				},
 				"s"
 			);
@@ -972,14 +1037,12 @@
 				"Burn Time Remaining",
 				delegate()
 				{
-					if (Core.LastStage == null || currManeuverDVRemaining == double.NaN)
-					{
-						return double.NaN;
-					}
-
-					double stageThrust = stageNominalThrust;
-
-					return burnTime(currManeuverDVRemaining, totalMass, stageMassFlow, stageThrust);
+					if (currManeuverDVRemaining.Value == double.NaN)
+					{
+						return double.NaN;
+					}
+
+					return realVesselBurnTime(currManeuverDVRemaining.Value);
 				},
 				"s"
 			);
@@ -989,14 +1052,12 @@
 				"Half Burn Time",
 				delegate()
 				{
-					if (Core.LastStage == null || currManeuverDeltaV.Value == double.NaN)
-					{
-						return double.NaN;
-					}
-
-					double stageThrust = stageNominalThrust;
-
-					return burnTime(currManeuverDeltaV.Value / 2d, totalMass, stageMassFlow, stageThrust);
+					if (currManeuverDeltaV.Value == double.NaN)
+					{
+						return double.NaN;
+					}
+
+					return realVesselBurnTime(currManeuverDeltaV.Value / 2d);
 				},
 				"s"
 			);
@@ -1008,7 +1069,7 @@
 				{
 					if (upcomingManeuverNodes > 1)
 					{
-						return Core.vessel.patchedConicSolver.maneuverNodes[1].DeltaV.magnitude;
+						return Core.Vessel.patchedConicSolver.maneuverNodes[1].DeltaV.magnitude;
 					}
 					else
 					{
@@ -1027,58 +1088,58 @@
 				VOID_Localization.void_primary,
 				delegate()
 				{
-					if (Core.vessel == null)
+					if (Core.Vessel == null)
 					{
 						return string.Empty;
 					}
-					return Core.vessel.mainBody.name;
+					return Core.Vessel.mainBody.name;
 				}
 			);
 
 		public static readonly VOID_DoubleValue orbitAltitude =
 			new VOID_DoubleValue(
 				"Altitude (ASL)",
-				new Func<double>(() => Core.vessel.orbit.altitude),
+				new Func<double>(() => Core.Vessel.orbit.altitude),
 				"m"
 			);
 
 		public static readonly VOID_DoubleValue orbitVelocity =
 			new VOID_DoubleValue(
 				VOID_Localization.void_velocity,
-				new Func<double>(() => Core.vessel.orbit.vel.magnitude),
+				new Func<double>(() => Core.Vessel.orbit.vel.magnitude),
 				"m/s"
 			);
 
 		public static readonly VOID_DoubleValue orbitApoAlt =
 			new VOID_DoubleValue(
 				VOID_Localization.void_apoapsis,
-				new Func<double>(() => Core.vessel.orbit.ApA),
+				new Func<double>(() => Core.Vessel.orbit.ApA),
 				"m"
 			);
 
 		public static readonly VOID_DoubleValue oribtPeriAlt =
 			new VOID_DoubleValue(
 				VOID_Localization.void_periapsis,
-				new Func<double>(() => Core.vessel.orbit.PeA),
+				new Func<double>(() => Core.Vessel.orbit.PeA),
 				"m"
 			);
 
 		public static readonly VOID_StrValue timeToApo =
 			new VOID_StrValue(
 				"Time to Apoapsis",
-				new Func<string>(() => VOID_Tools.FormatInterval(Core.vessel.orbit.timeToAp))
+				new Func<string>(() => VOID_Tools.FormatInterval(Core.Vessel.orbit.timeToAp))
 			);
 
 		public static readonly VOID_StrValue timeToPeri =
 			new VOID_StrValue(
 				"Time to Periapsis",
-				new Func<string>(() => VOID_Tools.FormatInterval(Core.vessel.orbit.timeToPe))
+				new Func<string>(() => VOID_Tools.FormatInterval(Core.Vessel.orbit.timeToPe))
 			);
 
 		public static readonly VOID_DoubleValue orbitInclination =
 			new VOID_DoubleValue(
 				"Inclination",
-				new Func<double>(() => Core.vessel.orbit.inclination),
+				new Func<double>(() => Core.Vessel.orbit.inclination),
 				"°"
 			);
 
@@ -1087,9 +1148,9 @@
 				"Gravity",
 				delegate()
 				{
-					double orbitRadius = Core.vessel.mainBody.Radius +
-					                   Core.vessel.mainBody.GetAltitude(Core.vessel.findWorldCenterOfMass());
-					return (VOIDCore.Constant_G * Core.vessel.mainBody.Mass) /
+					double orbitRadius = Core.Vessel.mainBody.Radius +
+					                     Core.Vessel.mainBody.GetAltitude(Core.Vessel.findWorldCenterOfMass());
+					return (VOIDCore.Constant_G * Core.Vessel.mainBody.Mass) /
 					(orbitRadius * orbitRadius);
 				},
 				"m/s²"
@@ -1098,55 +1159,55 @@
 		public static readonly VOID_StrValue orbitPeriod =
 			new VOID_StrValue(
 				"Period",
-				new Func<string>(() => VOID_Tools.FormatInterval(Core.vessel.orbit.period))
+				new Func<string>(() => VOID_Tools.FormatInterval(Core.Vessel.orbit.period))
 			);
 
 		public static readonly VOID_DoubleValue semiMajorAxis =
 			new VOID_DoubleValue(
 				"Semi-Major Axis",
-				new Func<double>(() => Core.vessel.orbit.semiMajorAxis),
+				new Func<double>(() => Core.Vessel.orbit.semiMajorAxis),
 				"m"
 			);
 
 		public static readonly VOID_DoubleValue eccentricity =
 			new VOID_DoubleValue(
 				"Eccentricity",
-				new Func<double>(() => Core.vessel.orbit.eccentricity),
+				new Func<double>(() => Core.Vessel.orbit.eccentricity),
 				""
 			);
 
 		public static readonly VOID_DoubleValue meanAnomaly =
 			new VOID_DoubleValue(
 				"Mean Anomaly",
-				new Func<double>(() => Core.vessel.orbit.meanAnomaly * 180d / Math.PI),
+				new Func<double>(() => Core.Vessel.orbit.meanAnomaly * 180d / Math.PI),
 				"°"
 			);
 
 		public static readonly VOID_DoubleValue trueAnomaly = 
 			new VOID_DoubleValue(
 				"True Anomaly",
-				new Func<double>(() => Core.vessel.orbit.trueAnomaly),
+				new Func<double>(() => Core.Vessel.orbit.trueAnomaly * 180d / Math.PI),
 				"°"
 			);
 
 		public static readonly VOID_DoubleValue eccAnomaly =
 			new VOID_DoubleValue(
 				"Eccentric Anomaly",
-				new Func<double>(() => Core.vessel.orbit.eccentricAnomaly * 180d / Math.PI),
+				new Func<double>(() => Core.Vessel.orbit.eccentricAnomaly * 180d / Math.PI),
 				"°"
 			);
 
 		public static readonly VOID_DoubleValue longitudeAscNode =
 			new VOID_DoubleValue(
 				"Long. Ascending Node",
-				new Func<double>(() => Core.vessel.orbit.LAN),
+				new Func<double>(() => Core.Vessel.orbit.LAN),
 				"°"
 			);
 
 		public static readonly VOID_DoubleValue argumentPeriapsis =
 			new VOID_DoubleValue(
 				"Argument of Periapsis",
-				new Func<double>(() => Core.vessel.orbit.argumentOfPeriapsis),
+				new Func<double>(() => Core.Vessel.orbit.argumentOfPeriapsis),
 				"°"
 			);
 
@@ -1156,16 +1217,16 @@
 				delegate()
 				{
 					double trueAnomalyAscNode = 360d - argumentPeriapsis;
-					double dTAscNode = Core.vessel.orbit.GetDTforTrueAnomaly(
-						trueAnomalyAscNode * Mathf.Deg2Rad,
-						Core.vessel.orbit.period
-					);
-
-					dTAscNode %= Core.vessel.orbit.period;
+					double dTAscNode = Core.Vessel.orbit.GetDTforTrueAnomaly(
+						                   trueAnomalyAscNode * Mathf.Deg2Rad,
+						                   Core.Vessel.orbit.period
+					                   );
+
+					dTAscNode %= Core.Vessel.orbit.period;
 
 					if (dTAscNode < 0d)
 					{
-						dTAscNode += Core.vessel.orbit.period;
+						dTAscNode += Core.Vessel.orbit.period;
 					}
 
 					return VOID_Tools.FormatInterval(dTAscNode);
@@ -1178,16 +1239,16 @@
 				delegate()
 				{
 					double trueAnomalyAscNode = 180d - argumentPeriapsis;
-					double dTDescNode = Core.vessel.orbit.GetDTforTrueAnomaly(
-						trueAnomalyAscNode * Mathf.Deg2Rad,
-						Core.vessel.orbit.period
-					);
-
-					dTDescNode %= Core.vessel.orbit.period;
+					double dTDescNode = Core.Vessel.orbit.GetDTforTrueAnomaly(
+						                    trueAnomalyAscNode * Mathf.Deg2Rad,
+						                    Core.Vessel.orbit.period
+					                    );
+
+					dTDescNode %= Core.Vessel.orbit.period;
 
 					if (dTDescNode < 0d)
 					{
-						dTDescNode += Core.vessel.orbit.period;
+						dTDescNode += Core.Vessel.orbit.period;
 					}
 
 					return VOID_Tools.FormatInterval(dTDescNode);
@@ -1198,7 +1259,7 @@
 			new VOID_DoubleValue(
 				"Local Sidereal Longitude",
 				new Func<double>(() => VOID_Tools.FixDegreeDomain(
-						Core.vessel.longitude + Core.vessel.orbit.referenceBody.rotationAngle)),
+					Core.Vessel.longitude + Core.Vessel.orbit.referenceBody.rotationAngle)),
 				"°"
 			);
 
@@ -1209,7 +1270,7 @@
 		public static readonly VOID_StrValue expSituation =
 			new VOID_StrValue(
 				"Situation",
-				new Func<string>(() => Core.vessel.GetExperimentSituation().HumanString())
+				new Func<string>(() => Core.Vessel.GetExperimentSituation().HumanString())
 			);
 
 		public static readonly VOID_StrValue currBiome =
@@ -1217,13 +1278,13 @@
 				"Biome",
 				delegate()
 				{
-					if (Core.vessel.landedAt == string.Empty)
-					{
-						return VOID_Tools.GetBiome(Core.vessel).name;
+					if (Core.Vessel.landedAt == string.Empty)
+					{
+						return VOID_Tools.GetBiome(Core.Vessel).name;
 					}
 					else
 					{
-						return Core.vessel.landedAt;
+						return Core.Vessel.landedAt;
 					}
 				}
 			);
@@ -1235,7 +1296,7 @@
 		public static readonly VOID_DoubleValue terrainElevation =
 			new VOID_DoubleValue(
 				"Terrain elevation",
-				new Func<double>(() => Core.vessel.terrainAltitude),
+				new Func<double>(() => Core.Vessel.terrainAltitude),
 				"m"
 			);
 
@@ -1243,11 +1304,11 @@
 
 		private static double burnTime(double deltaV, double initialMass, double massFlow, double thrust)
 		{
-			Tools.PostDebugMessage(typeof(VOID_Data), "calculating burnTime from:\n" +
-				"\tdeltaV: {0}\n" +
-				"\tinitialMass: {1}\n" +
-				"\tmassFlow: {2}\n" +
-				"\tthrust: {3}\n",
+			Logging.PostDebugMessage(typeof(VOID_Data), "calculating burnTime from:\n" +
+			"\tdeltaV: {0}\n" +
+			"\tinitialMass: {1}\n" +
+			"\tmassFlow: {2}\n" +
+			"\tthrust: {3}\n",
 				deltaV,
 				initialMass,
 				massFlow,
@@ -1255,6 +1316,88 @@
 			);
 			return initialMass / massFlow * (1d - Math.Exp(-deltaV * massFlow / thrust));
 		}
+
+		private static double dVfromBurnTime(double time, double initialMass, double massFlow, double thrust)
+		{
+			return -thrust / massFlow * Math.Log(1d - time * massFlow / initialMass);
+		}
+
+		private static double realVesselBurnTime(double deltaV)
+		{
+			if (Core.Stages == null || Core.Stages.Length < 1)
+			{
+				return double.NaN;
+			}
+
+			double burntime = 0d;
+			double dVRemaining = deltaV;
+
+			int stageIdx = Core.Stages.Length - 1;
+
+			while (dVRemaining > double.Epsilon)
+			{
+				if (stageIdx < 0)
+				{
+					return double.PositiveInfinity;
+				}
+
+				Stage stage = Core.Stages[stageIdx];
+
+				if (stage.deltaV > 0)
+				{
+					double stageDVUsed = Math.Min(stage.deltaV, dVRemaining);
+
+					burntime += burnTime(stageDVUsed, stage.totalMass, stage.MassFlow(), stage.NominalThrust());
+					dVRemaining -= stageDVUsed;
+				}
+
+				stageIdx--;
+			}
+
+			return burntime;
+		}
+
+		private static void onFlightModulesLoaded(object sender)
+		{
+			if (sender is VOIDCore_Flight)
+			{
+				VOIDCore_Flight flightCore = sender as VOIDCore_Flight;
+
+				flightCore.onPreForEach += thrustOffsetPreForEach;
+				flightCore.onForEachModule += thrustOffSetPerModule;
+
+				flightCore.onPreForEach += intakeAirPreForEach;
+				flightCore.onForEachModule += intakeAirForEachModule;
+				flightCore.onPostForEach += intakeAirPostForEach;
+
+				flightCore.onPreForEach += crewCountPreForEach;
+				flightCore.onForEachPart += crewCountPerPart;
+			}
+		}
+
+		private static void onFlightModulesDestroyed(object sender)
+		{
+			if (sender is VOIDCore_Flight)
+			{
+				VOIDCore_Flight flightCore = sender as VOIDCore_Flight;
+
+				flightCore.onPreForEach -= thrustOffsetPreForEach;
+				flightCore.onForEachModule -= thrustOffSetPerModule;
+
+				flightCore.onPreForEach -= intakeAirPreForEach;
+				flightCore.onForEachModule -= intakeAirForEachModule;
+				flightCore.onPostForEach -= intakeAirPostForEach;
+
+				flightCore.onPreForEach -= crewCountPreForEach;
+				flightCore.onForEachPart -= crewCountPerPart;
+			}
+		}
+
+		static VOID_Data()
+		{
+			VOIDCore_Flight.onModulesLoaded += onFlightModulesLoaded;
+			VOIDCore_Flight.onModulesDestroyed += onFlightModulesDestroyed;
+		}
 	}
 }
 

--- a/VOID_DataLogger.cs
+++ b/VOID_DataLogger.cs
@@ -32,6 +32,9 @@
 using System.IO;
 using System.Text;
 using ToadicusTools;
+using ToadicusTools.DebugTools;
+using ToadicusTools.GUIUtils;
+using ToadicusTools.Text;
 using UnityEngine;
 
 namespace VOID
@@ -103,14 +106,11 @@
 			{
 				if (this._fileName == null || this._fileName == string.Empty)
 				{
-					this._fileName = KSP.IO.IOUtils.GetFilePathFor(
-						typeof(VOIDCore),
-						string.Format(
-							"{0}_{1}",
-							this.vessel.vesselName,
-							"data.csv"
-						),
-						null
+					this._fileName = string.Format(
+						"{0}/{1}_{2}",
+						this.core.SaveGamePath,
+						this.Vessel.vesselName,
+						"data.csv"
 					);
 				}
 
@@ -124,44 +124,46 @@
 			{
 				if (this._outputFile == null)
 				{
-					Tools.DebugLogger logger = Tools.DebugLogger.New(this);
-					logger.AppendFormat("Initializing output file '{0}' with mode ", this.fileName);
-
-					if (File.Exists(this.fileName))
+					using (PooledDebugLogger logger = PooledDebugLogger.New(this))
 					{
-						logger.Append("append");
-						this._outputFile = new FileStream(
-							this.fileName,
-							FileMode.Append,
-							FileAccess.Write,
-							FileShare.Read,
-							512,
-							true
-						);
+						logger.AppendFormat("Initializing output file '{0}' with mode ", this.fileName);
+
+						if (File.Exists(this.fileName))
+						{
+							logger.Append("append");
+							this._outputFile = new FileStream(
+								this.fileName,
+								FileMode.Append,
+								FileAccess.Write,
+								FileShare.Read,
+								512,
+								true
+							);
+						}
+						else
+						{
+							logger.Append("create");
+							this._outputFile = new FileStream(
+								this.fileName,
+								FileMode.Create,
+								FileAccess.Write,
+								FileShare.Read,
+								512,
+								true
+							);
+
+							byte[] byteOrderMark = utf8Encoding.GetPreamble();
+
+							logger.Append(" and writing preamble");
+							this._outputFile.Write(byteOrderMark, 0, byteOrderMark.Length);
+						}
+
+						logger.Append('.');
+
+						logger.AppendFormat("  File is {0}opened asynchronously.", this._outputFile.IsAsync ? "" : "not ");
+
+						logger.Print();
 					}
-					else
-					{
-						logger.Append("create");
-						this._outputFile = new FileStream(
-							this.fileName,
-							FileMode.Create,
-							FileAccess.Write,
-							FileShare.Read,
-							512,
-							true
-						);
-
-						byte[] byteOrderMark = utf8Encoding.GetPreamble();
-
-						logger.Append(" and writing preamble");
-						this._outputFile.Write(byteOrderMark, 0, byteOrderMark.Length);
-					}
-
-					logger.Append('.');
-
-					logger.AppendFormat("  File is {0}opened asynchronously.", this._outputFile.IsAsync ? "" : "not ");
-
-					logger.Print();
 				}
 
 				return this._outputFile;
@@ -197,7 +199,7 @@
 
 			// CSV Logging
 			// from ISA MapSat
-			if (loggingActive && (!waitForLaunch || this.vessel.situation != Vessel.Situations.PRELAUNCH))
+			if (loggingActive && (!waitForLaunch || this.Vessel.situation != Vessel.Situations.PRELAUNCH))
 			{
 				//data logging is on
 				//increment timers
@@ -216,28 +218,29 @@
 
 		public void OnDestroy()
 		{
-			Tools.DebugLogger logger = Tools.DebugLogger.New(this);
-
-			logger.Append("Destroying...");
-
-			this.CloseFileIfOpen();
-
-			logger.Append(" Done.");
-			logger.Print(false);
+			using (PooledDebugLogger logger = PooledDebugLogger.New(this))
+			{
+				logger.Append("Destroying...");
+
+				this.CloseFileIfOpen();
+
+				logger.Append(" Done.");
+				logger.Print(false);
+			}
 		}
 
 		#endregion
 
 		#region VOID_Module Overrides
 
-		public override void LoadConfig()
-		{
-			base.LoadConfig();
+		public override void LoadConfig(KSP.IO.PluginConfiguration config)
+		{
+			base.LoadConfig(config);
 
 			this.logIntervalStr = this.logInterval.value.ToString("#.0##");
 		}
 
-		public override void ModuleWindow(int _)
+		public override void ModuleWindow(int id)
 		{
 			GUILayout.BeginVertical();
 
@@ -258,14 +261,14 @@
 				activeLabelStyle = VOID_Styles.labelGreen;
 			}
 
-			this.loggingActive = GUITools.Toggle(
+			this.loggingActive = Layout.Toggle(
 				loggingActive,
 				string.Format("Data logging: {0}", activeLabelText),
 				null,
 				activeLabelStyle
 			);
 
-			this.waitForLaunch.value = GUITools.Toggle(
+			this.waitForLaunch.value = Layout.Toggle(
 				this.waitForLaunch,
 				"Wait for launch"
 			);
@@ -288,7 +291,7 @@
 
 			GUILayout.EndVertical();
 
-			GUI.DragWindow();
+			base.ModuleWindow(id);
 		}
 
 		#endregion
@@ -305,99 +308,125 @@
 			//called if logging is on and interval has passed
 			//writes one line to the csvList
 
-			StringBuilder line = new StringBuilder();
-
-			if (firstWrite)
-			{
-				firstWrite = false;
-				line.Append(
-					"\"Kerbin Universal Time (s)\"," +
-					"\"Mission Elapsed Time (s)\t\"," +
-					"\"Altitude ASL (m)\"," +
-					"\"Altitude above terrain (m)\"," +
-					"\"Surface Latitude (°)\"," +
-					"\"Surface Longitude (°)\"," +
-					"\"Orbital Velocity (m/s)\"," +
-					"\"Surface Velocity (m/s)\"," +
-					"\"Vertical Speed (m/s)\"," +
-					"\"Horizontal Speed (m/s)\"," +
-					"\"Gee Force (gees)\"," +
-					"\"Temperature (°C)\"," +
-					"\"Gravity (m/s²)\"," +
-					"\"Atmosphere Density (g/m³)\"," +
-					"\"Downrange Distance  (m)\"," +
-					"\n"
-				);
-			}
-
-			// Universal time
-			line.Append(Planetarium.GetUniversalTime().ToString("F2"));
-			line.Append(',');
-
-			//Mission time
-			line.Append(vessel.missionTime.ToString("F3"));
-			line.Append(',');
-
-			//Altitude ASL
-			line.Append(VOID_Data.orbitAltitude.Value.ToString("F3"));
-			line.Append(',');
-
-			//Altitude (true)
-			line.Append(VOID_Data.trueAltitude.Value.ToString("F3"));
-			line.Append(',');
-
-			// Surface Latitude
-			line.Append('"');
-			line.Append(VOID_Data.surfLatitude.Value);
-			line.Append('"');
-			line.Append(',');
-
-			// Surface Longitude
-			line.Append('"');
-			line.Append(VOID_Data.surfLongitude.Value);
-			line.Append('"');
-			line.Append(',');
-
-			//Orbital velocity
-			line.Append(VOID_Data.orbitVelocity.Value.ToString("F3"));
-			line.Append(',');
-
-			//surface velocity
-			line.Append(VOID_Data.surfVelocity.Value.ToString("F3"));
-			line.Append(',');
-
-			//vertical speed
-			line.Append(VOID_Data.vertVelocity.Value.ToString("F3"));
-			line.Append(',');
-
-			//horizontal speed
-			line.Append(VOID_Data.horzVelocity.Value.ToString("F3"));
-			line.Append(',');
-
-			//gee force
-			line.Append(VOID_Data.geeForce.Value.ToString("F3"));
-			line.Append(',');
-
-			//temperature
-			line.Append(VOID_Data.temperature.Value.ToString("F2"));
-			line.Append(',');
-
-			//gravity
-			line.Append(VOID_Data.gravityAccel.Value.ToString("F3"));
-			line.Append(',');
-
-			//atm density
-			line.Append(VOID_Data.atmDensity.Value.ToString("G3"));
-			line.Append(',');
-
-			// Downrange Distance
-			line.Append((VOID_Data.downrangeDistance.Value.ToString("G3")));
-
-			line.Append('\n');
-
-			csvBytes.AddRange(this.utf8Encoding.GetBytes(line.ToString()));
-
-			this.csvCollectTimer = 0f;
+			using (PooledStringBuilder line = PooledStringBuilder.Get())
+			{
+				if (firstWrite)
+				{
+					firstWrite = false;
+					line.Append(
+						"\"Kerbin Universal Time (s)\"," +
+						"\"Mission Elapsed Time (s)\t\"," +
+						"\"Altitude ASL (m)\"," +
+						"\"Altitude above terrain (m)\"," +
+						"\"Surface Latitude (°)\"," +
+						"\"Surface Longitude (°)\"," +
+						"\"Apoapsis Altitude (m)\"," +
+						"\"Periapsis Altitude (m)\"," +
+						"\"Orbital Inclination (°)\"," +
+						"\"Orbital Velocity (m/s)\"," +
+						"\"Surface Velocity (m/s)\"," +
+						"\"Vertical Speed (m/s)\"," +
+						"\"Horizontal Speed (m/s)\"," +
+						"\"Current Thrust (kN)\"," +
+						"\"Gee Force (gees)\"," +
+						"\"Temperature (°C)\"," +
+						"\"Gravity (m/s²)\"," +
+						"\"Atmosphere Density (g/m³)\"," +
+						"\"Downrange Distance  (m)\"," +
+						"\"Main Throttle\"," +
+						"\n"
+					);
+				}
+
+				// Universal time
+				line.Append(Planetarium.GetUniversalTime().ToString("F2"));
+				line.Append(',');
+
+				//Mission time
+				line.Append(Vessel.missionTime.ToString("F3"));
+				line.Append(',');
+
+				//Altitude ASL
+				line.Append(VOID_Data.orbitAltitude.Value.ToString("G9"));
+				line.Append(',');
+
+				//Altitude (true)
+				line.Append(VOID_Data.trueAltitude.Value.ToString("G9"));
+				line.Append(',');
+
+				// Surface Latitude
+				line.Append('"');
+				line.Append(VOID_Data.surfLatitude.Value.ToString("F3"));
+				line.Append('"');
+				line.Append(',');
+
+				// Surface Longitude
+				line.Append('"');
+				line.Append(VOID_Data.surfLongitude.Value.ToString("F3"));
+				line.Append('"');
+				line.Append(',');
+
+				// Apoapsis Altitude
+				line.Append(VOID_Data.orbitApoAlt.Value.ToString("G9"));
+				line.Append(',');
+
+				// Periapsis Altitude
+				line.Append(VOID_Data.oribtPeriAlt.Value.ToString("G9"));
+				line.Append(',');
+
+				// Orbital Inclination
+				line.Append(VOID_Data.orbitInclination.Value.ToString("F2"));
+				line.Append(',');
+
+				//Orbital velocity
+				line.Append(VOID_Data.orbitVelocity.Value.ToString("G9"));
+				line.Append(',');
+
+				//surface velocity
+				line.Append(VOID_Data.surfVelocity.Value.ToString("G9"));
+				line.Append(',');
+
+				//vertical speed
+				line.Append(VOID_Data.vertVelocity.Value.ToString("G9"));
+				line.Append(',');
+
+				//horizontal speed
+				line.Append(VOID_Data.horzVelocity.Value.ToString("G9"));
+				line.Append(',');
+
+				// Current Thrust
+				line.Append(VOID_Data.currThrust.Value.ToString("G9"));
+				line.Append(',');
+
+				//gee force
+				line.Append(VOID_Data.geeForce.Value.ToString("G9"));
+				line.Append(',');
+
+				//temperature
+				line.Append(VOID_Data.temperature.Value.ToString("F3"));
+				line.Append(',');
+
+				//gravity
+				line.Append(VOID_Data.gravityAccel.Value.ToString("G9"));
+				line.Append(',');
+
+				//atm density
+				line.Append(VOID_Data.atmDensity.Value.ToString("G9"));
+				line.Append(',');
+
+				// Downrange Distance
+				line.Append((VOID_Data.downrangeDistance.Value.ToString("G9")));
+				line.Append(',');
+
+				// Main Throttle
+				line.Append(VOID_Data.mainThrottle.Value.ToString("P2"));
+
+				line.Append('\n');
+
+				csvBytes.AddRange(this.utf8Encoding.GetBytes(line.ToString()));
+
+				this.csvCollectTimer = 0f;
+			}
 		}
 
 		#endregion
@@ -406,7 +435,7 @@
 
 		protected void AsyncWriteCallback(IAsyncResult result)
 		{
-			Tools.PostDebugMessage(this, "Got async callback, IsCompleted = {0}", result.IsCompleted);
+			Logging.PostDebugMessage(this, "Got async callback, IsCompleted = {0}", result.IsCompleted);
 
 			this.outputFile.EndWrite(result);
 			this.outstandingWrites--;
@@ -429,31 +458,32 @@
 
 		private void CloseFileIfOpen()
 		{
-			Tools.DebugLogger logger = Tools.DebugLogger.New(this);
-
-			logger.AppendFormat("Cleaning up file {0}...", this.fileName);
-
-			if (this.csvBytes != null && this.csvBytes.Count > 0)
-			{
-				logger.Append(" Writing remaining data...");
-				this.AsyncWriteData();
-			}
-
-			logger.Append(" Waiting for writes to finish.");
-			while (this.outstandingWrites > 0)
-			{
-				logger.Append('.');
-				System.Threading.Thread.Sleep(10);
-			}
-
-			if (this._outputFile != null)
-			{
-				this._outputFile.Close();
-				this._outputFile = null;
-				logger.Append(" File closed.");
-			}
-
-			logger.Print(false);
+			using (PooledDebugLogger logger = PooledDebugLogger.New(this))
+			{
+				logger.AppendFormat("Cleaning up file {0}...", this.fileName);
+
+				if (this.csvBytes != null && this.csvBytes.Count > 0)
+				{
+					logger.Append(" Writing remaining data...");
+					this.AsyncWriteData();
+				}
+
+				logger.Append(" Waiting for writes to finish.");
+				while (this.outstandingWrites > 0)
+				{
+					logger.Append('.');
+					System.Threading.Thread.Sleep(10);
+				}
+
+				if (this._outputFile != null)
+				{
+					this._outputFile.Close();
+					this._outputFile = null;
+					logger.Append(" File closed.");
+				}
+
+				logger.Print(false);
+			}
 		}
 
 		#endregion
@@ -467,10 +497,10 @@
 			this.loggingActive = false;
 			this.firstWrite = true;
 
-			this.waitForLaunch = true;
-
-			this.logInterval = 0.5f;
-			this.csvCollectTimer = 0f;
+			this.waitForLaunch = (VOID_SaveValue<bool>)true;
+
+			this.logInterval = (VOID_SaveValue<float>)0.5f;
+			this.csvCollectTimer = (VOID_SaveValue<float>)0f;
 
 			this.outstandingWrites = 0;
 

--- a/VOID_EditorHUD.cs
+++ b/VOID_EditorHUD.cs
@@ -28,11 +28,12 @@
 
 using KerbalEngineer.VesselSimulator;
 using KSP;
+using KSP.UI.Screens;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Text;
 using ToadicusTools;
+using ToadicusTools.Text;
 using UnityEngine;
 
 namespace VOID
@@ -58,9 +59,12 @@
 			{
 				if (this._vesselOverlays == null)
 				{
-					this._vesselOverlays = (EditorVesselOverlays)Resources
-						.FindObjectsOfTypeAll(typeof(EditorVesselOverlays))
-						.FirstOrDefault();
+					UnityEngine.Object[] overlayObjs = Resources.FindObjectsOfTypeAll(typeof(EditorVesselOverlays));
+
+					if (overlayObjs.Length > 0)
+					{
+						this._vesselOverlays = (EditorVesselOverlays)overlayObjs[0];
+					}
 				}
 
 				return this._vesselOverlays;
@@ -100,139 +104,138 @@
 		{
 			this.Name = "Heads-Up Display";
 
-			this.toggleActive = true;
+			this.Active = true;
 
 			this.snapToLeft.value = true;
 
 			this.ehudWindow = new HUDWindow(
 				"editorHUD",
 				this.ehudWindowFunc,
-				new Rect(EditorPanels.Instance.partsPanelWidth + 10f, 125f, 300f, 64f)
+				new Rect(10f, 125f, 300f, 64f)
 			);
 			this.Windows.Add(this.ehudWindow);
 
-			Tools.PostDebugMessage (this.GetType().Name + ": Constructed.");
+			Logging.PostDebugMessage (this.GetType().Name + ": Constructed.");
 		}
 
 		public void ehudWindowFunc(int id)
 		{
-			StringBuilder hudString = new StringBuilder();
-
-			if (this.core.LastStage == null)
-			{
+			using (PooledStringBuilder hudString = PooledStringBuilder.Get())
+			{
+				if (this.core.LastStage == null)
+				{
+					return;
+				}
+
+				VOID_Styles.labelHud.alignment = TextAnchor.UpperLeft;
+
+				hudString.Append("Total Mass: ");
+				hudString.Append(this.core.LastStage.totalMass.ToString("F3"));
+				hudString.Append('t');
+
+				hudString.Append(' ');
+
+				hudString.Append("Part Count: ");
+				hudString.Append(EditorLogic.SortedShipList.Count);
+
+				hudString.Append('\n');
+
+				hudString.Append("Total Delta-V: ");
+				hudString.Append(SIFormatProvider.ToSI(this.core.LastStage.totalDeltaV));
+				hudString.Append("m/s");
+
+				hudString.Append('\n');
+
+				hudString.Append("Bottom Stage Delta-V: ");
+				hudString.Append(SIFormatProvider.ToSI(this.core.LastStage.deltaV));
+				hudString.Append("m/s");
+
+				hudString.Append('\n');
+
+				hudString.Append("Bottom Stage T/W Ratio: ");
+				hudString.Append(this.core.LastStage.thrustToWeight.ToString("F3"));
+
+				Logging.PostDebugMessage(this,
+					"CoMmarker.gameObject.activeInHierarchy: {0};" +
+					"CoTmarker.gameObject.activeInHierarchy: {1}",
+					this.CoMmarker.gameObject.activeInHierarchy,
+					this.CoTmarker.gameObject.activeInHierarchy
+				);
+
+				if (this.CoMmarker.gameObject.activeInHierarchy && this.CoTmarker.gameObject.activeInHierarchy)
+				{
+					Logging.PostDebugMessage(this, "CoM and CoT markers are active, doing thrust offset.");
+					hudString.Append('\n');
+
+					hudString.Append("Thrust Offset: ");
+					hudString.Append(
+						Vector3.Cross(
+							this.CoTmarker.dirMarkerObject.transform.forward,
+							this.CoMmarker.posMarkerObject.transform.position - this.CoTmarker.posMarkerObject.transform.position
+						).ToString("F3"));
+				}
+				#if DEBUG
+			else
+			{
+				Logging.PostDebugMessage(this, "CoM and CoT markers are not active, thrust offset skipped.");
+			}
+				#endif
+
+				GUILayout.Label(
+					hudString.ToString(),
+					VOID_Styles.labelHud,
+					GUILayout.ExpandWidth(true),
+					GUILayout.ExpandHeight(true)
+				);
+
+				if (!this.positionsLocked)
+				{
+					GUI.DragWindow();
+				}
+
+				GUI.BringWindowToBack(id);
+			}
+		}
+
+		public override void DrawGUI(object sender)
+		{
+			float hudLeft;
+
+			try
+			{
+				switch (EditorLogic.fetch.editorScreen)
+				{
+					case EditorScreen.Parts:
+						hudLeft = 16f + EditorPanels.Instance.partsEditor.panelTransform.rect.width +
+							EditorPanels.Instance.partcategorizerModes.transform.localPosition.x;
+						break;
+					case EditorScreen.Actions:
+						hudLeft = EditorPanels.Instance.actions.transform.localPosition.x + 464f;
+						break;
+					default:
+						return;
+				}
+			}
+			catch (NullReferenceException)
+			{
+				Logging.PostErrorMessage(
+					"[{0}]: Something was null when fetching panel geometry; skipping frame.",
+					this.GetType().FullName
+				);
+
 				return;
 			}
 
-			VOID_Styles.labelHud.alignment = TextAnchor.UpperLeft;
-
-			hudString.Append("Total Mass: ");
-			hudString.Append(this.core.LastStage.totalMass.ToString("F3"));
-			hudString.Append('t');
-
-			hudString.Append(' ');
-
-			hudString.Append("Part Count: ");
-			hudString.Append(EditorLogic.SortedShipList.Count);
-
-			hudString.Append('\n');
-
-			hudString.Append("Total Delta-V: ");
-			hudString.Append(Tools.MuMech_ToSI(this.core.LastStage.totalDeltaV));
-			hudString.Append("m/s");
-
-			hudString.Append('\n');
-
-			hudString.Append("Bottom Stage Delta-V");
-			hudString.Append(Tools.MuMech_ToSI(this.core.LastStage.deltaV));
-			hudString.Append("m/s");
-
-			hudString.Append('\n');
-
-			hudString.Append("Bottom Stage T/W Ratio: ");
-			hudString.Append(this.core.LastStage.thrustToWeight.ToString("F3"));
-
-			Tools.PostDebugMessage(this,
-				"CoMmarker.gameObject.activeInHierarchy: {0};" +
-				"CoTmarker.gameObject.activeInHierarchy: {1}",
-				this.CoMmarker.gameObject.activeInHierarchy,
-				this.CoTmarker.gameObject.activeInHierarchy
-			);
-
-			if (this.CoMmarker.gameObject.activeInHierarchy && this.CoTmarker.gameObject.activeInHierarchy)
-			{
-				Tools.PostDebugMessage(this, "CoM and CoT markers are active, doing thrust offset.");
-				hudString.Append('\n');
-
-				hudString.Append("Thrust Offset: ");
-				hudString.Append(
-					Vector3.Cross(
-						this.CoTmarker.dirMarkerObject.transform.forward,
-						this.CoMmarker.posMarkerObject.transform.position - this.CoTmarker.posMarkerObject.transform.position
-					).ToString("F3"));
-			}
-			#if DEBUG
+			base.DrawGUI(this);
+
+			Rect hudPos = this.ehudWindow.WindowPos;
+
+			if (this.snapToLeft && this.positionsLocked)
+			{
+				hudPos.xMin = hudLeft;
+			}
 			else
 			{
-				Tools.PostDebugMessage(this, "CoM and CoT markers are not active, thrust offset skipped.");
-			}
-			#endif
-
-			GUILayout.Label(
-				hudString.ToString(),
-				VOID_Styles.labelHud,
-				GUILayout.ExpandWidth(true),
-				GUILayout.ExpandHeight(true)
-			);
-
-			if (!this.positionsLocked)
-			{
-				GUI.DragWindow();
-			}
-
-			GUI.BringWindowToBack(id);
-		}
-
-		public override void DrawGUI()
-		{
-			float hudLeft;
-
-			if (EditorLogic.fetch.editorScreen == EditorScreen.Parts)
-			{
-				hudLeft = EditorPanels.Instance.partsPanelWidth + 10f;
-				hudLeft += EditorPartList.Instance.transformTopLeft.position.x -
-					EditorPartList.Instance.transformTopLeft.parent.parent.position.x -
-					72f;
-			}
-			else if (EditorLogic.fetch.editorScreen == EditorScreen.Actions)
-			{
-				hudLeft = EditorPanels.Instance.actionsPanelWidth + 10f;
-			}
-			else
-			{
-				return;
-			}
-
-			Tools.PostDebugMessage(this,
-				"EditorPartList topLeft.parent.parent.position: {0}\n" +
-				"EditorPartList topLeft.parent.position: {1}\n" +
-				"EditorPartList topLeft.position: {2}\n" +
-				"snapToEdge: {3} (pos.Xmin: {4}; hudLeft: {5})",
-				EditorPartList.Instance.transformTopLeft.parent.parent.position,
-				EditorPartList.Instance.transformTopLeft.parent.position,
-				EditorPartList.Instance.transformTopLeft.position,
-				this.snapToLeft, this.ehudWindow.WindowPos.xMin, hudLeft
-			);
-
-			base.DrawGUI();
-
-			Rect hudPos = this.ehudWindow.WindowPos;
-
-			if (this.snapToLeft && this.positionsLocked)
-			{
-				hudPos.xMin = hudLeft;
-			}
-			else
-			{
 				hudPos.xMin = Mathf.Max(hudLeft, hudPos.xMin);
 			}
 
@@ -240,7 +243,7 @@
 
 			this.ehudWindow.WindowPos = hudPos;
 
-			this.snapToLeft = Mathf.Abs(this.ehudWindow.WindowPos.xMin - hudLeft) < 15f;
+			this.snapToLeft.value = Mathf.Abs(this.ehudWindow.WindowPos.xMin - hudLeft) < 15f;
 		}
 	}
 }

--- a/VOID_HUD.cs
+++ b/VOID_HUD.cs
@@ -32,6 +32,7 @@
 using System.Collections.Generic;
 using System.Text;
 using ToadicusTools;
+using ToadicusTools.Text;
 using UnityEngine;
 
 namespace VOID
@@ -55,133 +56,130 @@
 		{
 			this.Name = "Heads-Up Display";
 
-			this.toggleActive = true;
+			this.Active = true;
 
-			this.leftHUD = new HUDWindow("leftHUD", this.leftHUDWindow, new Rect(Screen.width * .375f - 300f, 0f, 300f, 90f));
+			this.leftHUD = new HUDWindow("leftHUD", this.leftHUDWindow, new Rect((float)Screen.width * .375f - 300f, 0f, 300f, 90f));
 			this.Windows.Add(this.leftHUD);
 
-			this.rightHUD = new HUDWindow("rightHUD", this.rightHUDWindow, new Rect(Screen.width * .625f, 0f, 300f, 90f));
+			this.rightHUD = new HUDWindow("rightHUD", this.rightHUDWindow, new Rect((float)Screen.width * .625f, 0f, 300f, 90f));
 			this.Windows.Add(this.rightHUD);
 
-			Tools.PostDebugMessage ("VOID_HUD: Constructed.");
+			Logging.PostDebugMessage ("VOID_HUD: Constructed.");
 		}
 
 		protected void leftHUDWindow(int id)
 		{
-			StringBuilder leftHUD;
+			using (PooledStringBuilder leftHUD = PooledStringBuilder.Get())
+			{
+				VOID_Styles.labelHud.alignment = TextAnchor.UpperRight;
 
-			leftHUD = new StringBuilder();
+				if (this.core.powerAvailable)
+				{
+					leftHUD.AppendFormat("Primary: {0} Inc: {1}",
+						VOID_Data.primaryName.ValueUnitString(),
+						VOID_Data.orbitInclination.ValueUnitString("F3")
+					);
+					leftHUD.AppendFormat("\nObt Alt: {0} Obt Vel: {1}",
+						VOID_Data.orbitAltitude.ToSIString(),
+						VOID_Data.orbitVelocity.ToSIString()
+					);
+					leftHUD.AppendFormat("\nAp: {0} ETA {1}",
+						VOID_Data.orbitApoAlt.ToSIString(),
+						VOID_Data.timeToApo.ValueUnitString()
+					);
+					leftHUD.AppendFormat("\nPe: {0} ETA {1}",
+						VOID_Data.oribtPeriAlt.ToSIString(),
+						VOID_Data.timeToPeri.ValueUnitString()
+					);
+					leftHUD.AppendFormat("\nTot Δv: {0} Stg Δv: {1}",
+						VOID_Data.totalDeltaV.ToSIString(2),
+						VOID_Data.stageDeltaV.ToSIString(2)
+					);
+				}
+				else
+				{
+					VOID_Styles.labelHud.normal.textColor = Color.red;
+					leftHUD.Append(string.Intern("-- POWER LOST --"));
+				}
 
-			VOID_Styles.labelHud.alignment = TextAnchor.UpperRight;
+				GUILayout.Label(
+					leftHUD.ToString(),
+					VOID_Styles.labelHud,
+					GUILayout.ExpandWidth(true),
+					GUILayout.ExpandHeight(true)
+				);
 
-			if (this.core.powerAvailable)
-			{
-				leftHUD.AppendFormat("Primary: {0} Inc: {1}",
-					VOID_Data.primaryName.ValueUnitString(),
-					VOID_Data.orbitInclination.ValueUnitString("F3")
-				);
-				leftHUD.AppendFormat("\nObt Alt: {0} Obt Vel: {1}",
-					VOID_Data.orbitAltitude.ToSIString(),
-					VOID_Data.orbitVelocity.ToSIString()
-				);
-				leftHUD.AppendFormat("\nAp: {0} ETA {1}",
-					VOID_Data.orbitApoAlt.ToSIString(),
-					VOID_Data.timeToApo.ValueUnitString()
-				);
-				leftHUD.AppendFormat("\nPe: {0} ETA {1}",
-					VOID_Data.oribtPeriAlt.ToSIString(),
-					VOID_Data.timeToPeri.ValueUnitString()
-				);
-				leftHUD.AppendFormat("\nTot Δv: {0} Stg Δv: {1}",
-					VOID_Data.totalDeltaV.ToSIString(2),
-					VOID_Data.stageDeltaV.ToSIString(2)
-				);
+				if (!this.positionsLocked)
+				{
+					GUI.DragWindow();
+				}
+
+				GUI.BringWindowToBack(id);
 			}
-			else
-			{
-				VOID_Styles.labelHud.normal.textColor = Color.red;
-				leftHUD.Append(string.Intern("-- POWER LOST --"));
-			}
-
-			GUILayout.Label(
-				leftHUD.ToString(),
-				VOID_Styles.labelHud,
-				GUILayout.ExpandWidth(true),
-				GUILayout.ExpandHeight(true)
-			);
-
-			if (!this.positionsLocked)
-			{
-				GUI.DragWindow();
-			}
-
-			GUI.BringWindowToBack(id);
 		}
 
 		protected void rightHUDWindow(int id)
 		{
-			StringBuilder rightHUD;
+			using (PooledStringBuilder rightHUD = PooledStringBuilder.Get())
+			{
+				VOID_Styles.labelHud.alignment = TextAnchor.UpperLeft;
 
-			rightHUD = new StringBuilder();
+				if (this.core.powerAvailable)
+				{
+					rightHUD.AppendFormat("Biome: {0} Sit: {1}",
+						VOID_Data.currBiome.ValueUnitString(),
+						VOID_Data.expSituation.ValueUnitString()
+					);
+					rightHUD.AppendFormat("\nSrf Alt: {0} Srf Vel: {1}",
+						VOID_Data.trueAltitude.ToSIString(),
+						VOID_Data.surfVelocity.ToSIString()
+					);
+					rightHUD.AppendFormat("\nVer: {0} Hor: {1}",
+						VOID_Data.vertVelocity.ToSIString(),
+						VOID_Data.horzVelocity.ToSIString()
+					);
+					rightHUD.AppendFormat("\nLat: {0} Lon: {1}",
+						VOID_Data.surfLatitudeString.ValueUnitString(),
+						VOID_Data.surfLongitudeString.ValueUnitString()
+					);
+					rightHUD.AppendFormat("\nHdg: {0} Pit: {1}",
+						VOID_Data.vesselHeading.ValueUnitString(),
+						VOID_Data.vesselPitch.ToSIString(2)
+					);
 
-			VOID_Styles.labelHud.alignment = TextAnchor.UpperLeft;
+					if (
+						this.core.Vessel.mainBody == this.core.HomeBody &&
+						(
+						    this.core.Vessel.situation == Vessel.Situations.FLYING ||
+						    this.core.Vessel.situation == Vessel.Situations.SUB_ORBITAL ||
+						    this.core.Vessel.situation == Vessel.Situations.LANDED ||
+						    this.core.Vessel.situation == Vessel.Situations.SPLASHED
+						))
+					{
+						rightHUD.AppendFormat("\nRange to KSC: {0}", VOID_Data.downrangeDistance.ValueUnitString(2));
+					}
+				}
+				else
+				{
+					VOID_Styles.labelHud.normal.textColor = Color.red;
+					rightHUD.Append(string.Intern("-- POWER LOST --"));
+				}
 
-			if (this.core.powerAvailable)
-			{
-				rightHUD.AppendFormat("Biome: {0} Sit: {1}",
-					VOID_Data.currBiome.ValueUnitString(),
-					VOID_Data.expSituation.ValueUnitString()
-				);
-				rightHUD.AppendFormat("\nSrf Alt: {0} Srf Vel: {1}",
-					VOID_Data.trueAltitude.ToSIString(),
-					VOID_Data.surfVelocity.ToSIString()
-				);
-				rightHUD.AppendFormat("\nVer: {0} Hor: {1}",
-					VOID_Data.vertVelocity.ToSIString(),
-					VOID_Data.horzVelocity.ToSIString()
-				);
-				rightHUD.AppendFormat("\nLat: {0} Lon: {1}",
-					VOID_Data.surfLatitude.ValueUnitString(),
-					VOID_Data.surfLongitude.ValueUnitString()
-				);
-				rightHUD.AppendFormat("\nHdg: {0} Pit: {1}",
-					VOID_Data.vesselHeading.ValueUnitString(),
-					VOID_Data.vesselPitch.ToSIString(2)
+
+				GUILayout.Label(
+					rightHUD.ToString(),
+					VOID_Styles.labelHud,
+					GUILayout.ExpandWidth(true),
+					GUILayout.ExpandHeight(true)
 				);
 
-				if (
-					this.core.vessel.mainBody == this.core.HomeBody &&
-					(
-						this.core.vessel.situation == Vessel.Situations.FLYING ||
-						this.core.vessel.situation == Vessel.Situations.SUB_ORBITAL ||
-						this.core.vessel.situation == Vessel.Situations.LANDED ||
-						this.core.vessel.situation == Vessel.Situations.SPLASHED
-					)
-				)
+				if (!this.positionsLocked)
 				{
-					rightHUD.AppendFormat("\nRange to KSC: {0}", VOID_Data.downrangeDistance.ValueUnitString(2));
+					GUI.DragWindow();
 				}
+
+				GUI.BringWindowToBack(id);
 			}
-			else
-			{
-				VOID_Styles.labelHud.normal.textColor = Color.red;
-				rightHUD.Append(string.Intern("-- POWER LOST --"));
-			}
-
-
-			GUILayout.Label(
-				rightHUD.ToString(),
-				VOID_Styles.labelHud,
-				GUILayout.ExpandWidth(true),
-				GUILayout.ExpandHeight(true)
-			);
-
-			if (!this.positionsLocked)
-			{
-				GUI.DragWindow();
-			}
-
-			GUI.BringWindowToBack(id);
 		}
 	}
 }

--- a/VOID_HUDAdvanced.cs
+++ b/VOID_HUDAdvanced.cs
@@ -30,9 +30,10 @@
 using KSP;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Text;
 using ToadicusTools;
+using ToadicusTools.GUIUtils;
+using ToadicusTools.Text;
 using UnityEngine;
 
 namespace VOID
@@ -74,12 +75,12 @@
 		{
 			this.Name = "Advanced Heads-Up Display";
 
-			this.toggleActive = true;
+			this.Active = true;
 
 			this.leftHUD = new HUDWindow("leftHUD",
 				this.leftHUDWindow,
 				new Rect(
-					Screen.width * .5f - (float)GameSettings.UI_SIZE * .25f - 300f,
+					Screen.width * .5f - 300f - 220f * GameSettings.UI_SCALE,
 					Screen.height - 200f,
 					300f, 90f)
 			);
@@ -89,151 +90,152 @@
 				"rightHUD",
 				this.rightHUDWindow,
 				new Rect(
-					Screen.width * .5f + (float)GameSettings.UI_SIZE * .25f,
+					Screen.width * .5f + 180f * GameSettings.UI_SCALE,
 					Screen.height - 200f,
 					300f, 90f)
 			);
 			this.Windows.Add(this.rightHUD);
 
-			this.positionsLocked = true;
-
-			Tools.PostDebugMessage (this, "Constructed.");
+			this.positionsLocked.value = true;
+
+			Logging.PostDebugMessage (this, "Constructed.");
 		}
 
 		protected void leftHUDWindow(int id)
 		{
-			StringBuilder leftHUD;
-
-			leftHUD = new StringBuilder();
-
-			VOID_Styles.labelHud.alignment = TextAnchor.UpperRight;
-
-			if (this.core.powerAvailable)
-			{
-				leftHUD.AppendFormat(
-					string.Intern("Mass: {0}\n"),
-					VOID_Data.totalMass.ToSIString(2)
+			using (PooledStringBuilder leftHUD = PooledStringBuilder.Get())
+			{
+				VOID_Styles.labelHud.alignment = TextAnchor.UpperRight;
+
+				if (this.core.powerAvailable)
+				{
+					leftHUD.AppendFormat(
+						string.Intern("Mass: {0}\n"),
+						VOID_Data.totalMass.ToSIString(2)
+					);
+
+					if (VOID_Data.vesselCrewCapacity > 0)
+					{
+						leftHUD.AppendFormat(
+							string.Intern("Crew: {0} / {1}\n"),
+							VOID_Data.vesselCrewCount.Value,
+							VOID_Data.vesselCrewCapacity.Value
+						);
+					}
+
+					leftHUD.AppendFormat(
+						string.Intern("Acc: {0} T:W: {1}\n"),
+						VOID_Data.vesselAccel.ToSIString(2),
+						VOID_Data.currThrustWeight.Value.ToString("f2")
+					);
+
+					leftHUD.AppendFormat(
+						string.Intern("Ang Vel: {0}\n"),
+						VOID_Data.vesselAngularVelocity.ToSIString(2)
+					);
+
+					if (VOID_Data.stageNominalThrust != 0d)
+					{
+						leftHUD.AppendFormat(
+							string.Intern("Thrust Offset: {0}\n"),
+							VOID_Data.vesselThrustOffset.Value.ToString("F1")
+						);
+					}
+				}
+				else
+				{
+					VOID_Styles.labelHud.normal.textColor = Color.red;
+					leftHUD.Append(string.Intern("-- POWER LOST --"));
+				}
+
+				GUILayout.Label(
+					leftHUD.ToString(),
+					VOID_Styles.labelHud,
+					GUILayout.ExpandWidth(true),
+					GUILayout.ExpandHeight(true)
 				);
 
-				if (VOID_Data.vesselCrewCapacity > 0)
-				{
-					leftHUD.AppendFormat(
-						string.Intern("Crew: {0} / {1}\n"),
-						VOID_Data.vesselCrewCount.Value,
-						VOID_Data.vesselCrewCapacity.Value
-					);
-				}
-
-				leftHUD.AppendFormat(
-					string.Intern("Acc: {0} T:W: {1}\n"),
-					VOID_Data.vesselAccel.ToSIString(2),
-					VOID_Data.currThrustWeight.Value.ToString("f2")
+				if (!this.positionsLocked)
+				{
+					GUI.DragWindow();
+				}
+
+				GUI.BringWindowToBack(id);
+			}
+		}
+
+		protected void rightHUDWindow(int id)
+		{
+			using (PooledStringBuilder rightHUD = PooledStringBuilder.Get())
+			{
+				VOID_Styles.labelHud.alignment = TextAnchor.UpperLeft;
+
+				if (this.core.powerAvailable)
+				{
+					rightHUD.AppendFormat(
+						"Burn Δv (Rem/Tot): {0} / {1}\n",
+						VOID_Data.currManeuverDVRemaining.ValueUnitString("f2"),
+						VOID_Data.currManeuverDeltaV.ValueUnitString("f2")
+					);
+
+					if (VOID_Data.upcomingManeuverNodes > 1)
+					{
+						rightHUD.AppendFormat("Next Burn Δv: {0}\n",
+							VOID_Data.nextManeuverDeltaV.ValueUnitString("f2")
+						);
+					}
+
+					rightHUD.AppendFormat("Burn Time (Rem/Total): {0} / {1}\n",
+						VOID_Tools.FormatInterval(VOID_Data.currentNodeBurnRemaining.Value),
+						VOID_Tools.FormatInterval(VOID_Data.currentNodeBurnDuration.Value)
+					);
+
+					if (VOID_Data.burnTimeDoneAtNode.Value != string.Empty)
+					{
+						rightHUD.AppendFormat("{0} (done @ node)\n",
+							VOID_Data.burnTimeDoneAtNode.Value
+						);
+
+						rightHUD.AppendFormat("{0} (½ done @ node)",
+							VOID_Data.burnTimeHalfDoneAtNode.Value
+						);
+					}
+					else
+					{
+						rightHUD.Append("Node is past");
+					}
+				}
+				else
+				{
+					VOID_Styles.labelHud.normal.textColor = Color.red;
+					rightHUD.Append(string.Intern("-- POWER LOST --"));
+				}
+
+				GUILayout.Label(
+					rightHUD.ToString(),
+					VOID_Styles.labelHud,
+					GUILayout.ExpandWidth(true),
+					GUILayout.ExpandHeight(true)
 				);
 
-				leftHUD.AppendFormat(
-					string.Intern("Ang Vel: {0}\n"),
-					VOID_Data.vesselAngularVelocity.ToSIString(2)
-				);
-
-				if (VOID_Data.stageNominalThrust != 0d)
-				{
-					leftHUD.AppendFormat(
-						string.Intern("Thrust Offset: {0}\n"),
-						VOID_Data.vesselThrustOffset.Value.ToString("F1")
-					);
-				}
-			}
-			else
-			{
-				VOID_Styles.labelHud.normal.textColor = Color.red;
-				leftHUD.Append(string.Intern("-- POWER LOST --"));
-			}
-
-			GUILayout.Label(
-				leftHUD.ToString(),
-				VOID_Styles.labelHud,
-				GUILayout.ExpandWidth(true),
-				GUILayout.ExpandHeight(true)
-			);
-
-			if (!this.positionsLocked)
-			{
-				GUI.DragWindow();
-			}
-
-			GUI.BringWindowToBack(id);
-		}
-
-		protected void rightHUDWindow(int id)
-		{
-			StringBuilder rightHUD;
-
-			rightHUD = new StringBuilder();
-
-			VOID_Styles.labelHud.alignment = TextAnchor.UpperLeft;
-
-			if (this.core.powerAvailable)
-			{
-				rightHUD.AppendFormat(
-					"Burn Δv (Rem/Tot): {0} / {1}\n",
-					VOID_Data.currManeuverDVRemaining.ValueUnitString("f2"),
-					VOID_Data.currManeuverDeltaV.ValueUnitString("f2")
-				);
-
-				if (VOID_Data.upcomingManeuverNodes > 1)
-				{
-					rightHUD.AppendFormat("Next Burn Δv: {0}\n",
-						VOID_Data.nextManeuverDeltaV.ValueUnitString("f2")
-					);
-				}
-
-				rightHUD.AppendFormat("Burn Time (Rem/Total): {0} / {1}\n",
-					VOID_Tools.FormatInterval(VOID_Data.currentNodeBurnRemaining.Value),
-					VOID_Tools.FormatInterval(VOID_Data.currentNodeBurnDuration.Value)
-				);
-
-				if (VOID_Data.burnTimeDoneAtNode.Value != string.Empty)
-				{
-					rightHUD.AppendFormat("{0} (done @ node)\n",
-						VOID_Data.burnTimeDoneAtNode.Value
-					);
-
-					rightHUD.AppendFormat("{0} (½ done @ node)",
-						VOID_Data.burnTimeHalfDoneAtNode.Value
-					);
-				}
-				else
-				{
-					rightHUD.Append("Node is past");
-				}
-			}
-			else
-			{
-				VOID_Styles.labelHud.normal.textColor = Color.red;
-				rightHUD.Append(string.Intern("-- POWER LOST --"));
-			}
-
-			GUILayout.Label(
-				rightHUD.ToString(),
-				VOID_Styles.labelHud,
-				GUILayout.ExpandWidth(true),
-				GUILayout.ExpandHeight(true)
-			);
-
-			if (!this.positionsLocked)
-			{
-				GUI.DragWindow();
-			}
-
-			GUI.BringWindowToBack(id);
-		}
-
-		public override void DrawGUI()
+				if (!this.positionsLocked)
+				{
+					GUI.DragWindow();
+				}
+
+				GUI.BringWindowToBack(id);
+			}
+		}
+
+		public override void DrawGUI(object sender)
 		{
 			if (this.primaryHUD == null)
 			{
-				foreach (IVOID_Module module in this.core.Modules)
-				{
+				IVOID_Module module;
+				for (int idx = 0; idx < this.core.Modules.Count; idx++)
+				{
+					module = this.core.Modules[idx];
+
 					if (module is VOID_HUD)
 					{
 						this.primaryHUD = module as VOID_HUD;
@@ -250,22 +252,23 @@
 				this.Windows.Add(this.rightHUD);
 			}
 
-			base.DrawGUI();
+			base.DrawGUI(sender);
 		}
 
 		public override void DrawConfigurables()
 		{
-			base.DrawConfigurables();
-
 			if (GUILayout.Button(string.Intern("Reset Advanced HUD Positions"), GUILayout.ExpandWidth(false)))
 			{
-				foreach (HUDWindow window in this.Windows)
-				{
+				HUDWindow window;
+				for (int idx = 0; idx < this.Windows.Count; idx++)
+				{
+					window = this.Windows[idx];
+
 					window.WindowPos = new Rect(window.defaultWindowPos);
 				}
 			}
 
-			this.positionsLocked = GUITools.Toggle(this.positionsLocked, string.Intern("Lock Advanced HUD Positions"));
+			this.positionsLocked.value = Layout.Toggle(this.positionsLocked, string.Intern("Lock Advanced HUD Positions"));
 		}
 	}
 }

file:a/VOID_Localization.cs (deleted)
--- a/VOID_Localization.cs
+++ /dev/null
@@ -1,36 +1,1 @@
-// VOID
-//
-// VOID_Localization.cs
-//
-// Copyright © 2014, toadicus
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice,
-//    this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice,
-//    this list of conditions and the following disclaimer in the documentation and/or other
-//    materials provided with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its contributors may be used
-//    to endorse or promote products derived from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-public static class VOID_Localization
-{
-	public static string void_primary = "Primary";
-	public static string void_altitude_asl = "Altitude (ASL)";
-	public static string void_velocity = "Velocity";
-	public static string void_apoapsis = "Apoapsis";
-	public static string void_periapsis = "Periapsis";
-}

--- a/VOID_Orbital.cs
+++ b/VOID_Orbital.cs
@@ -29,6 +29,7 @@
 using KSP;
 using System;
 using ToadicusTools;
+using ToadicusTools.GUIUtils;
 using UnityEngine;
 
 namespace VOID
@@ -36,10 +37,10 @@
 	public class VOID_Orbital : VOID_WindowModule
 	{
 		[AVOID_SaveValue("toggleExtended")]
-		protected VOID_SaveValue<bool> toggleExtended = false;
+		protected VOID_SaveValue<bool> toggleExtended;
 
 		[AVOID_SaveValue("precisionValues")]
-		protected long _precisionValues = 230584300921369395;
+		protected VOID_SaveValue<long> _precisionValues;
 		protected IntCollection precisionValues;
 
 		public VOID_Orbital()
@@ -48,9 +49,13 @@
 
 			this.WindowPos.x = Screen.width - 520f;
 			this.WindowPos.y = 250f;
+
+			this.toggleExtended = (VOID_SaveValue<bool>)false;
+
+			this._precisionValues = (VOID_SaveValue<long>)384307168202282325;
 		}
 
-		public override void ModuleWindow(int _)
+		public override void ModuleWindow(int id)
 		{
 			int idx = 0;
 
@@ -79,7 +84,7 @@
 			this.precisionValues [idx]= (ushort)VOID_Data.gravityAccel.DoGUIHorizontal (this.precisionValues [idx]);
 			idx++;
 
-			this.toggleExtended.value = GUITools.Toggle(this.toggleExtended, "Extended info");
+			this.toggleExtended.value = Layout.Toggle(this.toggleExtended, "Extended info");
 
 			if (this.toggleExtended)
             {
@@ -108,23 +113,23 @@
             }
 
             GUILayout.EndVertical();
-            GUI.DragWindow();
+
+			base.ModuleWindow(id);
 		}
 
-		public override void LoadConfig ()
+		public override void LoadConfig(KSP.IO.PluginConfiguration config)
 		{
-			base.LoadConfig ();
+			base.LoadConfig(config);
 
 			this.precisionValues = new IntCollection (4, this._precisionValues);
 		}
 
-		public override void _SaveToConfig (KSP.IO.PluginConfiguration config)
+		public override void Save (KSP.IO.PluginConfiguration config, string sceneKey)
 		{
-			this._precisionValues = this.precisionValues.collection;
+			this._precisionValues.value = this.precisionValues.collection;
 
-			base._SaveToConfig (config);
+			base.Save (config, sceneKey);
 		}
 	}
 }
 
-

--- a/VOID_Rendezvous.cs
+++ b/VOID_Rendezvous.cs
@@ -29,8 +29,9 @@
 using KSP;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using ToadicusTools;
+using ToadicusTools.GUIUtils;
+using ToadicusTools.Text;
 using UnityEngine;
 
 namespace VOID
@@ -38,10 +39,10 @@
 	public class VOID_Rendezvous : VOID_WindowModule
 	{
 		[AVOID_SaveValue("untoggleRegisterInfo")]
-		protected VOID_SaveValue<bool> untoggleRegisterInfo = false;
+		protected VOID_SaveValue<bool> untoggleRegisterInfo;
 
 		[AVOID_SaveValue("toggleExtendedOrbital")]
-		protected VOID_SaveValue<bool> toggleExtendedOrbital = false;
+		protected VOID_SaveValue<bool> toggleExtendedOrbital;
 
 		protected VOID_VesselRegister RegisterModule;
 
@@ -51,16 +52,26 @@
 
 			this.WindowPos.x = 845;
 			this.WindowPos.y = 85;
+
+			this.untoggleRegisterInfo = (VOID_SaveValue<bool>)false;
+			this.toggleExtendedOrbital = (VOID_SaveValue<bool>)false;
 		}
 
-		public override void ModuleWindow(int _)
+		public override void ModuleWindow(int id)
 		{
-			Vessel rendezvessel = new Vessel();
-			CelestialBody rendezbody = new CelestialBody();
+			Vessel rendezvessel;
+			CelestialBody rendezbody;
 
 			if (this.RegisterModule == null)
 			{
-				this.RegisterModule = this.core.Modules.Where(m => typeof(VOID_VesselRegister).IsAssignableFrom(m.GetType())).FirstOrDefault() as VOID_VesselRegister;
+				for (int idx = 0; idx < this.core.Modules.Count; idx++)
+				{
+					if (this.core.Modules[idx] is VOID_VesselRegister)
+					{
+						this.RegisterModule = this.core.Modules[idx] as VOID_VesselRegister;
+						break;
+					}
+				}
 			}
 
 			GUILayout.BeginVertical();
@@ -74,7 +85,7 @@
 				if (FlightGlobals.fetch.vesselTargetMode == VesselTargetModes.Direction)
 				{
 					//a Body is selected
-					rendezbody = vessel.patchedConicSolver.targetBody;
+					rendezbody = Vessel.patchedConicSolver.targetBody;
 					display_rendezvous_info(null, rendezbody);
 				}
 				else if (FlightGlobals.fetch.vesselTargetMode == VesselTargetModes.DirectionAndVelocity)
@@ -87,7 +98,7 @@
 				if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false)))
 				{
 					FlightGlobals.fetch.SetVesselTarget(null);
-					Tools.PostDebugMessage("VOID_Rendezvous: KSP Target set to null");
+					Logging.PostDebugMessage("VOID_Rendezvous: KSP Target set to null");
 				}
 
 			}
@@ -114,7 +125,7 @@
 						if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false)))
 						{
 							FlightGlobals.fetch.SetVesselTarget(rendezvessel);
-							Tools.PostDebugMessage("[VOID] KSP Target set to " + rendezvessel.vesselName);
+							Logging.PostDebugMessage("[VOID] KSP Target set to " + rendezvessel.vesselName);
 						}
 					}
 				}
@@ -126,15 +137,16 @@
 				}
 			}
 
-			untoggleRegisterInfo.value = GUITools.Toggle(untoggleRegisterInfo, "Hide Vessel Register Info");
+			untoggleRegisterInfo.value = Layout.Toggle(untoggleRegisterInfo, "Hide Vessel Register Info");
 
 			GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 			GUILayout.Label(" ", GUILayout.ExpandWidth(true));
-			if (GUILayout.Button("Close", GUILayout.ExpandWidth(false))) this.toggleActive = false;
+			if (GUILayout.Button("Close", GUILayout.ExpandWidth(false))) this.Active = false;
 			GUILayout.EndHorizontal();
 
 			GUILayout.EndVertical();
-			GUI.DragWindow();
+
+			base.ModuleWindow(id);
 		}
 
 		private void display_rendezvous_info(Vessel v, CelestialBody cb)
@@ -156,12 +168,12 @@
 					//display orbital info for orbiting/flying/suborbital/escaping vessels only
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 					GUILayout.Label("Ap/Pe:");
-					GUILayout.Label(Tools.MuMech_ToSI(v.orbit.ApA) + "m / " + Tools.MuMech_ToSI(v.orbit.PeA) + "m", GUILayout.ExpandWidth(false));
+					GUILayout.Label(SIFormatProvider.ToSI(v.orbit.ApA, 3) + "m / " + SIFormatProvider.ToSI(v.orbit.PeA, 3) + "m", GUILayout.ExpandWidth(false));
 					GUILayout.EndHorizontal();
 
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 					GUILayout.Label("Altitude:");
-					GUILayout.Label(Tools.MuMech_ToSI(v.orbit.altitude) + "m", GUILayout.ExpandWidth(false));
+					GUILayout.Label(SIFormatProvider.ToSI(v.orbit.altitude, 3) + "m", GUILayout.ExpandWidth(false));
 					GUILayout.EndHorizontal();
 
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
@@ -169,28 +181,28 @@
 					GUILayout.Label(v.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));
 					GUILayout.EndHorizontal();
 
-					if (vessel.mainBody == v.mainBody)
+					if (Vessel.mainBody == v.mainBody)
 					{
 						GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 						GUILayout.Label("Relative inclination:");
-						GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), v.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));
+						GUILayout.Label(Vector3.Angle(Vessel.orbit.GetOrbitNormal(), v.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));
 						GUILayout.EndHorizontal();
 					}
 					//if (debugging) Debug.Log("[CHATR] v -> v relative incl OK");
 
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 					GUILayout.Label("Velocity:");
-					GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));
+					GUILayout.Label(SIFormatProvider.ToSI(v.orbit.vel.magnitude, 3) + "m/s", GUILayout.ExpandWidth(false));
 					GUILayout.EndHorizontal();
 
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 					GUILayout.Label("Relative velocity:");
-					GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude - vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));
+					GUILayout.Label(SIFormatProvider.ToSI(v.orbit.vel.magnitude - Vessel.orbit.vel.magnitude, 3) + "m/s", GUILayout.ExpandWidth(false));
 					GUILayout.EndHorizontal();
 
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 					GUILayout.Label("Distance:");
-					GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false));
+					GUILayout.Label(SIFormatProvider.ToSI((Vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude, 3) + "m", GUILayout.ExpandWidth(false));
 					GUILayout.EndHorizontal();
 
 					// Toadicus edit: added local sidereal longitude.
@@ -199,7 +211,7 @@
 					GUILayout.Label(LSL.ToString("F3") + "°", VOID_Styles.labelRight);
 					GUILayout.EndHorizontal();
 
-					toggleExtendedOrbital.value = GUITools.Toggle(toggleExtendedOrbital, "Extended info");
+					toggleExtendedOrbital.value = Layout.Toggle(toggleExtendedOrbital, "Extended info");
 
 					if (toggleExtendedOrbital)
 					{
@@ -250,17 +262,17 @@
 				{
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 					GUILayout.Label("Latitude:");
-					GUILayout.Label(VOID_Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false));
+					GUILayout.Label(VOID_Tools.GetLatitudeString(Vessel), GUILayout.ExpandWidth(false));
 					GUILayout.EndHorizontal();
 
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 					GUILayout.Label("Longitude:");
-					GUILayout.Label(VOID_Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false));
+					GUILayout.Label(VOID_Tools.GetLongitudeString(Vessel), GUILayout.ExpandWidth(false));
 					GUILayout.EndHorizontal();
 
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 					GUILayout.Label("Distance:");
-					GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false));
+					GUILayout.Label(SIFormatProvider.ToSI((Vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude, 3) + "m", GUILayout.ExpandWidth(false));
 					GUILayout.EndHorizontal();
 				}
 			}
@@ -271,7 +283,7 @@
 
 				GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 				GUILayout.Label("Ap/Pe:");
-				GUILayout.Label(Tools.MuMech_ToSI(cb.orbit.ApA) + "m / " + Tools.MuMech_ToSI(cb.orbit.PeA) + "m", GUILayout.ExpandWidth(false));
+				GUILayout.Label(SIFormatProvider.ToSI(cb.orbit.ApA, 3) + "m / " + SIFormatProvider.ToSI(cb.orbit.PeA, 3) + "m", GUILayout.ExpandWidth(false));
 				GUILayout.EndHorizontal();
 				//if (debugging) Debug.Log("[VOID] Ap/Pe OK");
 
@@ -281,47 +293,47 @@
 				GUILayout.EndHorizontal();
 				//if (debugging) Debug.Log("[VOID] Inclination OK");
 
-				if (cb.referenceBody == vessel.mainBody)
+				if (cb.referenceBody == Vessel.mainBody)
 				{
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 					GUILayout.Label("Relative inclination:");
-					GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), cb.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));
+					GUILayout.Label(Vector3.Angle(Vessel.orbit.GetOrbitNormal(), cb.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));
 					GUILayout.EndHorizontal();
 					//if (debugging) Debug.Log("[VOID] cb Relative inclination OK");
 				}
 
 				GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 				GUILayout.Label("Distance:");
-				GUILayout.Label(Tools.MuMech_ToSI((vessel.mainBody.position - cb.position).magnitude) + "m", GUILayout.ExpandWidth(false));
+				GUILayout.Label(SIFormatProvider.ToSI((Vessel.mainBody.position - cb.position).magnitude, 3) + "m", GUILayout.ExpandWidth(false));
 				GUILayout.EndHorizontal();
 
 				//if (debugging) Debug.Log("[VOID] Distance OK");
 
 				//SUN2PLANET:
-				if (vessel.mainBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody)
-				{
-					VOID_Tools.display_transfer_angles_SUN2PLANET(cb, vessel);
+				if (Vessel.mainBody.bodyName == "Sun" && cb.referenceBody == Vessel.mainBody)
+				{
+					VOID_Tools.display_transfer_angles_SUN2PLANET(cb, Vessel);
 					//if (debugging) Debug.Log("[VOID] SUN2PLANET OK");
 				}
 
 				//PLANET2PLANET
-				else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody)
-				{
-					VOID_Tools.display_transfer_angles_PLANET2PLANET(cb, vessel);
+				else if (Vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == Vessel.mainBody.referenceBody)
+				{
+					VOID_Tools.display_transfer_angles_PLANET2PLANET(cb, Vessel);
 					//if (debugging) Debug.Log("[VOID] PLANET2PLANET OK");
 				}
 
 				//PLANET2MOON
-				else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody)
-				{
-					VOID_Tools.display_transfer_angles_PLANET2MOON(cb, vessel);
+				else if (Vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == Vessel.mainBody)
+				{
+					VOID_Tools.display_transfer_angles_PLANET2MOON(cb, Vessel);
 					//if (debugging) Debug.Log("[VOID] PLANET2MOON OK");
 				}
 
 				//MOON2MOON
-				else if (vessel.mainBody.referenceBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody)
-				{
-					VOID_Tools.display_transfer_angles_MOON2MOON(cb, vessel);
+				else if (Vessel.mainBody.referenceBody.referenceBody.bodyName == "Sun" && cb.referenceBody == Vessel.mainBody.referenceBody)
+				{
+					VOID_Tools.display_transfer_angles_MOON2MOON(cb, Vessel);
 					//if (debugging) Debug.Log("[VOID] MOON2MOON OK");
 				}
 

--- a/VOID_StageInfo.cs
+++ b/VOID_StageInfo.cs
@@ -7,8 +7,7 @@
 using KSP;
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using ToadicusTools;
+using ToadicusTools.GUIUtils;
 using UnityEngine;
 
 namespace VOID
@@ -33,22 +32,38 @@
 		private bool showBodyList;
 		private Rect bodyListPos;
 
-		private bool showColumnSelection;
-
-		private CelestialBody selectedBody;
+		private CelestialBody _selectedBody;
 		[AVOID_SaveValue("bodyIdx")]
 		private VOID_SaveValue<int> bodyIdx;
 		private int lastIdx;
 
+		private bool showAdvanced;
+
+		[AVOID_SaveValue("UseSealLevel")]
+		private VOID_SaveValue<bool> useSeaLevel;
+		private GUIContent seaLevelToggle;
+
+		private CelestialBody selectedBody
+		{
+			get
+			{
+				return this._selectedBody;
+			}
+			set
+			{
+				this._selectedBody = value;
+				KerbalEngineer.Helpers.CelestialBodies.SelectedBody = value;
+			}
+		}
+
 		public VOID_StageInfo() : base()
 		{
 			this.Name = "Stage Information";
 			this.defWidth = 20f;
-			this.bodyIdx = 4;
+			this.bodyIdx = (VOID_SaveValue<int>)4;
 
 			this.stylesApplied = false;
 			this.showBodyList = false;
-			this.showColumnSelection = false;
 
 			this.bodyListPos = new Rect();
 
@@ -87,20 +102,34 @@
 
 			this.stageTimeCol = new Table.Column<string>("Burn Time", 20f);
 			this.stageTable.Add(this.stageTimeCol);
-		}
-
-		public override void DrawGUI()
-		{
-			base.DrawGUI();
+
+			this.showAdvanced = false;
+
+			this.useSeaLevel = (VOID_SaveValue<bool>)false;
+
+			seaLevelToggle = new GUIContent(
+				"Use Sea Level",
+				"Use 'sea' level atmospheric conditions on bodies with atmospheres."
+			);
+		}
+
+		public override void DrawGUI(object sender)
+		{
+			base.DrawGUI(sender);
 
 			if (this.showBodyList)
 			{
-				GUILayout.Window(core.windowID, this.bodyListPos, this.BodyPickerWindow, string.Empty);
-			}
-		}
-
-		public override void ModuleWindow(int _)
-		{
+				GUILayout.Window(core.WindowID, this.bodyListPos, this.BodyPickerWindow, string.Empty);
+			}
+		}
+
+		public override void ModuleWindow(int id)
+		{
+			if (this.selectedBody == null)
+			{
+				this.selectedBody = core.HomeBody;
+			}
+
 			if (
 				!HighLogic.LoadedSceneIsFlight ||
 				(TimeWarp.WarpMode == TimeWarp.Modes.LOW) ||
@@ -129,8 +158,20 @@
 				return;
 			}
 
-			foreach (Stage stage in core.Stages)
-			{
+			if (HighLogic.LoadedSceneIsEditor && this.selectedBody.atmosphere && this.useSeaLevel)
+			{
+				SimManager.Atmosphere = this.selectedBody.GetPressure(0) * PhysicsGlobals.KpaToAtmospheres;
+			}
+			else
+			{
+				SimManager.Atmosphere = 0d;
+			}
+
+			Stage stage;
+			for (int idx = 0; idx < core.Stages.Length; idx++)
+			{
+				stage = core.Stages[idx];
+
 				if (stage.deltaV == 0 && stage.mass == 0)
 				{
 					continue;
@@ -153,13 +194,13 @@
 
 			this.stageTable.Render();
 
-			if (core.sortedBodyList != null)
+			if (core.SortedBodyList != null)
 			{
 				GUILayout.BeginHorizontal();
 
 				if (GUILayout.Button("◄"))
 				{
-					this.bodyIdx--;
+					this.bodyIdx.value--;
 				}
 
 				this.showBodyList = GUILayout.Toggle(
@@ -179,21 +220,43 @@
 
 				if (GUILayout.Button("►"))
 				{
-					this.bodyIdx++;
-				}
-
-				this.bodyIdx %= core.sortedBodyList.Count;
+					this.bodyIdx.value++;
+				}
+
+				this.bodyIdx.value %= core.SortedBodyList.Count;
 
 				if (this.bodyIdx < 0)
 				{
-					this.bodyIdx += core.sortedBodyList.Count;
+					this.bodyIdx.value += core.SortedBodyList.Count;
 				}
 
 				if (this.lastIdx != this.bodyIdx)
 				{
 					this.lastIdx = this.bodyIdx;
-					this.selectedBody = core.sortedBodyList[this.bodyIdx];
-				}
+					this.selectedBody = core.SortedBodyList[this.bodyIdx];
+				}
+
+				if (HighLogic.LoadedSceneIsEditor)
+				{
+					if (
+						GUILayout.Button(
+							this.showAdvanced ? "▲" : "▼",
+							GUILayout.ExpandWidth(false)
+						)
+					)
+					{
+						this.showAdvanced = !this.showAdvanced;
+					}
+				}
+
+				GUILayout.EndHorizontal();
+			}
+
+			if (this.showAdvanced && HighLogic.LoadedSceneIsEditor)
+			{
+				GUILayout.BeginHorizontal();
+
+				this.useSeaLevel.value = Layout.Toggle(this.useSeaLevel, this.seaLevelToggle, false);
 
 				GUILayout.EndHorizontal();
 			}
@@ -210,26 +273,24 @@
 
 			GUILayout.EndHorizontal();
 
-			GUI.DragWindow();
+			base.ModuleWindow(id);
 		}
 
 		public override void DrawConfigurables()
 		{
-			this.showColumnSelection = GUILayout.Toggle(
-				this.showColumnSelection,
-				"Select StageInfo Columns",
-				GUI.skin.button
-			);
+			
 		}
 
 		private void BodyPickerWindow(int _)
 		{
-			foreach (CelestialBody body in core.sortedBodyList)
-			{
+			CelestialBody body;
+			for (int idx = 0; idx < core.SortedBodyList.Count; idx++)
+			{
+				body = core.SortedBodyList[idx];
 				if (GUILayout.Button(body.bodyName, VOID_Styles.labelDefault))
 				{
 					Debug.Log("Picked new body focus: " + body.bodyName);
-					this.bodyIdx = core.sortedBodyList.IndexOf(body);
+					this.bodyIdx.value = core.SortedBodyList.IndexOf(body);
 					this.showBodyList = false;
 				}
 			}

--- a/VOID_Styles.cs
+++ b/VOID_Styles.cs
@@ -33,12 +33,6 @@
 {
 	public static class VOID_Styles
 	{
-		public static bool Ready
-		{
-			get;
-			private set;
-		}
-
 		public static GUIStyle labelDefault
 		{
 			get;
@@ -115,17 +109,12 @@
 
 			labelGreen = new GUIStyle(GUI.skin.label);
 			labelGreen.normal.textColor = Color.green;
-
-			Ready = true;
 		}
 
 		static VOID_Styles()
 		{
 			OnSkinChanged();
-
-			Ready = false;
 		}
 	}
 }
 
-

--- a/VOID_SurfAtmo.cs
+++ b/VOID_SurfAtmo.cs
@@ -36,76 +36,80 @@
 	public class VOID_SurfAtmo : VOID_WindowModule
 	{
 		[AVOID_SaveValue("precisionValues")]
-		protected long _precisionValues = 230584300921369395;
+		protected VOID_SaveValue<long> _precisionValues;
 		protected IntCollection precisionValues;
 
 		public VOID_SurfAtmo()
 		{
-			this.Name = "Surface & Atmospheric Information";
+			this.Name = "Surface & Atmospheric Info";
 
 			this.WindowPos.x = Screen.width - 260f;
 			this.WindowPos.y = 85;
+
+			this._precisionValues = (VOID_SaveValue<long>)384307168202282325;
 		}
 
-		public override void ModuleWindow(int _)
+		public override void ModuleWindow(int id)
 		{
 			int idx = 0;
 
 			GUILayout.BeginVertical();
 
-			this.precisionValues [idx]= (ushort)VOID_Data.trueAltitude.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues[idx] = (ushort)VOID_Data.trueAltitude.DoGUIHorizontal(this.precisionValues[idx]);
 			idx++;
 
-			VOID_Data.surfLatitude.DoGUIHorizontal ();
+			VOID_Data.surfLatitudeString.DoGUIHorizontal();
 
-			VOID_Data.surfLongitude.DoGUIHorizontal ();
+			VOID_Data.surfLongitudeString.DoGUIHorizontal();
 
-			VOID_Data.vesselHeading.DoGUIHorizontal ();
+			VOID_Data.vesselHeading.DoGUIHorizontal();
 
-			this.precisionValues [idx]= (ushort)VOID_Data.terrainElevation.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues[idx] = (ushort)VOID_Data.terrainElevation.DoGUIHorizontal(this.precisionValues[idx]);
 			idx++;
 
 			this.precisionValues[idx] = (ushort)VOID_Data.downrangeDistance.DoGUIHorizontal(this.precisionValues[idx]);
 			idx++;
 
-			this.precisionValues [idx]= (ushort)VOID_Data.surfVelocity.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues[idx] = (ushort)VOID_Data.surfVelocity.DoGUIHorizontal(this.precisionValues[idx]);
 			idx++;
 
-			this.precisionValues [idx]= (ushort)VOID_Data.vertVelocity.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues[idx] = (ushort)VOID_Data.vertVelocity.DoGUIHorizontal(this.precisionValues[idx]);
 			idx++;
 
-			this.precisionValues [idx]= (ushort)VOID_Data.horzVelocity.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues[idx] = (ushort)VOID_Data.horzVelocity.DoGUIHorizontal(this.precisionValues[idx]);
 			idx++;
 
-			VOID_Data.temperature.DoGUIHorizontal ("F2");
+			VOID_Data.temperature.DoGUIHorizontal("F2");
 
-			this.precisionValues [idx]= (ushort)VOID_Data.atmDensity.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues[idx] = (ushort)VOID_Data.atmDensity.DoGUIHorizontal(this.precisionValues[idx]);
 			idx++;
 
-			VOID_Data.atmPressure.DoGUIHorizontal ("F2");
+			this.precisionValues[idx] = (ushort)VOID_Data.atmPressure.DoGUIHorizontal(this.precisionValues[idx]);
+			idx++;
 
-			this.precisionValues [idx]= (ushort)VOID_Data.atmLimit.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues[idx] = (ushort)VOID_Data.atmLimit.DoGUIHorizontal(this.precisionValues[idx]);
 			idx++;
 
 			// Toadicus edit: added Biome
-			VOID_Data.currBiome.DoGUIHorizontal ();
+			VOID_Data.currBiome.DoGUIHorizontal();
 
 			GUILayout.EndVertical();
-			GUI.DragWindow();
+
+			base.ModuleWindow(id);
 		}
 
-		public override void LoadConfig ()
+		public override void LoadConfig(KSP.IO.PluginConfiguration config)
 		{
-			base.LoadConfig ();
+			base.LoadConfig(config);
 
-			this.precisionValues = new IntCollection (4, this._precisionValues);
+			this.precisionValues = new IntCollection(4, this._precisionValues);
 		}
 
-		public override void _SaveToConfig (KSP.IO.PluginConfiguration config)
+		public override void Save(KSP.IO.PluginConfiguration config, string sceneKey)
 		{
-			this._precisionValues = this.precisionValues.collection;
+			this._precisionValues.value = this.precisionValues.collection;
 
-			base._SaveToConfig (config);
+			base.Save(config, sceneKey);
 		}
 	}
 }

--- a/VOID_TWR.cs
+++ b/VOID_TWR.cs
@@ -3,11 +3,9 @@
 // This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a
 // copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/
 
+using KerbalEngineer.VesselSimulator;
 using KSP;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using ToadicusTools;
 using UnityEngine;
 
 namespace VOID
@@ -20,7 +18,7 @@
 			this.Name = "IP Thrust-to-Weight Ratios";
 		}
 
-		public override void ModuleWindow(int _)
+		public override void ModuleWindow(int id)
 		{
 			if (
 				!HighLogic.LoadedSceneIsFlight ||
@@ -28,12 +26,12 @@
 				(TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate)
 			)
 			{
-				KerbalEngineer.VesselSimulator.SimManager.RequestSimulation();
+				SimManager.RequestSimulation();
 			}
 
 			GUILayout.BeginVertical();
 
-			if (core.sortedBodyList == null)
+			if (core.SortedBodyList == null)
 			{
 				GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 
@@ -43,8 +41,11 @@
 			}
 			else
 			{
-				foreach (CelestialBody body in core.sortedBodyList)
+				CelestialBody body;
+				for (int idx = 0; idx < core.SortedBodyList.Count; idx++)
 				{
+					body = core.SortedBodyList[idx];
+
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 
 					GUILayout.Label(body.bodyName);
@@ -60,7 +61,7 @@
 
 			GUILayout.EndVertical();
 
-			GUI.DragWindow();
+			base.ModuleWindow(id);
 		}
 	}
 }

--- a/VOID_Transfer.cs
+++ b/VOID_Transfer.cs
@@ -29,7 +29,6 @@
 using KSP;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using ToadicusTools;
 using UnityEngine;
 
@@ -48,14 +47,18 @@
 			this.defWidth = 315;
 		}
 
-		public override void ModuleWindow(int _)
+		public override void ModuleWindow(int id)
 		{
+			CelestialBody body;
+
 			GUILayout.BeginVertical();
 
-			if (vessel.mainBody.name == "Sun")  //Vessel is orbiting the Sun
+			if (Vessel.mainBody.name == "Sun")  //Vessel is orbiting the Sun
 			{
-			    foreach (CelestialBody body in vessel.mainBody.orbitingBodies)
+			    for (int idx = 0; idx < Vessel.mainBody.orbitingBodies.Count; idx++)
 			    {
+					body = Vessel.mainBody.orbitingBodies[idx];
+
 					GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 					if (GUILayout.Button(body.bodyName))
 					{
@@ -68,16 +71,17 @@
 
 					if (selectedBodies.Contains(body))
 					{
-						VOID_Tools.display_transfer_angles_SUN2PLANET(body, vessel);  //show phase angles for each selected body
+						VOID_Tools.display_transfer_angles_SUN2PLANET(body, Vessel);  //show phase angles for each selected body
 						tad_targeting(body);    //display Set/Unset Target button for each selected body
 					}
 			    }
 			}
-			else if (vessel.mainBody.referenceBody.name == "Sun")	//Vessel is orbiting a planet
+			else if (Vessel.mainBody.referenceBody.name == "Sun")	//Vessel is orbiting a planet
 			{
-			    foreach (CelestialBody body in vessel.mainBody.referenceBody.orbitingBodies)
-			    {
-			        if (body.name != vessel.mainBody.name)	// show other planets
+			    for (int idx = 0; idx < Vessel.mainBody.referenceBody.orbitingBodies.Count; idx++)
+				{
+					body = Vessel.mainBody.referenceBody.orbitingBodies[idx];
+			        if (body.name != Vessel.mainBody.name)	// show other planets
 			        {
 			            GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 			            if (GUILayout.Button(body.bodyName))
@@ -91,13 +95,15 @@
 
 			            if (selectedBodies.Contains(body))
 			            {
-			                VOID_Tools.display_transfer_angles_PLANET2PLANET(body, vessel);
+			                VOID_Tools.display_transfer_angles_PLANET2PLANET(body, Vessel);
 			                tad_targeting(body);    //display Set/Unset Target button
 			            }
 			        }
 			    }
-			    foreach (CelestialBody body in vessel.mainBody.orbitingBodies)	// show moons
+			    for (int moonIdx = 0; moonIdx < Vessel.mainBody.orbitingBodies.Count; moonIdx++)
 			    {
+					body = Vessel.mainBody.orbitingBodies[moonIdx];
+
 			        GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 			        if (GUILayout.Button(body.bodyName))
 			        {
@@ -110,16 +116,18 @@
 
 			        if (selectedBodies.Contains(body))
 			        {
-			            VOID_Tools.display_transfer_angles_PLANET2MOON(body, vessel);
+			            VOID_Tools.display_transfer_angles_PLANET2MOON(body, Vessel);
 			            tad_targeting(body);    //display Set/Unset Target button
 			        }
 			    }
 			}
-			else if (vessel.mainBody.referenceBody.referenceBody.name == "Sun")	// Vessel is orbiting a moon
+			else if (Vessel.mainBody.referenceBody.referenceBody.name == "Sun")	// Vessel is orbiting a moon
 			{
-			    foreach (CelestialBody body in vessel.mainBody.referenceBody.orbitingBodies)
+			    for (int idx = 0; idx < Vessel.mainBody.referenceBody.orbitingBodies.Count; idx++)
 			    {
-					if (body.name != vessel.mainBody.name)	// show other moons
+					body = Vessel.mainBody.referenceBody.orbitingBodies[idx];
+
+					if (body.name != Vessel.mainBody.name)	// show other moons
 					{
 						GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 						if (GUILayout.Button(body.bodyName))
@@ -133,14 +141,15 @@
 
 						if (selectedBodies.Contains(body))
 						{
-							VOID_Tools.display_transfer_angles_MOON2MOON(body, vessel);
+							VOID_Tools.display_transfer_angles_MOON2MOON(body, Vessel);
 							tad_targeting(body);    //display Set/Unset Target button
 						}
 					}
 				}
 			}
 			GUILayout.EndVertical();
-			GUI.DragWindow();
+
+			base.ModuleWindow(id);
 		}
 
 		private void tad_targeting(CelestialBody body)
@@ -154,7 +163,7 @@
 		            if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false)))
 		            {
 		                FlightGlobals.fetch.SetVesselTarget(body);
-						Tools.PostDebugMessage("[VOID] KSP Target set to CelestialBody " + body.bodyName);
+						Logging.PostDebugMessage("[VOID] KSP Target set to CelestialBody " + body.bodyName);
 		            }
 		        }
 		        else if ((CelestialBody)FlightGlobals.fetch.VesselTarget == body)
@@ -162,7 +171,7 @@
 		            if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false)))
 		            {
 		                FlightGlobals.fetch.SetVesselTarget(null);
-		                Tools.PostDebugMessage("[VOID] KSP Target set to null");
+		                Logging.PostDebugMessage("[VOID] KSP Target set to null");
 		            }
 		        }
 		    }
@@ -172,7 +181,7 @@
 		        if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false)))
 		        {
 		            FlightGlobals.fetch.SetVesselTarget(body);
-		            Tools.PostDebugMessage("[VOID] KSP Target set to CelestialBody " + body.bodyName);
+		            Logging.PostDebugMessage("[VOID] KSP Target set to CelestialBody " + body.bodyName);
 		        }
 		    }
 		}

--- a/VOID_VesselInfo.cs
+++ b/VOID_VesselInfo.cs
@@ -31,7 +31,6 @@
 using KSP;
 using System;
 using System.Collections.Generic;
-using ToadicusTools;
 using UnityEngine;
 
 namespace VOID
@@ -46,7 +45,7 @@
 			this.WindowPos.y = 450;
 		}
 
-		public override void ModuleWindow(int _)
+		public override void ModuleWindow(int id)
 		{
 			if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) || (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate))
 			{
@@ -56,37 +55,37 @@
 			GUILayout.BeginVertical();
 
 			GUILayout.Label(
-				vessel.vesselName,
+				Vessel.vesselName,
 				VOID_Styles.labelCenterBold,
 				GUILayout.ExpandWidth(true));
 
-			VOID_Data.geeForce.DoGUIHorizontal ("F2");
+			VOID_Data.geeForce.DoGUIHorizontal("F2");
 
-			VOID_Data.partCount.DoGUIHorizontal ();
+			VOID_Data.partCount.DoGUIHorizontal();
 
-			VOID_Data.totalMass.DoGUIHorizontal ("F3");
+			VOID_Data.totalMass.DoGUIHorizontal("F3");
 
-			VOID_Data.stageResourceMass.DoGUIHorizontal("F2");
+			VOID_Data.stageResourceMass.DoGUIHorizontal("F3");
 
-			VOID_Data.resourceMass.DoGUIHorizontal("F2");
+			VOID_Data.resourceMass.DoGUIHorizontal("F3");
 
-			VOID_Data.stageDeltaV.DoGUIHorizontal (3, false);
+			VOID_Data.stageDeltaV.DoGUIHorizontal(3, false);
 
-			VOID_Data.totalDeltaV.DoGUIHorizontal (3, false);
+			VOID_Data.totalDeltaV.DoGUIHorizontal(3, false);
 
-			VOID_Data.mainThrottle.DoGUIHorizontal ("F0");
+			VOID_Data.mainThrottle.DoGUIHorizontal("P0");
 
-			VOID_Data.currmaxThrust.DoGUIHorizontal ();
+			VOID_Data.currmaxThrust.DoGUIHorizontal();
 
-			VOID_Data.currmaxThrustWeight.DoGUIHorizontal ();
+			VOID_Data.currmaxThrustWeight.DoGUIHorizontal();
 
-			VOID_Data.surfaceThrustWeight.DoGUIHorizontal ("F2");
+			VOID_Data.surfaceThrustWeight.DoGUIHorizontal("F2");
 
 			VOID_Data.intakeAirStatus.DoGUIHorizontal();
 
 			GUILayout.EndVertical();
 
-			GUI.DragWindow();
+			base.ModuleWindow(id);
 		}
 	}
 }

--- a/VOID_VesselRegister.cs
+++ b/VOID_VesselRegister.cs
@@ -28,8 +28,6 @@
 
 using KSP;
 using System;
-using System.Linq;
-using ToadicusTools;
 using UnityEngine;
 
 namespace VOID
@@ -37,16 +35,16 @@
 	public class VOID_VesselRegister : VOID_WindowModule
 	{
 		[AVOID_SaveValue("selectedBodyIdx")]
-		protected VOID_SaveValue<int> selectedBodyIdx = 0;
+		protected VOID_SaveValue<int> selectedBodyIdx;
 		protected CelestialBody seletedBody;
 
 		[AVOID_SaveValue("selectedVesselTypeIdx")]
-		protected VOID_SaveValue<int> selectedVesselTypeIdx = 0;
+		protected VOID_SaveValue<int> selectedVesselTypeIdx;
 		protected VesselType selectedVesselType;
 
-		protected string vesselSituation = "Orbiting";
+		protected string vesselSituation;
 
-		protected Vector2 selectorScrollPos = new Vector2();
+		protected Vector2 selectorScrollPos;
 
 		protected Vessel _selectedVessel;
 
@@ -65,13 +63,30 @@
 			this.WindowPos.x = 845;
 			this.WindowPos.y = 275;
 			this.defHeight = 375;
+
+			this.selectedBodyIdx = (VOID_SaveValue<int>)0;
+			this.selectedVesselTypeIdx = (VOID_SaveValue<int>)0;
+
+			this.vesselSituation = "Orbiting";
+
+			this.selectorScrollPos = new Vector2();
 		}
 
-		public override void ModuleWindow(int _)
+		public override void ModuleWindow(int id)
 		{
-			if (!this.core.allVesselTypes.Any())
+			if (this.core.AllVesselTypes.Length < 1)
 			{
 				return;
+			}
+
+			if (selectedBodyIdx >= this.core.SortedBodyList.Count)
+			{
+				selectedBodyIdx.value %= this.core.SortedBodyList.Count;
+			}
+
+			if (selectedBodyIdx < 0)
+			{
+				selectedBodyIdx.value += this.core.SortedBodyList.Count;
 			}
 
 			GUILayout.BeginVertical();
@@ -79,34 +94,46 @@
 			GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 			if (GUILayout.Button("<"))
 			{
-				selectedBodyIdx--;
-				if (selectedBodyIdx < 0) selectedBodyIdx = this.core.allBodies.Count - 1;
+				selectedBodyIdx.value--;
+				if (selectedBodyIdx < 0)
+				{
+					selectedBodyIdx.value = this.core.SortedBodyList.Count - 1;
+				}
 			}
-			GUILayout.Label(this.core.allBodies[selectedBodyIdx].bodyName, VOID_Styles.labelCenterBold, GUILayout.ExpandWidth(true));
+			GUILayout.Label(this.core.SortedBodyList[selectedBodyIdx].bodyName, VOID_Styles.labelCenterBold, GUILayout.ExpandWidth(true));
 			if (GUILayout.Button(">"))
 			{
-				selectedBodyIdx++;
-				if (selectedBodyIdx > this.core.allBodies.Count - 1) selectedBodyIdx = 0;
+				selectedBodyIdx.value++;
+				if (selectedBodyIdx > this.core.SortedBodyList.Count - 1)
+				{
+					selectedBodyIdx.value = 0;
+				}
 			}
 			GUILayout.EndHorizontal();
 
-			seletedBody = this.core.allBodies[selectedBodyIdx];
+			seletedBody = this.core.SortedBodyList[selectedBodyIdx];
 
 			GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 			if (GUILayout.Button("<"))
 			{
-				selectedVesselTypeIdx--;
-				if (selectedVesselTypeIdx < 0) selectedVesselTypeIdx = this.core.allVesselTypes.Count - 1;
+				selectedVesselTypeIdx.value--;
+				if (selectedVesselTypeIdx < 0)
+				{
+					selectedVesselTypeIdx.value = this.core.AllVesselTypes.Length - 1;
+				}
 			}
-			GUILayout.Label(this.core.allVesselTypes[selectedVesselTypeIdx].ToString(), VOID_Styles.labelCenterBold, GUILayout.ExpandWidth(true));
+			GUILayout.Label(this.core.AllVesselTypes[selectedVesselTypeIdx].ToString(), VOID_Styles.labelCenterBold, GUILayout.ExpandWidth(true));
 			if (GUILayout.Button(">"))
 			{
-				selectedVesselTypeIdx++;
-				if (selectedVesselTypeIdx > this.core.allVesselTypes.Count - 1) selectedVesselTypeIdx = 0;
+				selectedVesselTypeIdx.value++;
+				if (selectedVesselTypeIdx > this.core.AllVesselTypes.Length - 1)
+				{
+					selectedVesselTypeIdx.value = 0;
+				}
 			}
 			GUILayout.EndHorizontal();
 
-			selectedVesselType = this.core.allVesselTypes[selectedVesselTypeIdx];
+			selectedVesselType = this.core.AllVesselTypes[selectedVesselTypeIdx];
 
 			GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 			if (GUILayout.Button("Landed", GUILayout.ExpandWidth(true))) vesselSituation = "Landed";
@@ -122,9 +149,12 @@
 
 			selectorScrollPos = GUILayout.BeginScrollView(selectorScrollPos, false, false);
 
-			foreach (Vessel v in FlightGlobals.Vessels)
+			Vessel v;
+			for (int idx = 0; idx < FlightGlobals.Vessels.Count; idx++)
 			{
-				if (v != vessel && v.vesselType == selectedVesselType && v.mainBody == seletedBody)
+				v = FlightGlobals.Vessels[idx];
+
+				if (v != Vessel && v.vesselType == selectedVesselType && v.mainBody == seletedBody)
 				{
 					if ((vesselSituation == "Landed" &&
 					     (v.situation == Vessel.Situations.LANDED ||
@@ -142,7 +172,7 @@
 							if (_selectedVessel != v)
 							{
 								_selectedVessel = v; //set clicked vessel as selected_vessel
-								this.toggleActive = true;    //turn bool on to open the window if closed
+								this.Active = true;    //turn bool on to open the window if closed
 							}
 							else
 							{
@@ -157,7 +187,7 @@
 
 			GUILayout.EndVertical();
 
-			GUI.DragWindow();
+			base.ModuleWindow(id);
 		}
 	}
 }