Preliminary new references, usings, and code changes to compile for KSP 1.1.
Preliminary new references, usings, and code changes to compile for KSP 1.1.

--- a/Averager.cs
+++ b/Averager.cs
@@ -18,49 +18,50 @@
 // 
 
 using System;
+using UnityEngine;
 
 namespace KerbalEngineer
 { 
     public class VectorAverager
     {
-        private Vector3d sum = Vector3d.zero;
+        private Vector3 sum = Vector3.zero;
         private uint count = 0;
 
-        public void Add(Vector3d v) {
+        public void Add(Vector3 v) {
             sum += v;
             count += 1;
         }
 
-        public Vector3d Get() {
+        public Vector3 Get() {
             if (count > 0) {
                 return sum / count;
             } else {
-                return Vector3d.zero;
+                return Vector3.zero;
             }
         }
 
         public void Reset()
         {
-            sum = Vector3d.zero;
+            sum = Vector3.zero;
             count = 0;
         }
     }
 
     public class WeightedVectorAverager
     {
-        private Vector3d sum = Vector3d.zero;
+        private Vector3 sum = Vector3.zero;
         private double totalweight = 0;
 
-        public void Add(Vector3d v, double weight) {
-            sum += v * weight;
+        public void Add(Vector3 v, double weight) {
+            sum += v * (float)weight;
             totalweight += weight;
         }
 
-        public Vector3d Get() {
+        public Vector3 Get() {
             if (totalweight > 0) {
-                return sum / totalweight;
+                return sum / (float)totalweight;
             } else {
-                return Vector3d.zero;
+                return Vector3.zero;
             }
         }
 
@@ -70,7 +71,7 @@
 
         public void Reset()
         {
-            sum = Vector3d.zero;
+            sum = Vector3.zero;
             totalweight = 0.0;
         }
     }

--- a/EngineSim.cs
+++ b/EngineSim.cs
@@ -194,10 +194,10 @@
             for (int i = 0; i < thrustTransforms.Count; i++)
             {
                 Transform thrustTransform = thrustTransforms[i];
-                Vector3d direction = thrustTransform.forward.normalized;
-                Vector3d position = thrustTransform.position;
-
-                AppliedForce appliedForce = AppliedForce.New(direction * thrustPerThrustTransform, position);
+                Vector3 direction = thrustTransform.forward.normalized;
+                Vector3 position = thrustTransform.position;
+
+                AppliedForce appliedForce = AppliedForce.New(direction * (float)thrustPerThrustTransform, position);
                 engineSim.appliedForces.Add(appliedForce);
             }
 

--- a/ForceAccumulator.cs
+++ b/ForceAccumulator.cs
@@ -20,6 +20,7 @@
 using System;
 using System.Collections.Generic;
 using KerbalEngineer.VesselSimulator;
+using UnityEngine;
 
 namespace KerbalEngineer
 {
@@ -28,8 +29,8 @@
     {
         private static readonly Pool<AppliedForce> pool = new Pool<AppliedForce>(Create, Reset);
 
-        public Vector3d vector;
-        public Vector3d applicationPoint;
+        public Vector3 vector;
+        public Vector3 applicationPoint;
 
         static private AppliedForce Create()
         {
@@ -38,7 +39,7 @@
 
         static private void Reset(AppliedForce appliedForce) { }
 
-        static public AppliedForce New(Vector3d vector, Vector3d applicationPoint)
+        static public AppliedForce New(Vector3 vector, Vector3 applicationPoint)
         {
             AppliedForce force = pool.Borrow();
             force.vector = vector;
@@ -68,22 +69,22 @@
 	public class ForceAccumulator
 	{
 	    // Total force.
-		private Vector3d totalForce = Vector3d.zero;
+		private Vector3 totalForce = Vector3.zero;
 		// Torque needed to compensate if force were applied at origin.
-		private Vector3d totalZeroOriginTorque = Vector3d.zero;
+		private Vector3 totalZeroOriginTorque = Vector3.zero;
 
 		// Weighted average of force application points.
 		private WeightedVectorAverager avgApplicationPoint = new WeightedVectorAverager();
 
 		// Feed an force to the accumulator.
-		public void AddForce(Vector3d applicationPoint, Vector3d force)
+		public void AddForce(Vector3 applicationPoint, Vector3 force)
 		{
 			totalForce += force;
-			totalZeroOriginTorque += Vector3d.Cross(applicationPoint, force);
+			totalZeroOriginTorque += Vector3.Cross(applicationPoint, force);
 			avgApplicationPoint.Add(applicationPoint, force.magnitude);
 		}
 
-        public Vector3d GetAverageForceApplicationPoint() {
+        public Vector3 GetAverageForceApplicationPoint() {
             return avgApplicationPoint.Get();
         }
 
@@ -92,38 +93,38 @@
         }
 
 		// Residual torque for given force application point.
-		public Vector3d TorqueAt(Vector3d origin)
+		public Vector3 TorqueAt(Vector3 origin)
 		{
-			return totalZeroOriginTorque - Vector3d.Cross(origin, totalForce);
+			return totalZeroOriginTorque - Vector3.Cross(origin, totalForce);
 		}
 
         // Total force vector.
-        public Vector3d GetTotalForce()
+        public Vector3 GetTotalForce()
         {
             return totalForce;
         }
 
         // Returns the minimum-residual-torque force application point that is closest to origin.
         // Note that TorqueAt(GetMinTorquePos()) is always parallel to totalForce.
-        public Vector3d GetMinTorqueForceApplicationPoint(Vector3d origin)
+        public Vector3 GetMinTorqueForceApplicationPoint(Vector3 origin)
         {
             double fmag = totalForce.sqrMagnitude;
             if (fmag <= 0) {
                 return origin;
             }
 
-            return origin + Vector3d.Cross(totalForce, TorqueAt(origin)) / fmag;
+            return origin + Vector3.Cross(totalForce, TorqueAt(origin)) / (float)fmag;
         }
 
-        public Vector3d GetMinTorqueForceApplicationPoint()
+        public Vector3 GetMinTorqueForceApplicationPoint()
         {
             return GetMinTorqueForceApplicationPoint(avgApplicationPoint.Get());
         }
 
 	    public void Reset()
 	    {
-	        totalForce = Vector3d.zero;
-	        totalZeroOriginTorque = Vector3d.zero;
+	        totalForce = Vector3.zero;
+	        totalZeroOriginTorque = Vector3.zero;
             avgApplicationPoint.Reset();
 	    }
 	}

file:a/PartSim.cs -> file:b/PartSim.cs
--- a/PartSim.cs
+++ b/PartSim.cs
@@ -37,7 +37,7 @@
         public double realMass;
         public double baseMass;
         public double baseMassForCoM;
-        public Vector3d centerOfMass;
+        public Vector3 centerOfMass;
         public double baseCost;
         public int decoupledInStage;
         public bool fuelCrossFeed;

--- a/Simulation.cs
+++ b/Simulation.cs
@@ -59,7 +59,7 @@
         private List<Part> partList = new List<Part>();
         private double simpleTotalThrust;
         private double stageStartMass;
-        private Vector3d stageStartCom;
+        private Vector3 stageStartCom;
         private double stageTime;
         private double stepEndMass;
         private double stepStartMass;
@@ -110,7 +110,7 @@
             }
         }
 
-        private Vector3d ShipCom
+        private Vector3 ShipCom
         {
             get
             {

--- a/VesselSimulator.csproj
+++ b/VesselSimulator.csproj
@@ -103,6 +103,12 @@
     <Reference Include="UnityEngine">
       <HintPath>..\_KSPAssemblies\UnityEngine.dll</HintPath>
     </Reference>
+    <Reference Include="UnityEngine.UI">
+      <HintPath>..\_KSPAssemblies\UnityEngine.UI.dll</HintPath>
+    </Reference>
+    <Reference Include="KSPUtil">
+      <HintPath>..\_KSPAssemblies\KSPUtil.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ProjectExtensions>
     <MonoDevelop>