diff --git a/Analytical_Engine/Convert/Graph/ToRelation.cs b/Analytical_Engine/Convert/Graph/ToRelation.cs
index 68b8faf24..e0f6a85a9 100644
--- a/Analytical_Engine/Convert/Graph/ToRelation.cs
+++ b/Analytical_Engine/Convert/Graph/ToRelation.cs
@@ -172,17 +172,17 @@ public static IRelation ToRelation<TNode>(this ILink<TNode> link)
         {
             Relation relation = new Relation()
             {
-                Source = link.StartNode.BHoM_Guid,
-                Target = link.EndNode.BHoM_Guid,
+                Source = link.Start.BHoM_Guid,
+                Target = link.End.BHoM_Guid,
                 Curve = (ICurve)link.IGeometry(),
             };
 
             Graph subgraph = new Graph();
-            subgraph.Entities.Add(link.StartNode.BHoM_Guid, link.StartNode);
-            subgraph.Entities.Add(link.EndNode.BHoM_Guid, link.EndNode);
+            subgraph.Entities.Add(link.Start.BHoM_Guid, link.Start);
+            subgraph.Entities.Add(link.End.BHoM_Guid, link.End);
             subgraph.Entities.Add(link.BHoM_Guid, link);
-            subgraph.Relations.Add(new Relation() { Source = link.StartNode.BHoM_Guid, Target = link.BHoM_Guid });
-            subgraph.Relations.Add(new Relation() { Source = link.BHoM_Guid, Target = link.StartNode.BHoM_Guid });
+            subgraph.Relations.Add(new Relation() { Source = link.Start.BHoM_Guid, Target = link.BHoM_Guid });
+            subgraph.Relations.Add(new Relation() { Source = link.BHoM_Guid, Target = link.Start.BHoM_Guid });
             relation.Subgraph = subgraph;
 
             return relation;
diff --git a/Analytical_Engine/Modify/SetElements0D.cs b/Analytical_Engine/Modify/SetElements0D.cs
index c991a798b..bb5590c6b 100644
--- a/Analytical_Engine/Modify/SetElements0D.cs
+++ b/Analytical_Engine/Modify/SetElements0D.cs
@@ -58,21 +58,21 @@ public static ILink<TNode> SetElements0D<TNode>(this ILink<TNode> link, List<IEl
             if (newElements0D[0] is Point)
             {
                 //clone.StartNode = new TNode() { Position = newElements0D[0] as Point };
-                clone.StartNode = Activator.CreateInstance<TNode>();
-                clone.StartNode.Position = newElements0D[0] as Point;
+                clone.Start = Activator.CreateInstance<TNode>();
+                clone.Start.Position = newElements0D[0] as Point;
             }
             else
-                clone.StartNode = (TNode)newElements0D[0];
+                clone.Start = (TNode)newElements0D[0];
 
             // Default the ILink end if the input is an Point
             if (newElements0D[1] is Point)
             {
                 //clone.EndNode = new TNode() { Position = newElements0D[1] as Point };
-                clone.EndNode = Activator.CreateInstance<TNode>();
-                clone.EndNode.Position = newElements0D[1] as Point;
+                clone.End = Activator.CreateInstance<TNode>();
+                clone.End.Position = newElements0D[1] as Point;
             }
             else
-                clone.EndNode = (TNode)newElements0D[1];
+                clone.End = (TNode)newElements0D[1];
 
             return clone;
         }
diff --git a/Analytical_Engine/Modify/SetGeometry.cs b/Analytical_Engine/Modify/SetGeometry.cs
index c223a26db..288ba4cb0 100644
--- a/Analytical_Engine/Modify/SetGeometry.cs
+++ b/Analytical_Engine/Modify/SetGeometry.cs
@@ -73,8 +73,8 @@ public static ILink<TNode> SetGeometry<TNode>(this ILink<TNode> link, ICurve cur
             }
 
             ILink<TNode> clone = link.ShallowClone();
-            clone.StartNode = (TNode)clone.StartNode.SetGeometry(curve.IStartPoint());
-            clone.EndNode = (TNode)clone.EndNode.SetGeometry(curve.IEndPoint());
+            clone.Start = (TNode)clone.Start.SetGeometry(curve.IStartPoint());
+            clone.End = (TNode)clone.End.SetGeometry(curve.IEndPoint());
             return clone;
         }
 
diff --git a/Analytical_Engine/Query/Elements0D.cs b/Analytical_Engine/Query/Elements0D.cs
index 725036649..3705b632a 100644
--- a/Analytical_Engine/Query/Elements0D.cs
+++ b/Analytical_Engine/Query/Elements0D.cs
@@ -43,7 +43,7 @@ public static partial class Query
         public static List<IElement0D> Elements0D<TNode>(this ILink<TNode> link)
             where TNode : INode
         {
-            return new List<IElement0D> { link.StartNode, link.EndNode };
+            return new List<IElement0D> { link.Start, link.End };
         }
 
         /******************************************/
diff --git a/Analytical_Engine/Query/Geometry.cs b/Analytical_Engine/Query/Geometry.cs
index 8a53305cc..14269bb2c 100644
--- a/Analytical_Engine/Query/Geometry.cs
+++ b/Analytical_Engine/Query/Geometry.cs
@@ -60,7 +60,7 @@ public static Point Geometry(this INode node)
         public static Line Geometry<TNode>(this ILink<TNode> link)
             where TNode : INode
         {
-            return new Line { Start = link?.StartNode?.Position, End = link?.EndNode?.Position };
+            return new Line { Start = link?.Start?.Position, End = link?.End?.Position };
         }
 
         /***************************************************/
diff --git a/Structure_Engine/Compute/MapTaperedProfile.cs b/Structure_Engine/Compute/MapTaperedProfile.cs
index 90a81d24c..ce415f9fe 100644
--- a/Structure_Engine/Compute/MapTaperedProfile.cs
+++ b/Structure_Engine/Compute/MapTaperedProfile.cs
@@ -42,8 +42,8 @@ public static partial class Compute
         /***************************************************/
         [Description("Maps a TaperedProfile to a series of sequential Bars by interpolating the profiles at the startNode and endNode of each bar using a polynomial defined by the interpolationOrder. " +
             "For nonlinear profiles a concave profile is achieved by setting the larger profile at the smallest position. To achieve a convex profile, the larger profile must be at the largest position.")]
-        [Input("section", "The section containing the TaperedProfile to be mapped to the series of Bars.")]
         [Input("bars", "The Bars in sequential order for the TaperedProfile to be mapped to.")]
+        [Input("section", "The section containing the TaperedProfile to be mapped to the series of Bars.")]
         [Output("bars", "The Bars with interpolated SectionProperties based on the TaperedProfile provided.")]
         public static List<Bar> MapTaperedProfile(List<Bar> bars, IGeometricalSection section)
         {
@@ -119,8 +119,8 @@ private static List<TaperedProfile> MapTaperedProfile(List<Bar> bars, TaperedPro
             //For each bar interpolate the profiles as necessary and create a TaperedProfile 
             foreach (Bar bar in bars)
             {
-                double startPosition = centreline.ParameterAtPoint(bar.StartNode.Position);
-                double endPosition = centreline.ParameterAtPoint(bar.EndNode.Position);
+                double startPosition = centreline.ParameterAtPoint(bar.Start.Position);
+                double endPosition = centreline.ParameterAtPoint(bar.End.Position);
                 double newLength = endPosition - startPosition;
 
                 List<double> positions = new List<double>(originalPositions);
diff --git a/Structure_Engine/Create/Elements/Bar.cs b/Structure_Engine/Create/Elements/Bar.cs
index 4540801df..a565d61be 100644
--- a/Structure_Engine/Create/Elements/Bar.cs
+++ b/Structure_Engine/Create/Elements/Bar.cs
@@ -56,8 +56,8 @@ public static Bar Bar(Line line, ISectionProperty sectionProperty = null, double
             return line.IsNull() ? null : new Bar
             {
                 Name = name,
-                StartNode = (Node)line.Start,
-                EndNode = (Node)line.End,
+                Start = (Node)line.Start,
+                End = (Node)line.End,
                 SectionProperty = sectionProperty,
                 Release = release == null ? BarReleaseFixFix() : release,
                 FEAType = feaType,
diff --git a/Structure_Engine/Create/Loads/BarVaryingDistributedLoad/BarVaryingDistributedLoadDistanceBothEnds.cs b/Structure_Engine/Create/Loads/BarVaryingDistributedLoad/BarVaryingDistributedLoadDistanceBothEnds.cs
index 28fc9b501..218c56e4d 100644
--- a/Structure_Engine/Create/Loads/BarVaryingDistributedLoad/BarVaryingDistributedLoadDistanceBothEnds.cs
+++ b/Structure_Engine/Create/Loads/BarVaryingDistributedLoad/BarVaryingDistributedLoadDistanceBothEnds.cs
@@ -52,12 +52,12 @@ public static partial class Create
                      "Method will group Bars by their length, according to the tolerance, and return one load for each group.")]
         [InputFromProperty("loadcase")]
         [InputFromProperty("group", "Objects")]
-        [Input("startToStartDistance", "Distance along each Bar from the StartNode to the start of the load.")]
-        [Input("endToEndDistance", "Distance along each Bar from the EndNode to the end of the load.")]
         [InputFromProperty("relativePositions")]
+        [Input("startToStartDistance", "Distance along each Bar from the StartNode to the start of the load.")]
         [InputFromProperty("forceAtStart")]
+        [InputFromProperty("momentAtStart")]       
+        [Input("endToEndDistance", "Distance along each Bar from the EndNode to the end of the load.")]         
         [InputFromProperty("forceAtEnd")]
-        [InputFromProperty("momentAtStart")]
         [InputFromProperty("momentAtEnd")]
         [InputFromProperty("axis")]
         [InputFromProperty("projected")]
@@ -105,12 +105,12 @@ public static List<BarVaryingDistributedLoad> BarVaryingDistributedLoadDistanceB
                              "Method will group Bars by their length, according to the tolerance, and return one load for each group.")]
         [InputFromProperty("loadcase")]
         [Input("objects", "The collection of Bars the load should be applied to.")]
-        [Input("startToStartDistance", "Distance along each Bar from the StartNode to the start of the load.")]
-        [Input("endToEndDistance", "Distance along each Bar from the EndNode to the end of the load.")]
         [InputFromProperty("relativePositions")]
+        [Input("startToStartDistance", "Distance along each Bar from the StartNode to the start of the load.")]
         [InputFromProperty("forceAtStart")]
-        [InputFromProperty("forceAtEnd")]
         [InputFromProperty("momentAtStart")]
+        [Input("endToEndDistance", "Distance along each Bar from the EndNode to the end of the load.")]
+        [InputFromProperty("forceAtEnd")]
         [InputFromProperty("momentAtEnd")]
         [InputFromProperty("axis")]
         [InputFromProperty("projected")]
@@ -139,7 +139,7 @@ public static List<BarVaryingDistributedLoad> BarVaryingDistributedLoadDistanceB
         private static Dictionary<double, List<Bar>> GroupBarsByLength(this IEnumerable<Bar> bars, double tolerance)
         {
             //Check that bars have valid geometry
-            bars = bars.Where(x => x != null && x.StartNode != null && x.EndNode != null && x.StartNode.Position != null && x.EndNode.Position != null);
+            bars = bars.Where(x => x != null && x.Start != null && x.End != null && x.Start.Position != null && x.End.Position != null);
 
             Dictionary<double, List<Bar>> dict = new Dictionary<double, List<Bar>>();
             foreach (var group in bars.GroupBy(x => (int)Math.Round(x.Length() / tolerance)))
diff --git a/Structure_Engine/Modify/Flip.cs b/Structure_Engine/Modify/Flip.cs
index 4910ff0b4..4d29c8b0c 100644
--- a/Structure_Engine/Modify/Flip.cs
+++ b/Structure_Engine/Modify/Flip.cs
@@ -47,9 +47,9 @@ public static Bar Flip(this Bar bar)
 
             Bar flipped = bar.ShallowClone();
 
-            Node tempNode = flipped.StartNode;
-            flipped.StartNode = flipped.EndNode;
-            flipped.EndNode = tempNode;
+            Node tempNode = flipped.Start;
+            flipped.Start = flipped.End;
+            flipped.End = tempNode;
 
             return flipped;
         }
diff --git a/Structure_Engine/Modify/SetElements0D.cs b/Structure_Engine/Modify/SetElements0D.cs
index eef20eade..4fea5588d 100644
--- a/Structure_Engine/Modify/SetElements0D.cs
+++ b/Structure_Engine/Modify/SetElements0D.cs
@@ -56,22 +56,22 @@ public static Bar SetElements0D(this Bar bar, List<IElement0D> newElements0D)
             // Default the Bars end if the input is an Point
             if (newElements0D[0] is Point)
             {
-                clone.StartNode = new Node { Position = newElements0D[0] as Point };
+                clone.Start = new Node { Position = newElements0D[0] as Point };
                 if (clone.Release != null)
                     clone.Release.StartRelease = Create.FixConstraint6DOF();
             }
             else
-                clone.StartNode = newElements0D[0] as Node;
+                clone.Start = newElements0D[0] as Node;
 
             // Default the Bars end if the input is an Point
             if (newElements0D[1] is Point)
             {
-                clone.EndNode = new Node { Position = newElements0D[1] as Point };
+                clone.End = new Node { Position = newElements0D[1] as Point };
                 if (clone.Release != null)
                     clone.Release.EndRelease = Create.FixConstraint6DOF();
             }
             else
-                clone.EndNode = newElements0D[1] as Node;
+                clone.End = newElements0D[1] as Node;
 
             return clone;
         }
diff --git a/Structure_Engine/Modify/Transform.cs b/Structure_Engine/Modify/Transform.cs
index eaa61f92e..a8ce46ca0 100644
--- a/Structure_Engine/Modify/Transform.cs
+++ b/Structure_Engine/Modify/Transform.cs
@@ -78,7 +78,7 @@ public static Bar Transform(this Bar bar, TransformMatrix transform, double tole
                 return null;
             }
 
-            if (bar.StartNode?.Position == null || bar.EndNode?.Position == null)
+            if (bar.Start?.Position == null || bar.End?.Position == null)
             {
                 BH.Engine.Base.Compute.RecordWarning("The bar could not be transformed because at least one of its nodes (or their location) is null.");
                 return bar;
@@ -91,12 +91,12 @@ public static Bar Transform(this Bar bar, TransformMatrix transform, double tole
             }
 
             Bar result = bar.ShallowClone();
-            result.StartNode = result.StartNode.Transform(transform, tolerance);
-            result.EndNode = result.EndNode.Transform(transform, tolerance);
+            result.Start = result.Start.Transform(transform, tolerance);
+            result.End = result.End.Transform(transform, tolerance);
 
-            Vector normalBefore = new Line { Start = bar.StartNode.Position, End = bar.EndNode.Position }.ElementNormal(bar.OrientationAngle);
+            Vector normalBefore = new Line { Start = bar.Start.Position, End = bar.End.Position }.ElementNormal(bar.OrientationAngle);
             Vector normalAfter = normalBefore.Transform(transform);
-            result.OrientationAngle = normalAfter.OrientationAngleLinear(new Line { Start = result.StartNode.Position, End = result.EndNode.Position });
+            result.OrientationAngle = normalAfter.OrientationAngleLinear(new Line { Start = result.Start.Position, End = result.End.Position });
 
             return result;
         }
diff --git a/Structure_Engine/Objects/EqualityComparers/BarEndNodesDistanceComparer.cs b/Structure_Engine/Objects/EqualityComparers/BarEndNodesDistanceComparer.cs
index 5bcc6305e..14c91443e 100644
--- a/Structure_Engine/Objects/EqualityComparers/BarEndNodesDistanceComparer.cs
+++ b/Structure_Engine/Objects/EqualityComparers/BarEndNodesDistanceComparer.cs
@@ -58,13 +58,13 @@ public bool Equals(Bar bar1, Bar bar2)
             if (Object.ReferenceEquals(bar1, null) || Object.ReferenceEquals(bar2, null))
                 return false;
 
-            if (m_nodeComparer.Equals(bar1.StartNode, bar2.StartNode))
+            if (m_nodeComparer.Equals(bar1.Start, bar2.Start))
             {
-                return m_nodeComparer.Equals(bar1.EndNode, bar2.EndNode);
+                return m_nodeComparer.Equals(bar1.End, bar2.End);
             }
-            else if (m_nodeComparer.Equals(bar1.StartNode, bar2.EndNode))
+            else if (m_nodeComparer.Equals(bar1.Start, bar2.End))
             {
-                return m_nodeComparer.Equals(bar1.EndNode, bar2.StartNode);
+                return m_nodeComparer.Equals(bar1.End, bar2.Start);
             }
 
             return false;
@@ -77,7 +77,7 @@ public int GetHashCode(Bar bar)
             //Check whether the object is null
             if (Object.ReferenceEquals(bar, null)) return 0;
 
-            return m_nodeComparer.GetHashCode(bar.StartNode) ^ m_nodeComparer.GetHashCode(bar.EndNode);
+            return m_nodeComparer.GetHashCode(bar.Start) ^ m_nodeComparer.GetHashCode(bar.End);
         }
 
 
diff --git a/Structure_Engine/Query/BarSectionTranformation.cs b/Structure_Engine/Query/BarSectionTranformation.cs
index a831f1213..231a86217 100644
--- a/Structure_Engine/Query/BarSectionTranformation.cs
+++ b/Structure_Engine/Query/BarSectionTranformation.cs
@@ -45,7 +45,7 @@ public static TransformMatrix BarSectionTranformation(this Bar bar)
             if (bar.IsNull())
                 return null;
 
-            Vector trans = bar.StartNode.Position - Point.Origin;
+            Vector trans = bar.Start.Position - Point.Origin;
 
             Vector gX = Vector.XAxis;
             Vector gY = Vector.YAxis;
diff --git a/Structure_Engine/Query/Centreline.cs b/Structure_Engine/Query/Centreline.cs
index 289e39192..9bd568568 100644
--- a/Structure_Engine/Query/Centreline.cs
+++ b/Structure_Engine/Query/Centreline.cs
@@ -38,7 +38,7 @@ public static partial class Query
         [Output("centreLine", "The centreline of the Bar.")]
         public static Line Centreline(this Bar bar)
         {
-            return bar.IsNull() ? null : new Line { Start = bar.StartNode.Position, End = bar.EndNode.Position };
+            return bar.IsNull() ? null : new Line { Start = bar.Start.Position, End = bar.End.Position };
         }
 
         /***************************************************/
diff --git a/Structure_Engine/Query/CoordinateSystem.cs b/Structure_Engine/Query/CoordinateSystem.cs
index f41675095..14727303a 100644
--- a/Structure_Engine/Query/CoordinateSystem.cs
+++ b/Structure_Engine/Query/CoordinateSystem.cs
@@ -56,7 +56,7 @@ public static Cartesian CoordinateSystem(this Bar bar)
         {
             Vector tan = bar?.Tangent(true);
             Vector ax = bar?.Normal()?.CrossProduct(tan);
-            return tan != null && ax != null ? Engine.Geometry.Create.CartesianCoordinateSystem(bar.StartNode.Position, tan, ax) : null;
+            return tan != null && ax != null ? Engine.Geometry.Create.CartesianCoordinateSystem(bar.Start.Position, tan, ax) : null;
         }
 
         /***************************************************/
diff --git a/Structure_Engine/Query/DeformedShape.cs b/Structure_Engine/Query/DeformedShape.cs
index 0240c707a..868d9bd7c 100644
--- a/Structure_Engine/Query/DeformedShape.cs
+++ b/Structure_Engine/Query/DeformedShape.cs
@@ -55,7 +55,7 @@ public static partial class Query
         [Input("scaleFactor", "Controls by how much the results should be scaled.")]
         [Input("drawSections", "Toggles if output should be just centrelines or include section geometry. Note that currently section geometry only supports displacements, no rotations!")]
         [Output("deformed","The shape of the Bars from the displacements.")]
-        public static List<IGeometry> DeformedShape(List<Bar> bars, List<BarDisplacement> barDisplacements, Type adapterIdType, object loadcase, double scaleFactor = 1.0, bool drawSections = false)
+        public static List<IGeometry> DeformedShape(this List<Bar> bars, List<BarDisplacement> barDisplacements, Type adapterIdType, object loadcase, double scaleFactor = 1.0, bool drawSections = false)
         {
             if (adapterIdType == null)
             {
@@ -116,7 +116,7 @@ public static List<IGeometry> DeformedShape(List<Bar> bars, List<BarDisplacement
         [Input("loadcase", "Loadcase to display results for. Should generally be either an identifier matching the one used in the analysis package that the results were pulled from or a Loadcase/LoadCombination.")]
         [Input("scaleFactor", "Controls by how much the results should be scaled.")]
         [Output("deformed", "The shape of the FEMeshes from the displacements.")]
-        public static List<Mesh> DeformedShape(List<FEMesh> meshes, List<MeshResult> meshDisplacements, Type adapterIdType, object loadcase, double scaleFactor = 1.0)
+        public static List<Mesh> DeformedShape(this List<FEMesh> meshes, List<MeshResult> meshDisplacements, Type adapterIdType, object loadcase, double scaleFactor = 1.0)
         {
             if (adapterIdType == null)
             {
@@ -168,13 +168,13 @@ public static List<Mesh> DeformedShape(List<FEMesh> meshes, List<MeshResult> mes
 
         private static Polyline DeformedShapeCentreLine(Bar bar, List<BarDisplacement> deformations, double scaleFactor = 1.0)
         {
-            Vector tan = (bar.EndNode.Position - bar.StartNode.Position);
+            Vector tan = (bar.End.Position - bar.Start.Position);
             List<Point> pts = new List<Point>();
 
             foreach (BarDisplacement defo in deformations)
             {
                 Vector disp = new Vector { X = defo.UX * scaleFactor, Y = defo.UY * scaleFactor, Z = defo.UZ * scaleFactor };
-                Point pt = bar.StartNode.Position + tan * defo.Position + disp;
+                Point pt = bar.Start.Position + tan * defo.Position + disp;
                 pts.Add(pt);
             }
 
diff --git a/Structure_Engine/Query/DistributedPoints.cs b/Structure_Engine/Query/DistributedPoints.cs
index 9a69daf7d..d44d33c53 100644
--- a/Structure_Engine/Query/DistributedPoints.cs
+++ b/Structure_Engine/Query/DistributedPoints.cs
@@ -59,14 +59,14 @@ public static List<Point> DistributedPoints(this Bar bar, int divisions, double
             Vector tan;
             if (startLength == 0 && endLength == 0)
             {
-                startPos = bar.StartNode.Position;
+                startPos = bar.Start.Position;
                 tan = bar.Tangent() / (double)divisions;
             }
             else
             {
                 double length = bar.Length();
                 tan = bar.Tangent() / length;
-                startPos = bar.StartNode.Position + tan * startLength;
+                startPos = bar.Start.Position + tan * startLength;
 
                 tan *= (length - endLength - startLength) / (double)divisions;
             }
diff --git a/Structure_Engine/Query/IsNull.cs b/Structure_Engine/Query/IsNull.cs
index 19c0f0986..a4fb302e4 100644
--- a/Structure_Engine/Query/IsNull.cs
+++ b/Structure_Engine/Query/IsNull.cs
@@ -83,7 +83,7 @@ public static bool IsNull(this Bar bar, string msg = "", [CallerMemberName] stri
                 ErrorMessage(methodName, "Bar", msg);
                 return true;
             }
-            else if (bar.StartNode.IsNull("The Node (StartNode) is owned by a Bar.", methodName) || bar.EndNode.IsNull("The Node (EndNode) is owned by a Bar.", methodName))
+            else if (bar.Start.IsNull("The Node (Start) is owned by a Bar.", methodName) || bar.End.IsNull("The Node (End) is owned by a Bar.", methodName))
                 return true;
 
             return false;
diff --git a/Structure_Engine/Query/OppositeNode.cs b/Structure_Engine/Query/OppositeNode.cs
index e16d6bb67..1a4b19d81 100644
--- a/Structure_Engine/Query/OppositeNode.cs
+++ b/Structure_Engine/Query/OppositeNode.cs
@@ -42,10 +42,10 @@ public static Node OppositeNode(this Bar bar, Node node)
             if (bar.IsNull() || node.IsNull())
                 return null;
 
-            if (bar.EndNode.BHoM_Guid == node.BHoM_Guid)
-                return bar.StartNode;
-            else if (bar.StartNode.BHoM_Guid == node.BHoM_Guid)
-                return bar.EndNode;
+            if (bar.End.BHoM_Guid == node.BHoM_Guid)
+                return bar.Start;
+            else if (bar.Start.BHoM_Guid == node.BHoM_Guid)
+                return bar.End;
             else
             {
                 Base.Compute.RecordError("The Bar does not contain the provided Node.");
diff --git a/Structure_Engine/Query/PlotBarForce.cs b/Structure_Engine/Query/PlotBarForce.cs
index 8d9b5b131..46b2e033b 100644
--- a/Structure_Engine/Query/PlotBarForce.cs
+++ b/Structure_Engine/Query/PlotBarForce.cs
@@ -43,7 +43,7 @@ public static partial class Query
         /**** Public Methods                            ****/
         /***************************************************/
 
-        public static List<ICurve> PlotBarForce(List<Bar> bars, List<BarForce> forces, Type adapterIdType, double scaleFactor = 1.0, object loadCase = null, bool fx = true, bool fy = true, bool fz = true, bool mx = true, bool my = true, bool mz = true)
+        public static List<ICurve> PlotBarForce(this List<Bar> bars, List<BarForce> forces, Type adapterIdType, double scaleFactor = 1.0, object loadCase = null, bool fx = true, bool fy = true, bool fz = true, bool mx = true, bool my = true, bool mz = true)
         {
             if (adapterIdType == null)
             {
@@ -92,7 +92,7 @@ private static List<ICurve> PlotBarForce(Bar bar, List<BarForce> forces, double
 
             scaleFactor /= 1000;
 
-            List<Point> basePoints = forces.Select(x => bar.StartNode.Position + tan * x.Position).ToList();
+            List<Point> basePoints = forces.Select(x => bar.Start.Position + tan * x.Position).ToList();
 
             List<ICurve> plots = new List<ICurve>();
 
diff --git a/Structure_Engine/Query/Tangent.cs b/Structure_Engine/Query/Tangent.cs
index de8039aac..c2a985b0e 100644
--- a/Structure_Engine/Query/Tangent.cs
+++ b/Structure_Engine/Query/Tangent.cs
@@ -41,7 +41,7 @@ public static partial class Query
         [Output("tan", "The tangent Vector of the Bar.")]
         public static Vector Tangent(this Bar bar, bool normalise = false)
         {
-            Vector tan = bar.IsNull() ? null : bar.EndNode.Position - bar.StartNode.Position;
+            Vector tan = bar.IsNull() ? null : bar.End.Position - bar.Start.Position;
             return normalise ? tan?.Normalise() : tan;
         }
 
diff --git a/Structure_Engine/Query/Visualize.cs b/Structure_Engine/Query/Visualize.cs
index d822f2b26..6b55cc95f 100644
--- a/Structure_Engine/Query/Visualize.cs
+++ b/Structure_Engine/Query/Visualize.cs
@@ -164,7 +164,7 @@ public static List<ICurve> Visualize(this BarPointLoad barPointForce, double sca
             {
                 Basis orientation;
                 Vector[] loads = BarForceVectors(bar, forceVec, momentVec, barPointForce.Axis, barPointForce.Projected, out orientation);
-                Point point = bar.StartNode.Position;
+                Point point = bar.Start.Position;
                 Vector tan = bar.Tangent(true);
                 point += tan * barPointForce.DistanceFromA;
 
@@ -753,7 +753,7 @@ private static Vector[] BarForceVectors(Bar bar, Vector globalForce, Vector glob
                 orientation = null;
                 if (isProjected)
                 {
-                    Point startPos = bar.StartNode.Position;
+                    Point startPos = bar.Start.Position;
                     Vector tan = bar.Tangent();
 
                     Vector tanUnit = tan.Normalise();