diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/ArcToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/ArcToHostConverter.cs
index 0068c38ef2..73840337de 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/ArcToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/ArcToHostConverter.cs
@@ -1,34 +1,36 @@
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
 /// <summary>
 /// Converts a SpeckleArcRaw object to a Rhino.Geometry.Arc object or Rhino.Geometry.ArcCurve object.
 /// </summary>
-public class ArcToHostConverter : ITypedConverter<SOG.Arc, RG.Arc>, ITypedConverter<SOG.Arc, RG.ArcCurve>
+public class ArcToHostConverter : ITypedConverter<SOG.Arc, IRhinoArc>, ITypedConverter<SOG.Arc, IRhinoArcCurve>
 {
-  private readonly ITypedConverter<SOG.Point, RG.Point3d> _pointConverter;
-  private readonly ITypedConverter<SOP.Interval, RG.Interval> _intervalConverter;
+  private readonly ITypedConverter<SOG.Point, IRhinoPoint3d> _pointConverter;
+  private readonly ITypedConverter<SOP.Interval, IRhinoInterval> _intervalConverter;
+  private readonly IRhinoArcFactory _rhinoArcFactory;
 
   public ArcToHostConverter(
-    ITypedConverter<SOG.Point, RG.Point3d> pointConverter,
-    ITypedConverter<SOP.Interval, RG.Interval> intervalConverter
-  )
+    ITypedConverter<SOG.Point, IRhinoPoint3d> pointConverter,
+    ITypedConverter<SOP.Interval, IRhinoInterval> intervalConverter, IRhinoArcFactory rhinoArcFactory)
   {
     _pointConverter = pointConverter;
     this._intervalConverter = intervalConverter;
+    _rhinoArcFactory = rhinoArcFactory;
   }
 
   /// <summary>
-  /// Converts a <see cref="SOG.Arc"/> object to a <see cref="RG.Arc"/> object.
+  /// Converts a <see cref="SOG.Arc"/> object to a <see cref="IRhinoArc"/> object.
   /// </summary>
   /// <param name="target">The Speckle Arc object to convert.</param>
-  /// <returns>The converted <see cref="RG.Arc"/> object.</returns>
+  /// <returns>The converted <see cref="IRhinoArc"/> object.</returns>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
   /// <remarks><br/>⚠️ This method does not preserve the original curve domain</remarks>
-  public RG.Arc Convert(SOG.Arc target)
+  public IRhinoArc Convert(SOG.Arc target)
   {
-    var rhinoArc = new RG.Arc(
+    var rhinoArc = _rhinoArcFactory.Create(
       _pointConverter.Convert(target.startPoint),
       _pointConverter.Convert(target.midPoint),
       _pointConverter.Convert(target.endPoint)
@@ -39,16 +41,16 @@ public RG.Arc Convert(SOG.Arc target)
   // POC: CNX-9271 Potential code-smell by directly implementing the interface. We should discuss this further but
   // since we're using the interfaces instead of the direct type, this may not be an issue.
   /// <summary>
-  /// Converts a <see cref="SOG.Arc"/> object to a <see cref="RG.ArcCurve"/> object.
+  /// Converts a <see cref="SOG.Arc"/> object to a <see cref="IRhinoArcCurve"/> object.
   /// </summary>
   /// <param name="target">The <see cref="SOG.Arc"/> object to convert.</param>
-  /// <returns>The converted <see cref="RG.ArcCurve"/> object.</returns>
+  /// <returns>The converted <see cref="IRhinoArcCurve"/> object.</returns>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  /// <remarks><br/>⚠️ Converting to <see cref="RG.ArcCurve"/> instead of <see cref="RG.Arc"/> preserves the domain of the curve.</remarks>
-  RG.ArcCurve ITypedConverter<SOG.Arc, RG.ArcCurve>.Convert(SOG.Arc target)
+  /// <remarks><br/>⚠️ Converting to <see cref="IRhinoArcCurve"/> instead of <see cref="IRhinoArc"/> preserves the domain of the curve.</remarks>
+  IRhinoArcCurve ITypedConverter<SOG.Arc, IRhinoArcCurve>.Convert(SOG.Arc target)
   {
     var rhinoArc = Convert(target);
-    var arcCurve = new RG.ArcCurve(rhinoArc) { Domain = _intervalConverter.Convert(target.domain) };
+    var arcCurve = _rhinoArcFactory.Create(rhinoArc, _intervalConverter.Convert(target.domain));
     return arcCurve;
   }
 }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/CircleToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/CircleToHostConverter.cs
index 1431d3fc1a..a55bb72f6b 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/CircleToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/CircleToHostConverter.cs
@@ -1,46 +1,48 @@
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
 /// <summary>
-/// This class is responsible for converting a <see cref="SOG.Circle"/> into <see cref="RG.Circle"/> and <see cref="RG.ArcCurve"/> objects.
+/// This class is responsible for converting a <see cref="SOG.Circle"/> into <see cref="IRhinoCircle"/> and <see cref="IRhinoArcCurve"/> objects.
 /// Implements the <see cref="ITypedConverter{TIn,TOut}"/> interface,
-/// providing implementation for <see cref="SOG.Circle"/> to <see cref="RG.Circle"/> and <see cref="RG.ArcCurve"/> conversion.
+/// providing implementation for <see cref="SOG.Circle"/> to <see cref="IRhinoCircle"/> and <see cref="IRhinoArcCurve"/> conversion.
 /// </summary>
-public class CircleToHostConverter : ITypedConverter<SOG.Circle, RG.Circle>, ITypedConverter<SOG.Circle, RG.ArcCurve>
+public class CircleToHostConverter : ITypedConverter<SOG.Circle, IRhinoCircle>, ITypedConverter<SOG.Circle, IRhinoArcCurve>
 {
-  private readonly ITypedConverter<SOG.Plane, RG.Plane> _planeConverter;
-  private readonly ITypedConverter<SOP.Interval, RG.Interval> _intervalConverter;
+  private readonly ITypedConverter<SOG.Plane, IRhinoPlane> _planeConverter;
+  private readonly ITypedConverter<SOP.Interval, IRhinoInterval> _intervalConverter;
+  private readonly IRhinoCircleFactory _rhinoCircleFactory;
 
   /// <summary>
   /// Constructs a new instance of the <see cref="CircleToHostConverter"/> class.
   /// </summary>
   /// <param name="intervalConverter">
-  /// An implementation of <see cref="ITypedConverter{TIn,TOut}"/> used to convert <see cref="SOP.Interval"/> into <see cref="RG.Interval"/>.
+  /// An implementation of <see cref="ITypedConverter{TIn,TOut}"/> used to convert <see cref="SOP.Interval"/> into <see cref="IRhinoInterval"/>.
   /// </param>
   /// <param name="planeConverter">
-  /// An implementation of <see cref="ITypedConverter{TIn,TOut}"/> used to convert <see cref="SOG.Plane"/> into <see cref="RG.Plane"/>.
+  /// An implementation of <see cref="ITypedConverter{TIn,TOut}"/> used to convert <see cref="SOG.Plane"/> into <see cref="IRhinoPlane"/>.
   /// </param>
   public CircleToHostConverter(
-    ITypedConverter<SOP.Interval, RG.Interval> intervalConverter,
-    ITypedConverter<SOG.Plane, RG.Plane> planeConverter
-  )
+    ITypedConverter<SOP.Interval, IRhinoInterval> intervalConverter,
+    ITypedConverter<SOG.Plane, IRhinoPlane> planeConverter, IRhinoCircleFactory rhinoCircleFactory)
   {
     _intervalConverter = intervalConverter;
     _planeConverter = planeConverter;
+    _rhinoCircleFactory = rhinoCircleFactory;
   }
 
   /// <summary>
-  /// Converts the given <see cref="SOG.Circle"/> object into a <see cref="RG.Circle"/> object.
+  /// Converts the given <see cref="SOG.Circle"/> object into a <see cref="IRhinoCircle"/> object.
   /// </summary>
   /// <param name="target">The <see cref="SOG.Circle"/> object to convert.</param>
-  /// <returns>The resulting <see cref="RG.Circle"/> object.</returns>
+  /// <returns>The resulting <see cref="IRhinoCircle"/> object.</returns>
   /// <exception cref="ArgumentNullException">
   /// Thrown when the radius of the given <see cref="SOG.Circle"/> object is null.
   /// </exception>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  /// <remarks><br/>⚠️ This conversion does not preserve the curve domain. If you need it preserved you must request a conversion to <see cref="RG.ArcCurve"/> conversion instead</remarks>
-  public RG.Circle Convert(SOG.Circle target)
+  /// <remarks><br/>⚠️ This conversion does not preserve the curve domain. If you need it preserved you must request a conversion to <see cref="IRhinoArcCurve"/> conversion instead</remarks>
+  public IRhinoCircle Convert(SOG.Circle target)
   {
     if (target.radius == null)
     {
@@ -50,9 +52,9 @@ public RG.Circle Convert(SOG.Circle target)
 
     var plane = _planeConverter.Convert(target.plane);
     var radius = target.radius.Value;
-    return new RG.Circle(plane, radius);
+    return _rhinoCircleFactory.Create(plane, radius);
   }
 
-  RG.ArcCurve ITypedConverter<SOG.Circle, RG.ArcCurve>.Convert(SOG.Circle target) =>
-    new(Convert(target)) { Domain = _intervalConverter.Convert(target.domain) };
+  IRhinoArcCurve ITypedConverter<SOG.Circle, IRhinoArcCurve>.Convert(SOG.Circle target) =>
+    _rhinoCircleFactory.Create(Convert(target), _intervalConverter.Convert(target.domain));
 }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/EllipseToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/EllipseToHostConverter.cs
index 74f309a61f..a74da6774f 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/EllipseToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/EllipseToHostConverter.cs
@@ -1,49 +1,51 @@
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
 public class EllipseToHostConverter
-  : ITypedConverter<SOG.Ellipse, RG.Ellipse>,
-    ITypedConverter<SOG.Ellipse, RG.NurbsCurve>
+  : ITypedConverter<SOG.Ellipse, IRhinoEllipse>,
+    ITypedConverter<SOG.Ellipse, IRhinoNurbsCurve>
 {
-  private readonly ITypedConverter<SOG.Plane, RG.Plane> _planeConverter;
-  private readonly ITypedConverter<SOP.Interval, RG.Interval> _intervalConverter;
+  private readonly ITypedConverter<SOG.Plane, IRhinoPlane> _planeConverter;
+  private readonly ITypedConverter<SOP.Interval, IRhinoInterval> _intervalConverter;
+  private readonly IRhinoEllipseFactory _rhinoEllipseFactory;
 
   public EllipseToHostConverter(
-    ITypedConverter<SOG.Plane, RG.Plane> planeConverter,
-    ITypedConverter<SOP.Interval, RG.Interval> intervalConverter
-  )
+    ITypedConverter<SOG.Plane, IRhinoPlane> planeConverter,
+    ITypedConverter<SOP.Interval, IRhinoInterval> intervalConverter, IRhinoEllipseFactory rhinoEllipseFactory)
   {
     _planeConverter = planeConverter;
     _intervalConverter = intervalConverter;
+    _rhinoEllipseFactory = rhinoEllipseFactory;
   }
 
   /// <summary>
-  /// Converts an instance of <see cref="SOG.Ellipse"/> to an <see cref="RG.Ellipse"/> while preserving geometric properties.
+  /// Converts an instance of <see cref="SOG.Ellipse"/> to an <see cref="IRhinoEllipse"/> while preserving geometric properties.
   /// </summary>
   /// <param name="target">The <see cref="SOG.Ellipse"/> instance to be converted.</param>
-  /// <returns>The resulting <see cref="RG.Ellipse"/> after conversion.</returns>
+  /// <returns>The resulting <see cref="IRhinoEllipse"/> after conversion.</returns>
   /// <exception cref="InvalidOperationException">Thrown when <see cref="SOG.Ellipse.firstRadius"/> or <see cref="SOG.Ellipse.secondRadius"/> properties are null.</exception>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  /// <remarks><br/>⚠️ This conversion does not preserve the curve domain. If you need it preserved you must request a conversion to <see cref="RG.NurbsCurve"/> conversion instead</remarks>
-  public RG.Ellipse Convert(SOG.Ellipse target)
+  /// <remarks><br/>⚠️ This conversion does not preserve the curve domain. If you need it preserved you must request a conversion to <see cref="IRhinoNurbsCurve"/> conversion instead</remarks>
+  public IRhinoEllipse Convert(SOG.Ellipse target)
   {
     if (!target.firstRadius.HasValue || !target.secondRadius.HasValue)
     {
       throw new InvalidOperationException($"Ellipses cannot have null radii");
     }
 
-    return new RG.Ellipse(_planeConverter.Convert(target.plane), target.firstRadius.Value, target.secondRadius.Value);
+    return _rhinoEllipseFactory.Create(_planeConverter.Convert(target.plane), target.firstRadius.Value, target.secondRadius.Value);
   }
 
   /// <summary>
-  /// Converts the provided <see cref="SOG.Ellipse"/> into a <see cref="RG.NurbsCurve"/> representation.
+  /// Converts the provided <see cref="SOG.Ellipse"/> into a <see cref="IRhinoNurbsCurve"/> representation.
   /// </summary>
   /// <param name="target">The <see cref="SOG.Ellipse"/> to convert.</param>
   /// <returns>
-  /// A <see cref="RG.NurbsCurve"/> that represents the provided <see cref="SOG.Ellipse"/>.
+  /// A <see cref="IRhinoNurbsCurve"/> that represents the provided <see cref="SOG.Ellipse"/>.
   /// </returns>
-  RG.NurbsCurve ITypedConverter<SOG.Ellipse, RG.NurbsCurve>.Convert(SOG.Ellipse target)
+  IRhinoNurbsCurve ITypedConverter<SOG.Ellipse, IRhinoNurbsCurve>.Convert(SOG.Ellipse target)
   {
     var rhinoEllipse = Convert(target);
     var rhinoNurbsEllipse = rhinoEllipse.ToNurbsCurve();
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/FlatPointListToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/FlatPointListToHostConverter.cs
index f0363a387d..97c2786b44 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/FlatPointListToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/FlatPointListToHostConverter.cs
@@ -1,14 +1,21 @@
-using Rhino.Collections;
-using Speckle.Converters.Common.Objects;
+using Speckle.Converters.Common.Objects;
 using Speckle.Core.Logging;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
 /// <summary>
 /// Converts a flat list of raw double values to a Point3dList.
 /// </summary>
-public class FlatPointListToHostConverter : ITypedConverter<IReadOnlyList<double>, Point3dList>
+public class FlatPointListToHostConverter : ITypedConverter<IReadOnlyList<double>, IRhinoPoint3dList>
 {
+  private readonly IRhinoPointFactory _rhinoPointFactory;
+
+  public FlatPointListToHostConverter(IRhinoPointFactory rhinoPointFactory)
+  {
+    _rhinoPointFactory = rhinoPointFactory;
+  }
+
   /// <summary>
   /// Converts a flat list of raw double values to a Point3dList.
   /// </summary>
@@ -19,20 +26,20 @@ public class FlatPointListToHostConverter : ITypedConverter<IReadOnlyList<double
   /// with the numbers being coordinates of each point in the format {x1, y1, z1, x2, y2, z2, ..., xN, yN, zN}
   /// </remarks>
   /// <exception cref="SpeckleException">Throws when the input list count is not a multiple of 3.</exception>
-  public Point3dList Convert(IReadOnlyList<double> target)
+  public IRhinoPoint3dList Convert(IReadOnlyList<double> target)
   {
     if (target.Count % 3 != 0)
     {
       throw new SpeckleException("Array malformed: length%3 != 0.");
     }
 
-    var points = new List<RG.Point3d>(target.Count / 3);
+    var points = new List<IRhinoPoint3d>(target.Count / 3);
 
     for (int i = 2; i < target.Count; i += 3)
     {
-      points.Add(new RG.Point3d(target[i - 2], target[i - 1], target[i]));
+      points.Add(_rhinoPointFactory.Create(target[i - 2], target[i - 1], target[i]));
     }
 
-    return new Point3dList(points);
+    return _rhinoPointFactory.Create(points);
   }
 }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/IntervalToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/IntervalToHostConverter.cs
index f201283ebd..ddaa476970 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/IntervalToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/IntervalToHostConverter.cs
@@ -1,9 +1,17 @@
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
-public class IntervalToHostConverter : ITypedConverter<SOP.Interval, RG.Interval>
+public class IntervalToHostConverter : ITypedConverter<SOP.Interval, IRhinoInterval>
 {
+  private readonly IRhinoIntervalFactory _rhinoIntervalFactory;
+
+  public IntervalToHostConverter(IRhinoIntervalFactory rhinoIntervalFactory)
+  {
+    _rhinoIntervalFactory = rhinoIntervalFactory;
+  }
+
   /// <summary>
   /// Converts a Speckle Interval object to a Rhino.Geometry.Interval object.
   /// </summary>
@@ -11,13 +19,13 @@ public class IntervalToHostConverter : ITypedConverter<SOP.Interval, RG.Interval
   /// <returns>The converted Rhino.Geometry.Interval object.</returns>
   /// <exception cref="ArgumentException">Thrown when the start or end value of the Interval is null.</exception>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  public RG.Interval Convert(SOP.Interval target)
+  public IRhinoInterval Convert(SOP.Interval target)
   {
     if (!target.start.HasValue || !target.end.HasValue) // POC: CNX-9272 Interval start and end being nullable makes no sense.
     {
       throw new ArgumentException("Interval start/end cannot be null");
     }
 
-    return new RG.Interval(target.start.Value, target.end.Value);
+    return _rhinoIntervalFactory.Create(target.start.Value, target.end.Value);
   }
 }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/LineToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/LineToHostConverter.cs
index c549e96741..cfb2fcc66c 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/LineToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/LineToHostConverter.cs
@@ -1,14 +1,17 @@
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
-public class LineToHostConverter : ITypedConverter<SOG.Line, RG.LineCurve>, ITypedConverter<SOG.Line, RG.Line>
+public class LineToHostConverter : ITypedConverter<SOG.Line, IRhinoLineCurve>, ITypedConverter<SOG.Line, IRhinoLine>
 {
-  private readonly ITypedConverter<SOG.Point, RG.Point3d> _pointConverter;
+  private readonly ITypedConverter<SOG.Point, IRhinoPoint3d> _pointConverter;
+  private readonly IRhinoLineFactory _rhinoLineFactory;
 
-  public LineToHostConverter(ITypedConverter<SOG.Point, RG.Point3d> pointConverter)
+  public LineToHostConverter(ITypedConverter<SOG.Point, IRhinoPoint3d> pointConverter, IRhinoLineFactory rhinoLineFactory)
   {
     _pointConverter = pointConverter;
+    _rhinoLineFactory = rhinoLineFactory;
   }
 
   /// <summary>
@@ -20,15 +23,15 @@ public LineToHostConverter(ITypedConverter<SOG.Point, RG.Point3d> pointConverter
   /// <remarks>
   /// <br/>⚠️ This conversion does not preserve the curve domain.
   /// If you need it preserved you must request a conversion to
-  /// <see cref="RG.LineCurve"/> conversion instead
+  /// <see cref="IRhinoLineCurve"/> conversion instead
   /// </remarks>
-  public RG.Line Convert(SOG.Line target) =>
-    new(_pointConverter.Convert(target.start), _pointConverter.Convert(target.end));
+  public IRhinoLine Convert(SOG.Line target) =>
+    _rhinoLineFactory.Create(_pointConverter.Convert(target.start), _pointConverter.Convert(target.end));
 
   /// <summary>
   /// Converts a Speckle Line object to a Rhino LineCurve object.
   /// </summary>
   /// <param name="target">The Speckle Line object to convert.</param>
   /// <returns>Returns the resulting Rhino LineCurve object.</returns>
-  RG.LineCurve ITypedConverter<SOG.Line, RG.LineCurve>.Convert(SOG.Line target) => new(Convert(target));
+  IRhinoLineCurve ITypedConverter<SOG.Line, IRhinoLineCurve>.Convert(SOG.Line target) => _rhinoLineFactory.Create(Convert(target));
 }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/NurbsCurveToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/NurbsCurveToHostConverter.cs
index 9f9bf52811..291fd4c5dc 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/NurbsCurveToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/NurbsCurveToHostConverter.cs
@@ -1,15 +1,20 @@
 using Speckle.Converters.Common;
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
-public class NurbsCurveToHostConverter : ITypedConverter<SOG.Curve, RG.NurbsCurve>
+public class NurbsCurveToHostConverter : ITypedConverter<SOG.Curve, IRhinoNurbsCurve>
 {
-  private readonly ITypedConverter<SOP.Interval, RG.Interval> _intervalConverter;
+  private readonly IRhinoPointFactory _rhinoPointFactory;
+  private readonly IRhinoCurveFactory _rhinoCurveFactory;
+  private readonly ITypedConverter<SOP.Interval, IRhinoInterval> _intervalConverter;
 
-  public NurbsCurveToHostConverter(ITypedConverter<SOP.Interval, RG.Interval> intervalConverter)
+  public NurbsCurveToHostConverter(ITypedConverter<SOP.Interval, IRhinoInterval> intervalConverter, IRhinoCurveFactory rhinoCurveFactory, IRhinoPointFactory rhinoPointFactory)
   {
     _intervalConverter = intervalConverter;
+    _rhinoCurveFactory = rhinoCurveFactory;
+    _rhinoPointFactory = rhinoPointFactory;
   }
 
   /// <summary>
@@ -19,14 +24,14 @@ public NurbsCurveToHostConverter(ITypedConverter<SOP.Interval, RG.Interval> inte
   /// <returns>The converted Rhino NurbsCurve object.</returns>
   /// <exception cref="SpeckleConversionException">Thrown when the conversion fails.</exception>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  public RG.NurbsCurve Convert(SOG.Curve target)
+  public IRhinoNurbsCurve Convert(SOG.Curve target)
   {
-    RG.NurbsCurve nurbsCurve = new(target.degree, target.points.Count / 3);
+    IRhinoNurbsCurve nurbsCurve = _rhinoCurveFactory.Create(target.degree, target.points.Count / 3);
 
     // Hyper optimised curve control point conversion
     for (int i = 2, j = 0; i < target.points.Count; i += 3, j++)
     {
-      var pt = new RG.Point3d(target.points[i - 2], target.points[i - 1], target.points[i]); // Skip the point converter for performance
+      var pt = _rhinoPointFactory.Create(target.points[i - 2], target.points[i - 1], target.points[i]); // Skip the point converter for performance
       nurbsCurve.Points.SetPoint(j, pt, target.weights[j]);
     }
 
@@ -37,11 +42,11 @@ public RG.NurbsCurve Convert(SOG.Curve target)
     {
       if (extraKnots == 2)
       {
-        nurbsCurve.Knots[j] = target.knots[j + 1];
+        nurbsCurve.Knots.SetKnot(j, target.knots[j + 1]);
       }
       else
       {
-        nurbsCurve.Knots[j] = target.knots[j];
+        nurbsCurve.Knots.SetKnot(j,  target.knots[j]);
       }
     }
 
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PlaneToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PlaneToHostConverter.cs
index 49e10ab69e..6856178a40 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PlaneToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PlaneToHostConverter.cs
@@ -1,19 +1,21 @@
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
-public class PlaneToHostConverter : ITypedConverter<SOG.Plane, RG.Plane>
+public class PlaneToHostConverter : ITypedConverter<SOG.Plane, IRhinoPlane>
 {
-  private readonly ITypedConverter<SOG.Point, RG.Point3d> _pointConverter;
-  private readonly ITypedConverter<SOG.Vector, RG.Vector3d> _vectorConverter;
+  private readonly ITypedConverter<SOG.Point, IRhinoPoint3d> _pointConverter;
+  private readonly ITypedConverter<SOG.Vector, IRhinoVector3d> _vectorConverter;
+  private readonly IRhinoPlaneFactory _rhinoPlaneFactory;
 
   public PlaneToHostConverter(
-    ITypedConverter<SOG.Point, RG.Point3d> pointConverter,
-    ITypedConverter<SOG.Vector, RG.Vector3d> vectorConverter
-  )
+    ITypedConverter<SOG.Point, IRhinoPoint3d> pointConverter,
+    ITypedConverter<SOG.Vector, IRhinoVector3d> vectorConverter, IRhinoPlaneFactory rhinoPlaneFactory)
   {
     _pointConverter = pointConverter;
     _vectorConverter = vectorConverter;
+    _rhinoPlaneFactory = rhinoPlaneFactory;
   }
 
   /// <summary>
@@ -22,8 +24,8 @@ public PlaneToHostConverter(
   /// <param name="target">The Speckle Plane object to be converted.</param>
   /// <returns>The converted Rhino Plane object.</returns>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  public RG.Plane Convert(SOG.Plane target) =>
-    new(
+  public IRhinoPlane Convert(SOG.Plane target) =>
+    _rhinoPlaneFactory.Create(
       _pointConverter.Convert(target.origin),
       _vectorConverter.Convert(target.xdir),
       _vectorConverter.Convert(target.ydir)
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PointCloudToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PointCloudToHostConverter.cs
index a6d749b15c..7f59009710 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PointCloudToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PointCloudToHostConverter.cs
@@ -1,16 +1,18 @@
 using System.Drawing;
-using Rhino.Collections;
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
-public class PointCloudToHostConverter : ITypedConverter<SOG.Pointcloud, RG.PointCloud>
+public class PointCloudToHostConverter : ITypedConverter<SOG.Pointcloud, IRhinoPointCloud>
 {
-  private readonly ITypedConverter<IReadOnlyList<double>, Point3dList> _pointListConverter;
+  private readonly ITypedConverter<IReadOnlyList<double>, IRhinoPoint3dList> _pointListConverter;
+  private readonly IRhinoPointCloudFactory _rhinoPointCloudFactory;
 
-  public PointCloudToHostConverter(ITypedConverter<IReadOnlyList<double>, Point3dList> pointListConverter)
+  public PointCloudToHostConverter(ITypedConverter<IReadOnlyList<double>, IRhinoPoint3dList> pointListConverter, IRhinoPointCloudFactory rhinoPointCloudFactory)
   {
     _pointListConverter = pointListConverter;
+    _rhinoPointCloudFactory = rhinoPointCloudFactory;
   }
 
   /// <summary>
@@ -19,10 +21,10 @@ public PointCloudToHostConverter(ITypedConverter<IReadOnlyList<double>, Point3dL
   /// <param name="target">The raw Speckle Pointcloud object to convert.</param>
   /// <returns>The converted Rhino PointCloud object.</returns>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  public RG.PointCloud Convert(SOG.Pointcloud target)
+  public IRhinoPointCloud Convert(SOG.Pointcloud target)
   {
     var rhinoPoints = _pointListConverter.Convert(target.points);
-    var rhinoPointCloud = new RG.PointCloud(rhinoPoints);
+    var rhinoPointCloud = _rhinoPointCloudFactory.Create(rhinoPoints);
 
     if (target.colors.Count == rhinoPoints.Count)
     {
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PointToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PointToHostConverter.cs
index 8ce40bcb59..edc4a3d7cb 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PointToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PointToHostConverter.cs
@@ -1,16 +1,24 @@
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
-public class PointToHostConverter : ITypedConverter<SOG.Point, RG.Point3d>, ITypedConverter<SOG.Point, RG.Point>
+public class PointToHostConverter : ITypedConverter<SOG.Point, IRhinoPoint3d>, ITypedConverter<SOG.Point, IRhinoPoint>
 {
+  private readonly IRhinoPointFactory _rhinoPointFactory;
+
+  public PointToHostConverter(IRhinoPointFactory rhinoPointFactory)
+  {
+    _rhinoPointFactory = rhinoPointFactory;
+  }
+
   /// <summary>
   /// Converts a Speckle Point object to a Rhino Point3d object.
   /// </summary>
   /// <param name="target">The Speckle Point object to convert.</param>
   /// <returns>The converted Rhino Point3d object.</returns>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  public RG.Point3d Convert(SOG.Point target) => new(target.x, target.y, target.z);
+  public IRhinoPoint3d Convert(SOG.Point target) => _rhinoPointFactory.Create(target.x, target.y, target.z);
 
   /// <summary>
   /// Converts a Speckle Point object to a Rhino Point object.
@@ -18,5 +26,5 @@ public class PointToHostConverter : ITypedConverter<SOG.Point, RG.Point3d>, ITyp
   /// <param name="target">The Speckle Point object to convert.</param>
   /// <returns>The converted Rhino Point object.</returns>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  RG.Point ITypedConverter<SOG.Point, RG.Point>.Convert(SOG.Point target) => new(Convert(target));
+  IRhinoPoint ITypedConverter<SOG.Point, IRhinoPoint>.Convert(SOG.Point target) => _rhinoPointFactory.Create(Convert(target));
 }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PolyCurveToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PolyCurveToHostConverter.cs
index 3f35905090..effbce9847 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PolyCurveToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PolyCurveToHostConverter.cs
@@ -1,19 +1,21 @@
 using Objects;
-using Speckle.Converters.Common;
 using Speckle.Converters.Common.Objects;
 using Speckle.Core.Kits;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
-public class PolyCurveToHostConverter : ITypedConverter<SOG.Polycurve, RG.PolyCurve>
+public class PolyCurveToHostConverter : ITypedConverter<SOG.Polycurve, IRhinoPolyCurve>
 {
-  public ITypedConverter<ICurve, RG.Curve>? CurveConverter { get; set; } // POC: CNX-9311 Circular dependency injected by the container using property.
+  private readonly ITypedConverter<ICurve, IRhinoCurve> _curveConverter;
+  private readonly ITypedConverter<SOP.Interval, IRhinoInterval> _intervalConverter;
+  private readonly IRhinoCurveFactory _rhinoCurveFactory;
 
-  private readonly ITypedConverter<SOP.Interval, RG.Interval> _intervalConverter;
-
-  public PolyCurveToHostConverter(ITypedConverter<SOP.Interval, RG.Interval> intervalConverter)
+  public PolyCurveToHostConverter(ITypedConverter<SOP.Interval, IRhinoInterval> intervalConverter, ITypedConverter<ICurve, IRhinoCurve> curveConverter, IRhinoCurveFactory rhinoCurveFactory)
   {
     _intervalConverter = intervalConverter;
+    _curveConverter = curveConverter;
+    _rhinoCurveFactory = rhinoCurveFactory;
   }
 
   /// <summary>
@@ -22,13 +24,13 @@ public PolyCurveToHostConverter(ITypedConverter<SOP.Interval, RG.Interval> inter
   /// <param name="target">The SpecklePolyCurve object to convert.</param>
   /// <returns>The converted Rhino PolyCurve object.</returns>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  public RG.PolyCurve Convert(SOG.Polycurve target)
+  public IRhinoPolyCurve Convert(SOG.Polycurve target)
   {
-    RG.PolyCurve result = new();
+    IRhinoPolyCurve result = _rhinoCurveFactory.Create();
 
     foreach (var segment in target.segments)
     {
-      var childCurve = CurveConverter.NotNull().Convert(segment);
+      var childCurve = _curveConverter.Convert(segment);
       bool success = result.AppendSegment(childCurve);
       if (!success)
       {
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PolylineToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PolylineToHostConverter.cs
index 5abe48fed5..4d1adff489 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PolylineToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/PolylineToHostConverter.cs
@@ -1,22 +1,23 @@
-using Rhino.Collections;
-using Speckle.Converters.Common.Objects;
+using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
 public class PolylineToHostConverter
-  : ITypedConverter<SOG.Polyline, RG.Polyline>,
-    ITypedConverter<SOG.Polyline, RG.PolylineCurve>
+  : ITypedConverter<SOG.Polyline, IRhinoPolyline>,
+    ITypedConverter<SOG.Polyline, IRhinoPolylineCurve>
 {
-  private readonly ITypedConverter<IReadOnlyList<double>, Point3dList> _pointListConverter;
-  private readonly ITypedConverter<SOP.Interval, RG.Interval> _intervalConverter;
+  private readonly ITypedConverter<IReadOnlyList<double>, IRhinoPoint3dList> _pointListConverter;
+  private readonly ITypedConverter<SOP.Interval, IRhinoInterval> _intervalConverter;
+  private readonly IRhinoLineFactory _rhinoLineFactory;
 
   public PolylineToHostConverter(
-    ITypedConverter<IReadOnlyList<double>, Point3dList> pointListConverter,
-    ITypedConverter<SOP.Interval, RG.Interval> intervalConverter
-  )
+    ITypedConverter<IReadOnlyList<double>, IRhinoPoint3dList> pointListConverter,
+    ITypedConverter<SOP.Interval, IRhinoInterval> intervalConverter, IRhinoLineFactory rhinoLineFactory)
   {
     _pointListConverter = pointListConverter;
     _intervalConverter = intervalConverter;
+    _rhinoLineFactory = rhinoLineFactory;
   }
 
   /// <summary>
@@ -28,9 +29,9 @@ public PolylineToHostConverter(
   /// <remarks>
   /// <br/>⚠️ This conversion does not preserve the curve domain.
   /// If you need it preserved you must request a conversion to
-  /// <see cref="RG.PolylineCurve"/> conversion instead
+  /// <see cref="IRhinoPolylineCurve"/> conversion instead
   /// </remarks>
-  public RG.Polyline Convert(SOG.Polyline target)
+  public IRhinoPolyline Convert(SOG.Polyline target)
   {
     var points = _pointListConverter.Convert(target.value);
 
@@ -39,7 +40,7 @@ public RG.Polyline Convert(SOG.Polyline target)
       points.Add(points[0]);
     }
 
-    var poly = new RG.Polyline(points);
+    var poly = _rhinoLineFactory.Create(points);
 
     return poly;
   }
@@ -52,7 +53,7 @@ public RG.Polyline Convert(SOG.Polyline target)
   /// <param name="target">The Speckle polyline object to be converted.</param>
   /// <returns>The converted Rhino Polyline object.</returns>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  RG.PolylineCurve ITypedConverter<SOG.Polyline, RG.PolylineCurve>.Convert(SOG.Polyline target)
+  IRhinoPolylineCurve ITypedConverter<SOG.Polyline, IRhinoPolylineCurve>.Convert(SOG.Polyline target)
   {
     var poly = Convert(target).ToPolylineCurve();
     poly.Domain = _intervalConverter.Convert(target.domain);
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/SpiralToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/SpiralToHostConverter.cs
index cb7f5a8745..c3cc3532ce 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/SpiralToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/SpiralToHostConverter.cs
@@ -1,15 +1,16 @@
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
-public class SpiralToHostConverter : ITypedConverter<SOG.Spiral, RG.PolylineCurve>
+public class SpiralToHostConverter : ITypedConverter<SOG.Spiral, IRhinoPolylineCurve>
 {
-  private readonly ITypedConverter<SOG.Polyline, RG.PolylineCurve> _polylineConverter;
-  private readonly ITypedConverter<SOP.Interval, RG.Interval> _intervalConverter;
+  private readonly ITypedConverter<SOG.Polyline, IRhinoPolylineCurve> _polylineConverter;
+  private readonly ITypedConverter<SOP.Interval, IRhinoInterval> _intervalConverter;
 
   public SpiralToHostConverter(
-    ITypedConverter<SOG.Polyline, RG.PolylineCurve> polylineConverter,
-    ITypedConverter<SOP.Interval, RG.Interval> intervalConverter
+    ITypedConverter<SOG.Polyline, IRhinoPolylineCurve> polylineConverter,
+    ITypedConverter<SOP.Interval, IRhinoInterval> intervalConverter
   )
   {
     _polylineConverter = polylineConverter;
@@ -22,7 +23,7 @@ public SpiralToHostConverter(
   /// <param name="target">The Speckle Spiral object to be converted.</param>
   /// <returns>A Rhino PolylineCurve object.</returns>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  public RG.PolylineCurve Convert(SOG.Spiral target)
+  public IRhinoPolylineCurve Convert(SOG.Spiral target)
   {
     var result = _polylineConverter.Convert(target.displayValue);
     result.Domain = _intervalConverter.Convert(target.domain);
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/SurfaceToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/SurfaceToHostConverter.cs
index 91da44ec59..d945c3da8f 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/SurfaceToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/SurfaceToHostConverter.cs
@@ -1,21 +1,29 @@
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
-public class SurfaceToHostConverter : ITypedConverter<SOG.Surface, RG.NurbsSurface>
+public class SurfaceToHostConverter : ITypedConverter<SOG.Surface, IRhinoNurbsSurface>
 {
+  private readonly IRhinoSurfaceFactory _rhinoSurfaceFactory;
+
+  public SurfaceToHostConverter(IRhinoSurfaceFactory rhinoSurfaceFactory)
+  {
+    _rhinoSurfaceFactory = rhinoSurfaceFactory;
+  }
+
   /// <summary>
   /// Converts a raw Speckle surface to a Rhino NURBS surface.
   /// </summary>
   /// <param name="target">The raw Speckle surface to convert.</param>
   /// <returns>The converted Rhino NURBS surface.</returns>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  public RG.NurbsSurface Convert(SOG.Surface target)
+  public IRhinoNurbsSurface Convert(SOG.Surface target)
   {
     // Create rhino surface
     var points = target.GetControlPoints().ToList();
 
-    var result = RG.NurbsSurface.Create(
+    var result = _rhinoSurfaceFactory.Create(
       3,
       target.rational,
       target.degreeU + 1,
@@ -28,13 +36,13 @@ public RG.NurbsSurface Convert(SOG.Surface target)
     var correctUKnots = GetCorrectKnots(target.knotsU, target.countU, target.degreeU);
     for (int i = 0; i < correctUKnots.Count; i++)
     {
-      result.KnotsU[i] = correctUKnots[i];
+      result.KnotsU.SetKnot(i,  correctUKnots[i]);
     }
 
     var correctVKnots = GetCorrectKnots(target.knotsV, target.countV, target.degreeV);
     for (int i = 0; i < correctVKnots.Count; i++)
     {
-      result.KnotsV[i] = correctVKnots[i];
+      result.KnotsV.SetKnot(i, correctVKnots[i]);
     }
 
     // Set control points
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/VectorToHostConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/VectorToHostConverter.cs
index 77e017f0fd..85ff17692c 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/VectorToHostConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToHost/Raw/VectorToHostConverter.cs
@@ -1,14 +1,22 @@
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToHost.Raw;
 
-public class VectorToHostConverter : ITypedConverter<SOG.Vector, RG.Vector3d>
+public class VectorToHostConverter : ITypedConverter<SOG.Vector, IRhinoVector3d>
 {
+  private readonly IRhinoVectorFactory _rhinoVectorFactory;
+
+  public VectorToHostConverter(IRhinoVectorFactory rhinoVectorFactory)
+  {
+    _rhinoVectorFactory = rhinoVectorFactory;
+  }
+
   /// <summary>
   /// Converts a Speckle.Vector object to a Rhino Vector3d object.
   /// </summary>
   /// <param name="target">The Speckle.Vector to be converted.</param>
   /// <returns>The converted Rhino Vector3d object.</returns>
   /// <remarks>⚠️ This conversion does NOT perform scaling.</remarks>
-  public RG.Vector3d Convert(SOG.Vector target) => new(target.x, target.y, target.z);
+  public IRhinoVector3d Convert(SOG.Vector target) => _rhinoVectorFactory.Create(target.x, target.y, target.z);
 }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/BrepObjectToSpeckleTopLevelConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/BrepObjectToSpeckleTopLevelConverter.cs
index 7520c1bd83..cce82c29e9 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/BrepObjectToSpeckleTopLevelConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/BrepObjectToSpeckleTopLevelConverter.cs
@@ -1,23 +1,23 @@
-using Rhino.DocObjects;
-using Speckle.Converters.Common;
+using Speckle.Converters.Common;
 using Speckle.Converters.Common.Objects;
 using Speckle.Core.Models;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToSpeckle.TopLevel;
 
-[NameAndRankValue(nameof(BrepObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
+[NameAndRankValue(nameof(IRhinoBrepObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
 public class BrepObjectToSpeckleTopLevelConverter : IToSpeckleTopLevelConverter
 {
-  private readonly ITypedConverter<RG.Brep, SOG.Brep> _curveConverter;
+  private readonly ITypedConverter<IRhinoBrep, SOG.Brep> _curveConverter;
 
-  public BrepObjectToSpeckleTopLevelConverter(ITypedConverter<RG.Brep, SOG.Brep> curveConverter)
+  public BrepObjectToSpeckleTopLevelConverter(ITypedConverter<IRhinoBrep, SOG.Brep> curveConverter)
   {
     _curveConverter = curveConverter;
   }
 
   public Base Convert(object target)
   {
-    var curveObject = (BrepObject)target;
+    var curveObject = (IRhinoBrepObject)target;
     var speckleCurve = _curveConverter.Convert(curveObject.BrepGeometry);
     return speckleCurve;
   }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/CurveObjectToSpeckleTopLevelConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/CurveObjectToSpeckleTopLevelConverter.cs
index a8214a0c97..2ff6020bc1 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/CurveObjectToSpeckleTopLevelConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/CurveObjectToSpeckleTopLevelConverter.cs
@@ -1,15 +1,15 @@
-using Rhino.DocObjects;
-using Speckle.Converters.Common;
+using Speckle.Converters.Common;
 using Speckle.Converters.Common.Objects;
 using Speckle.Core.Models;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToSpeckle.TopLevel;
 
-[NameAndRankValue(nameof(CurveObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
-public class CurveObjectToSpeckleTopLevelConverter : RhinoObjectToSpeckleTopLevelConverter<CurveObject, RG.Curve, Base>
+[NameAndRankValue(nameof(IRhinoCurveObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
+public class CurveObjectToSpeckleTopLevelConverter : RhinoObjectToSpeckleTopLevelConverter<IRhinoCurveObject, IRhinoCurve, Base>
 {
-  public CurveObjectToSpeckleTopLevelConverter(ITypedConverter<RG.Curve, Base> conversion)
+  public CurveObjectToSpeckleTopLevelConverter(ITypedConverter<IRhinoCurve, Base> conversion)
     : base(conversion) { }
 
-  protected override RG.Curve GetTypedGeometry(CurveObject input) => input.CurveGeometry;
+  protected override IRhinoCurve GetTypedGeometry(IRhinoCurveObject input) => input.CurveGeometry;
 }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/ExtrusionObjectToSpeckleTopLevelConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/ExtrusionObjectToSpeckleTopLevelConverter.cs
index 46d2c27586..cc59b338af 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/ExtrusionObjectToSpeckleTopLevelConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/ExtrusionObjectToSpeckleTopLevelConverter.cs
@@ -1,23 +1,23 @@
-using Rhino.DocObjects;
-using Speckle.Converters.Common;
+using Speckle.Converters.Common;
 using Speckle.Converters.Common.Objects;
 using Speckle.Core.Models;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToSpeckle.TopLevel;
 
-[NameAndRankValue(nameof(ExtrusionObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
+[NameAndRankValue(nameof(IRhinoExtrusionObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
 public class ExtrusionObjectToSpeckleTopLevelConverter : IToSpeckleTopLevelConverter
 {
-  private readonly ITypedConverter<RG.Brep, SOG.Brep> _curveConverter;
+  private readonly ITypedConverter<IRhinoBrep, SOG.Brep> _curveConverter;
 
-  public ExtrusionObjectToSpeckleTopLevelConverter(ITypedConverter<RG.Brep, SOG.Brep> curveConverter)
+  public ExtrusionObjectToSpeckleTopLevelConverter(ITypedConverter<IRhinoBrep, SOG.Brep> curveConverter)
   {
     _curveConverter = curveConverter;
   }
 
   public Base Convert(object target)
   {
-    var curveObject = (ExtrusionObject)target;
+    var curveObject = (IRhinoExtrusionObject)target;
     var speckleCurve = _curveConverter.Convert(curveObject.ExtrusionGeometry.ToBrep());
     return speckleCurve;
   }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/MeshObjectToSpeckleTopLevelConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/MeshObjectToSpeckleTopLevelConverter.cs
index f1c9675a04..4a4b5978ee 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/MeshObjectToSpeckleTopLevelConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/MeshObjectToSpeckleTopLevelConverter.cs
@@ -1,14 +1,14 @@
-using Rhino.DocObjects;
-using Speckle.Converters.Common;
+using Speckle.Converters.Common;
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToSpeckle.TopLevel;
 
-[NameAndRankValue(nameof(MeshObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
-public class MeshObjectToSpeckleTopLevelConverter : RhinoObjectToSpeckleTopLevelConverter<MeshObject, RG.Mesh, SOG.Mesh>
+[NameAndRankValue(nameof(IRhinoMeshObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
+public class MeshObjectToSpeckleTopLevelConverter : RhinoObjectToSpeckleTopLevelConverter<IRhinoMeshObject, IRhinoMesh, SOG.Mesh>
 {
-  public MeshObjectToSpeckleTopLevelConverter(ITypedConverter<RG.Mesh, SOG.Mesh> conversion)
+  public MeshObjectToSpeckleTopLevelConverter(ITypedConverter<IRhinoMesh, SOG.Mesh> conversion)
     : base(conversion) { }
 
-  protected override RG.Mesh GetTypedGeometry(MeshObject input) => input.MeshGeometry;
+  protected override IRhinoMesh GetTypedGeometry(IRhinoMeshObject input) => input.MeshGeometry;
 }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/PointCloudObjectToSpeckleTopLevelConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/PointCloudObjectToSpeckleTopLevelConverter.cs
index e741e38e49..b25c80d190 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/PointCloudObjectToSpeckleTopLevelConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/PointCloudObjectToSpeckleTopLevelConverter.cs
@@ -1,15 +1,15 @@
-using Rhino.DocObjects;
-using Speckle.Converters.Common;
+using Speckle.Converters.Common;
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToSpeckle.TopLevel;
 
-[NameAndRankValue(nameof(PointCloudObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
+[NameAndRankValue(nameof(IRhinoPointCloudObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
 public class PointCloudObjectToSpeckleTopLevelConverter
-  : RhinoObjectToSpeckleTopLevelConverter<PointCloudObject, RG.PointCloud, SOG.Pointcloud>
+  : RhinoObjectToSpeckleTopLevelConverter<IRhinoPointCloudObject, IRhinoPointCloud, SOG.Pointcloud>
 {
-  public PointCloudObjectToSpeckleTopLevelConverter(ITypedConverter<RG.PointCloud, SOG.Pointcloud> conversion)
+  public PointCloudObjectToSpeckleTopLevelConverter(ITypedConverter<IRhinoPointCloud, SOG.Pointcloud> conversion)
     : base(conversion) { }
 
-  protected override RG.PointCloud GetTypedGeometry(PointCloudObject input) => input.PointCloudGeometry;
+  protected override IRhinoPointCloud GetTypedGeometry(IRhinoPointCloudObject input) => input.PointCloudGeometry;
 }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/PointObjectToSpeckleTopLevelConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/PointObjectToSpeckleTopLevelConverter.cs
index 7d9c750b64..d127aa0266 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/PointObjectToSpeckleTopLevelConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/PointObjectToSpeckleTopLevelConverter.cs
@@ -1,15 +1,15 @@
-using Rhino.DocObjects;
-using Speckle.Converters.Common;
+using Speckle.Converters.Common;
 using Speckle.Converters.Common.Objects;
+using Speckle.Rhino7.Interfaces;
 
 namespace Speckle.Converters.Rhino7.ToSpeckle.TopLevel;
 
-[NameAndRankValue(nameof(PointObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
+[NameAndRankValue(nameof(IRhinoPointObject), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
 public class PointObjectToSpeckleTopLevelConverter
-  : RhinoObjectToSpeckleTopLevelConverter<PointObject, RG.Point, SOG.Point>
+  : RhinoObjectToSpeckleTopLevelConverter<IRhinoPointObject, IRhinoPoint, SOG.Point>
 {
-  public PointObjectToSpeckleTopLevelConverter(ITypedConverter<RG.Point, SOG.Point> conversion)
+  public PointObjectToSpeckleTopLevelConverter(ITypedConverter<IRhinoPoint, SOG.Point> conversion)
     : base(conversion) { }
 
-  protected override RG.Point GetTypedGeometry(PointObject input) => input.PointGeometry;
+  protected override IRhinoPoint GetTypedGeometry(IRhinoPointObject input) => input.PointGeometry;
 }
diff --git a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/RhinoObjectToSpeckleTopLevelConverter.cs b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/RhinoObjectToSpeckleTopLevelConverter.cs
index edff24473a..c21065cd68 100644
--- a/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/RhinoObjectToSpeckleTopLevelConverter.cs
+++ b/DUI3-DX/Converters/Rhino/Speckle.Converters.Rhino7/ToSpeckle/TopLevel/RhinoObjectToSpeckleTopLevelConverter.cs
@@ -4,8 +4,8 @@
 namespace Speckle.Converters.Rhino7.ToSpeckle.TopLevel;
 
 public abstract class RhinoObjectToSpeckleTopLevelConverter<TTopLevelIn, TInRaw, TOutRaw> : IToSpeckleTopLevelConverter
-  where TTopLevelIn : Rhino.DocObjects.RhinoObject
-  where TInRaw : RG.GeometryBase
+  where TTopLevelIn : notnull
+  where TInRaw : notnull
   where TOutRaw : Base
 {
   public ITypedConverter<TInRaw, TOutRaw> Conversion { get; }