diff --git a/examples/c-sharp-examples/GlobalRegistration.dox.cs b/examples/c-sharp-examples/GlobalRegistration.dox.cs
index 9a7addfa299e..50cb8911c912 100644
--- a/examples/c-sharp-examples/GlobalRegistration.dox.cs
+++ b/examples/c-sharp-examples/GlobalRegistration.dox.cs
@@ -39,11 +39,11 @@ public static void Run(string[] args)
                 input_pointclouds.Add(pc); // Need this to prevent the point-cloud object from dying too early.
                 MR.MeshOrPointsXf obj = new MR.MeshOrPointsXf(pc, new MR.AffineXf3f());
                 inputs.PushBack(obj);
-                maxBBox.Include(obj.Obj.ComputeBoundingBox());
+                maxBBox.Include(obj.obj.ComputeBoundingBox());
             }
 
             MR.MultiwayICPSamplingParameters samplingParams = new();
-            samplingParams.SamplingVoxelSize = maxBBox.Diagonal() * 0.03f;
+            samplingParams.samplingVoxelSize = maxBBox.Diagonal() * 0.03f;
 
             MR.MultiwayICP icp = new(inputs, samplingParams);
             MR.ICPProperties iCPProperties = new();
@@ -59,8 +59,8 @@ public static void Run(string[] args)
             {
                 MR.ObjId id = new(i);
                 var xf = xfs.Index(id);
-                for (ulong j = 0; j < inputs.Index(id).Obj.Points().Size(); j++)
-                    output.AddPoint(xf.Call(inputs.Index(id).Obj.Points().Index(new MR.VertId(j))));
+                for (ulong j = 0; j < inputs.Index(id).obj.Points().Size(); j++)
+                    output.AddPoint(xf.Call(inputs.Index(id).obj.Points().Index(new MR.VertId(j))));
             }
 
             MR.PointsSave.ToAnySupportedFormat(output, args[args.Length - 1]);
diff --git a/examples/c-sharp-examples/MeshBoolean.dox.cs b/examples/c-sharp-examples/MeshBoolean.dox.cs
index 0f6f56aceddf..cfff7fe62b76 100644
--- a/examples/c-sharp-examples/MeshBoolean.dox.cs
+++ b/examples/c-sharp-examples/MeshBoolean.dox.cs
@@ -20,7 +20,7 @@ public static void Run(string[] args)
             MR.BooleanResult res = MR.Boolean(mesh_a, mesh_b, MR.BooleanOperation.Intersection);
 
             // save result to STL file
-            MR.MeshSave.ToAnySupportedFormat(res.Mesh, "out_boolean.stl");
+            MR.MeshSave.ToAnySupportedFormat(res.mesh, "out_boolean.stl");
         }
         catch (Exception e)
         {
diff --git a/examples/c-sharp-examples/MeshDecimate.dox.cs b/examples/c-sharp-examples/MeshDecimate.dox.cs
index d9324110e52c..1b95f9ef412b 100644
--- a/examples/c-sharp-examples/MeshDecimate.dox.cs
+++ b/examples/c-sharp-examples/MeshDecimate.dox.cs
@@ -9,10 +9,10 @@ public static void Run(string[] args)
 
             // Setup decimate parameters
             MR.DecimateSettings ds = new();
-            ds.Strategy = MR.DecimateStrategy.MinimizeError;
-            ds.MaxError = 1e-5f * mesh.ComputeBoundingBox().Diagonal();
-            ds.TinyEdgeLength = 1e-3f;
-            ds.PackMesh = true;
+            ds.strategy = MR.DecimateStrategy.MinimizeError;
+            ds.maxError = 1e-5f * mesh.ComputeBoundingBox().Diagonal();
+            ds.tinyEdgeLength = 1e-3f;
+            ds.packMesh = true;
 
             // Decimate mesh
             MR.DecimateResult result = MR.DecimateMesh(mesh, ds);
diff --git a/examples/c-sharp-examples/MeshExport.dox.cs b/examples/c-sharp-examples/MeshExport.dox.cs
index 72b84cbf5ca4..3e5ea01facf2 100644
--- a/examples/c-sharp-examples/MeshExport.dox.cs
+++ b/examples/c-sharp-examples/MeshExport.dox.cs
@@ -6,18 +6,18 @@ public static void Run(string[] args)
         {
             MR.Mesh mesh = MR.MakeCube(MR.Vector3f.Diagonal(1), MR.Vector3f.Diagonal(-0.5f));
             Console.WriteLine("Vertices coordinates:");
-            for (ulong i = 0; i < mesh.Points.Size(); ++i)
+            for (ulong i = 0; i < mesh.points.Size(); ++i)
             {
-                var p = mesh.Points.Index(new MR.VertId(i));
-                Console.WriteLine("Vertex {0} coordinates: {1}; {2}; {3}", i, p.X, p.Y, p.Z);
+                var p = mesh.points.Index(new MR.VertId(i));
+                Console.WriteLine("Vertex {0} coordinates: {1}; {2}; {3}", i, p.x, p.y, p.z);
             }
 
-            MR.Triangulation tri = mesh.Topology.GetTriangulation();
+            MR.Triangulation tri = mesh.topology.GetTriangulation();
 
             for (ulong i = 0; i < tri.Size(); ++i)
             {
                 var t = tri.Index(new MR.FaceId(i));
-                Console.WriteLine("Triangle {0} vertices: {1}; {2}; {3}", i, t.Elems._0.Id, t.Elems._1.Id, t.Elems._2.Id);
+                Console.WriteLine("Triangle {0} vertices: {1}; {2}; {3}", i, t.elems._0.id, t.elems._1.id, t.elems._2.id);
             }
         }
         catch (Exception e)
diff --git a/examples/c-sharp-examples/MeshFillHole.dox.cs b/examples/c-sharp-examples/MeshFillHole.dox.cs
index aa2b1ef7a1a1..646b7462840a 100644
--- a/examples/c-sharp-examples/MeshFillHole.dox.cs
+++ b/examples/c-sharp-examples/MeshFillHole.dox.cs
@@ -17,10 +17,10 @@ public static void Run(string[] args)
 
             var mesh = MR.MeshLoad.FromAnySupportedFormat(inputFile);
 
-            MR.Std.Vector_MREdgeId holes = mesh.Topology.FindHoleRepresentiveEdges();
+            MR.Std.Vector_MREdgeId holes = mesh.topology.FindHoleRepresentiveEdges();
 
             MR.FillHoleParams fillHoleParams = new();
-            fillHoleParams.Metric.Assign(MR.GetUniversalMetric(mesh));
+            fillHoleParams.metric.Assign(MR.GetUniversalMetric(mesh));
             MR.FaceBitSet outfaces = new();
             // TODO
             // fillHoleParams.OutNewFaces = ...
diff --git a/examples/c-sharp-examples/MeshFixDegeneracies.dox.cs b/examples/c-sharp-examples/MeshFixDegeneracies.dox.cs
index 53a9936f9a3c..f158bb37e0bd 100644
--- a/examples/c-sharp-examples/MeshFixDegeneracies.dox.cs
+++ b/examples/c-sharp-examples/MeshFixDegeneracies.dox.cs
@@ -18,8 +18,8 @@ public static void Run(string[] args)
             var mesh = MR.MeshLoad.FromAnySupportedFormat(inputFile);
 
             MR.FixMeshDegeneraciesParams parameters = new();
-            parameters.MaxDeviation = mesh.ComputeBoundingBox().Diagonal() * 1e-5f;
-            parameters.TinyEdgeLength = 1e-3f;
+            parameters.maxDeviation = mesh.ComputeBoundingBox().Diagonal() * 1e-5f;
+            parameters.tinyEdgeLength = 1e-3f;
 
             MR.FixMeshDegeneracies(mesh, parameters);
             MR.MeshSave.ToAnySupportedFormat(mesh, outputFile);
diff --git a/examples/c-sharp-examples/MeshICP.dox.cs b/examples/c-sharp-examples/MeshICP.dox.cs
index 76f5f39d2e53..aa8980b43376 100644
--- a/examples/c-sharp-examples/MeshICP.dox.cs
+++ b/examples/c-sharp-examples/MeshICP.dox.cs
@@ -13,11 +13,11 @@ public static void Run()
             MR.MeshOrPointsXf mesh_xf_fixed = new(mesh_fixed, new MR.AffineXf3f());
 
             // Prepare ICP parameters
-            float diagonal = mesh_xf_fixed.Obj.ComputeBoundingBox().Diagonal();
+            float diagonal = mesh_xf_fixed.obj.ComputeBoundingBox().Diagonal();
             float icpSamplingVoxelSize = diagonal * 0.01f; // To sample points from object
             MR.ICPProperties icpParams = new();
-            icpParams.DistThresholdSq = diagonal * diagonal * 0.01f; // Use points pairs with maximum distance specified
-            icpParams.ExitVal = diagonal * 0.003f; // Stop when distance reached
+            icpParams.distThresholdSq = diagonal * diagonal * 0.01f; // Use points pairs with maximum distance specified
+            icpParams.exitVal = diagonal * 0.003f; // Stop when distance reached
 
             // Calculate transformation
             MR.ICP icp = new(mesh_xf_floating, mesh_xf_fixed, icpSamplingVoxelSize);
diff --git a/examples/c-sharp-examples/MeshOffset.dox.cs b/examples/c-sharp-examples/MeshOffset.dox.cs
index 467cc6709ef0..65401e25745c 100644
--- a/examples/c-sharp-examples/MeshOffset.dox.cs
+++ b/examples/c-sharp-examples/MeshOffset.dox.cs
@@ -24,7 +24,7 @@ public static void Run(string[] args)
 
             // Setup parameters
             MR.OffsetParameters op = new();
-            op.VoxelSize = MR.SuggestVoxelSize(mp, 1e6f);
+            op.voxelSize = MR.SuggestVoxelSize(mp, 1e6f);
 
             // Make offset mesh
             var result = MR.OffsetMesh(mp, offsetValue, op);
diff --git a/examples/c-sharp-examples/Triangulation.dox.cs b/examples/c-sharp-examples/Triangulation.dox.cs
index 806ddcf2fda4..0e74fddf76eb 100644
--- a/examples/c-sharp-examples/Triangulation.dox.cs
+++ b/examples/c-sharp-examples/Triangulation.dox.cs
@@ -37,7 +37,7 @@ public static void Run()
             // Fix possible issues
             MR.OffsetParameters offsetParameters = new();
             MR.MeshPart mp = new(triangulated);
-            offsetParameters.VoxelSize = MR.SuggestVoxelSize(mp, 5e+6f);
+            offsetParameters.voxelSize = MR.SuggestVoxelSize(mp, 5e+6f);
             var offset = MR.OffsetMesh(mp, 0f, offsetParameters);
 
             // Save result
diff --git a/source/MRDotNet2Test/src/AffineXffTests.cs b/source/MRDotNet2Test/src/AffineXffTests.cs
index 8c3b2815454f..3df8a5b504bd 100644
--- a/source/MRDotNet2Test/src/AffineXffTests.cs
+++ b/source/MRDotNet2Test/src/AffineXffTests.cs
@@ -10,8 +10,8 @@ internal class AffineXfTests
         public void TestDefaultConstructor()
         {
             var a = new AffineXf3f();
-            Assert.That( a.A == new Matrix3f() );
-            Assert.That( a.B == new Vector3f() );
+            Assert.That( a.a == new Matrix3f() );
+            Assert.That( a.b == new Vector3f() );
         }
 
         [Test]
@@ -21,8 +21,8 @@ public void TestConstructor()
             var b = new Vector3f( 10, 11, 12 );
 
             var a = new AffineXf3f( A, b );
-            Assert.That( a.A == A );
-            Assert.That( a.B == b );
+            Assert.That( a.a == A );
+            Assert.That( a.b == b );
         }
 
         [Test]
@@ -30,8 +30,8 @@ public void TestLinearConstructor()
         {
             var A = new Matrix3f( new Vector3f( 1, 2, 3 ), new Vector3f( 4, 5, 6 ), new Vector3f( 7, 8, 9 ) );
             var a = AffineXf3f.Linear( A );
-            Assert.That( a.A == A );
-            Assert.That( a.B == new Vector3f() );
+            Assert.That( a.a == A );
+            Assert.That( a.b == new Vector3f() );
         }
 
         [Test]
@@ -39,8 +39,8 @@ public void TestTranslationConstructor()
         {
             var b = new Vector3f( 10, 11, 12 );
             var a = AffineXf3f.Translation( b );
-            Assert.That( a.A == new Matrix3f() );
-            Assert.That( a.B == b );
+            Assert.That( a.a == new Matrix3f() );
+            Assert.That( a.b == b );
         }
 
         [Test]
@@ -51,8 +51,8 @@ public void TestMultiplication()
             var xf = new AffineXf3f( A, b );
 
             var res = xf * xf;
-            Assert.That( res.A == A * A );
-            Assert.That( res.B == A * b + b );
+            Assert.That( res.a == A * A );
+            Assert.That( res.b == A * b + b );
         }
 
     }
diff --git a/source/MRDotNet2Test/src/BooleanTests.cs b/source/MRDotNet2Test/src/BooleanTests.cs
index 34ff6fe7d123..6288a56e2668 100644
--- a/source/MRDotNet2Test/src/BooleanTests.cs
+++ b/source/MRDotNet2Test/src/BooleanTests.cs
@@ -36,10 +36,10 @@ public void TestOperations()
                             Matrix3f rotation = new Matrix3f();
                             for (int i = 0; i < 3; ++i)
                                 if ( ( maskRot & (1 << i) ) > 0 )
-                                    rotation = Matrix3f.Rotation( baseAxis[i], angle ) * rotation; 
+                                    rotation = Matrix3f.Rotation( baseAxis[i], angle ) * rotation;
 
                             BooleanParameters parameters = new BooleanParameters();
-                            parameters.RigidB2A = AffineXf3f.Translation(shiftVec) * AffineXf3f.Linear(rotation);
+                            parameters.rigidB2A = AffineXf3f.Translation(shiftVec) * AffineXf3f.Linear(rotation);
 
                             Assert.DoesNotThrow(() => Boolean(meshA, meshB, BooleanOperation.Union, parameters));
                             Assert.DoesNotThrow(() => Boolean(meshA, meshB, BooleanOperation.Intersection, parameters));
@@ -57,17 +57,17 @@ public void TestMapper()
             meshB.Transform(AffineXf3f.Linear(Matrix3f.Rotation(Vector3f.PlusZ(), Vector3f.PlusY())));
 
             var parameters = new BooleanParameters();
-            parameters.Mapper = new BooleanResultMapper();
+            parameters.mapper = new BooleanResultMapper();
             var booleanResult = Boolean(meshA, meshB, BooleanOperation.Union, parameters);
 
-            var validPointsA = meshA.Topology.GetValidVerts();
-            var validPointsB = meshB.Topology.GetValidVerts();
-            var validFacesA = meshA.Topology.GetValidFaces();
-            var validFacesB = meshB.Topology.GetValidFaces();
+            var validPointsA = meshA.topology.GetValidVerts();
+            var validPointsB = meshB.topology.GetValidVerts();
+            var validFacesA = meshA.topology.GetValidFaces();
+            var validFacesB = meshB.topology.GetValidFaces();
 
-            var old2NewVerts = parameters.Mapper.GetMaps(BooleanResultMapper.MapObject.A).Old2newVerts;
-            var vMapA = parameters.Mapper.Map(validPointsA, BooleanResultMapper.MapObject.A);
-            var vMapB = parameters.Mapper.Map(validPointsB, BooleanResultMapper.MapObject.B);
+            var old2NewVerts = parameters.mapper.GetMaps(BooleanResultMapper.MapObject.A).old2newVerts;
+            var vMapA = parameters.mapper.Map(validPointsA, BooleanResultMapper.MapObject.A);
+            var vMapB = parameters.mapper.Map(validPointsB, BooleanResultMapper.MapObject.B);
 
             Assert.That(vMapA.Size(), Is.EqualTo(60) );
             Assert.That(vMapA.Count(), Is.EqualTo(60));
@@ -75,29 +75,29 @@ public void TestMapper()
             Assert.That(vMapB.Count(), Is.EqualTo(48));
 
 
-            var fMapA = parameters.Mapper.Map(validFacesA, BooleanResultMapper.MapObject.A);
-            var fMapB = parameters.Mapper.Map(validFacesB, BooleanResultMapper.MapObject.B);
+            var fMapA = parameters.mapper.Map(validFacesA, BooleanResultMapper.MapObject.A);
+            var fMapB = parameters.mapper.Map(validFacesB, BooleanResultMapper.MapObject.B);
 
             Assert.That(fMapA.Size(), Is.EqualTo(224) );
             Assert.That(fMapA.Count(), Is.EqualTo(224));
             Assert.That(fMapB.Size(), Is.EqualTo(416) );
             Assert.That(fMapB.Count(), Is.EqualTo(192));
 
-            var newFaces = parameters.Mapper.NewFaces();
+            var newFaces = parameters.mapper.NewFaces();
             Assert.That(newFaces.Size(), Is.EqualTo(416) );
             Assert.That(newFaces.Count(), Is.EqualTo(252));
 
-            var mapsA = parameters.Mapper.GetMaps( BooleanResultMapper.MapObject.A );
-            Assert.That(!mapsA.Identity);
-            Assert.That( mapsA.Old2newVerts.Size(), Is.EqualTo(160) );
-            Assert.That( mapsA.Cut2newFaces.Size(), Is.EqualTo(348) );
-            Assert.That( mapsA.Cut2origin.Size(), Is.EqualTo(348) );
-
-            var mapsB = parameters.Mapper.GetMaps( BooleanResultMapper.MapObject.B );
-            Assert.That(!mapsB.Identity);
-            Assert.That( mapsB.Old2newVerts.Size(), Is.EqualTo(160) );
-            Assert.That( mapsB.Cut2newFaces.Size(), Is.EqualTo(384) );
-            Assert.That( mapsB.Cut2origin.Size(), Is.EqualTo(384) );
+            var mapsA = parameters.mapper.GetMaps( BooleanResultMapper.MapObject.A );
+            Assert.That(!mapsA.identity);
+            Assert.That( mapsA.old2newVerts.Size(), Is.EqualTo(160) );
+            Assert.That( mapsA.cut2newFaces.Size(), Is.EqualTo(348) );
+            Assert.That( mapsA.cut2origin.Size(), Is.EqualTo(348) );
+
+            var mapsB = parameters.mapper.GetMaps( BooleanResultMapper.MapObject.B );
+            Assert.That(!mapsB.identity);
+            Assert.That( mapsB.old2newVerts.Size(), Is.EqualTo(160) );
+            Assert.That( mapsB.cut2newFaces.Size(), Is.EqualTo(384) );
+            Assert.That( mapsB.cut2origin.Size(), Is.EqualTo(384) );
         }
     }
 }
diff --git a/source/MRDotNet2Test/src/Box3Tests.cs b/source/MRDotNet2Test/src/Box3Tests.cs
index 6bc5bba0355e..1959bdd328ce 100644
--- a/source/MRDotNet2Test/src/Box3Tests.cs
+++ b/source/MRDotNet2Test/src/Box3Tests.cs
@@ -2,7 +2,7 @@
 using static MR;
 
 namespace MRTest
-{ 
+{
     [TestFixture]
     internal class Box3Tests
     {
@@ -17,23 +17,23 @@ public void TestDefaultConstructor()
         public void TestBox()
         {
             var box = new Box3f(new Vector3f(1, 2, 3), new Vector3f(4, 5, 6));
-            Assert.That(box.Min.X == 1);
-            Assert.That(box.Min.Y == 2);
-            Assert.That(box.Min.Z == 3);
+            Assert.That(box.min.x == 1);
+            Assert.That(box.min.y == 2);
+            Assert.That(box.min.z == 3);
 
-            Assert.That(box.Max.X == 4);
-            Assert.That(box.Max.Y == 5);
-            Assert.That(box.Max.Z == 6);
+            Assert.That(box.max.x == 4);
+            Assert.That(box.max.y == 5);
+            Assert.That(box.max.z == 6);
 
             var center = box.Center();
-            Assert.That(center.X == 2.5);
-            Assert.That(center.Y == 3.5);
-            Assert.That(center.Z == 4.5);
+            Assert.That(center.x == 2.5);
+            Assert.That(center.y == 3.5);
+            Assert.That(center.z == 4.5);
 
             var size = box.Size();
-            Assert.That(size.X == 3);
-            Assert.That(size.Y == 3);
-            Assert.That(size.Z == 3);
+            Assert.That(size.x == 3);
+            Assert.That(size.y == 3);
+            Assert.That(size.z == 3);
 
             float diagonal = box.Diagonal();
             Assert.That(diagonal, Is.EqualTo(5.19).Within(0.01));
diff --git a/source/MRDotNet2Test/src/ConvexHullTests.cs b/source/MRDotNet2Test/src/ConvexHullTests.cs
index 52063fc84460..d17639b12f2c 100644
--- a/source/MRDotNet2Test/src/ConvexHullTests.cs
+++ b/source/MRDotNet2Test/src/ConvexHullTests.cs
@@ -14,9 +14,9 @@ public void TestConvexHull()
             var meshA = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f));
             var meshB = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(0.0f));
             var union = Boolean(meshA, meshB, BooleanOperation.Union);
-            var convexHull = MakeConvexHull(union.Mesh);
+            var convexHull = MakeConvexHull(union.mesh);
 
-            Assert.That(convexHull.Points.Size() == 14);
+            Assert.That(convexHull.points.Size() == 14);
         }
     }
 }
diff --git a/source/MRDotNet2Test/src/DecimateTests.cs b/source/MRDotNet2Test/src/DecimateTests.cs
index a456ecc1750e..d864d95c4c75 100644
--- a/source/MRDotNet2Test/src/DecimateTests.cs
+++ b/source/MRDotNet2Test/src/DecimateTests.cs
@@ -13,30 +13,30 @@ public void TestDecimate()
         {
             Mesh sphere = MakeSphere( new SphereParams( 0.5f, 30000 ) );
 
-            var savedRegion = new FaceBitSet((Const_BitSet)sphere.Topology.GetValidFaces());
+            var savedRegion = new FaceBitSet((Const_BitSet)sphere.topology.GetValidFaces());
 
             var parameters = new DecimateSettings();
-            var region = new FaceBitSet((Const_BitSet)sphere.Topology.GetValidFaces());
+            var region = new FaceBitSet((Const_BitSet)sphere.topology.GetValidFaces());
             if ( region is not null )
-                parameters.Region = region;
+                parameters.region = region;
 
-            parameters.MaxTriangleAspectRatio = 80;
+            parameters.maxTriangleAspectRatio = 80;
 
             var decimateResult = DecimateMesh(sphere, parameters);
-            Assert.That(parameters.Region is not null && !parameters.Region.Equals( savedRegion ) );
-            Assert.That(decimateResult.FacesDeleted > 0);
-            Assert.That(decimateResult.VertsDeleted > 0);
+            Assert.That(parameters.region is not null && !parameters.region.Equals( savedRegion ) );
+            Assert.That(decimateResult.facesDeleted > 0);
+            Assert.That(decimateResult.vertsDeleted > 0);
         }
 
         [Test]
         public void TestRemesh()
         {
             var sphere = MakeSphere( new SphereParams( 0.5f, 300 ) );
-            Assert.That(sphere.Topology.GetValidFaces().Count(), Is.EqualTo(596));
+            Assert.That(sphere.topology.GetValidFaces().Count(), Is.EqualTo(596));
             var parameters = new RemeshSettings();
-            parameters.TargetEdgeLen = 0.1f;
+            parameters.targetEdgeLen = 0.1f;
             var remeshResult = Remesh(sphere, parameters);
-            Assert.That(sphere.Topology.GetValidFaces().Count(), Is.EqualTo(716));
+            Assert.That(sphere.topology.GetValidFaces().Count(), Is.EqualTo(716));
         }
     }
 }
diff --git a/source/MRDotNet2Test/src/ExpandShrink.cs b/source/MRDotNet2Test/src/ExpandShrink.cs
index e57e07195a77..4ef7bcbf3a13 100644
--- a/source/MRDotNet2Test/src/ExpandShrink.cs
+++ b/source/MRDotNet2Test/src/ExpandShrink.cs
@@ -10,11 +10,11 @@ internal class ExpandShrinkTests
         public void TestExpandShrink()
         {
             var mesh = MakeSphere(new SphereParams(1.0f, 3000));
-            var region = Expand(mesh.Topology, new FaceId(0), 3);
+            var region = Expand(mesh.topology, new FaceId(0), 3);
             Assert.That(region.Count, Is.EqualTo(75));
-            Expand(mesh.Topology, region, 3);
+            Expand(mesh.topology, region, 3);
             Assert.That(region.Count, Is.GreaterThan(75));
-            Shrink(mesh.Topology, region, 3);
+            Shrink(mesh.topology, region, 3);
             Assert.That(region.Count, Is.EqualTo(75));
         }
 
@@ -22,11 +22,11 @@ public void TestExpandShrink()
         public void TestExpandShrinkVerts()
         {
             var mesh = MakeSphere(new SphereParams(1.0f, 3000));
-            var region = Expand(mesh.Topology, new VertId(0), 3);
+            var region = Expand(mesh.topology, new VertId(0), 3);
             Assert.That(region.Count, Is.EqualTo(37));
-            Expand(mesh.Topology, region, 3);
+            Expand(mesh.topology, region, 3);
             Assert.That(region.Count, Is.GreaterThan(37));
-            Shrink(mesh.Topology, region, 3);
+            Shrink(mesh.topology, region, 3);
             Assert.That(region.Count, Is.EqualTo(37));
         }
 
diff --git a/source/MRDotNet2Test/src/FillHoleTests.cs b/source/MRDotNet2Test/src/FillHoleTests.cs
index 686a206e1ca6..62cfa9d1cff4 100644
--- a/source/MRDotNet2Test/src/FillHoleTests.cs
+++ b/source/MRDotNet2Test/src/FillHoleTests.cs
@@ -8,9 +8,9 @@ internal class FillHoleTests
     {
         private static void updateTri(Std.Mut_Array_MRVertId_3 tri, int v0, int v1, int v2)
         {
-            tri.Elems._0 = new VertId(v0);
-            tri.Elems._1 = new VertId(v1);
-            tri.Elems._2 = new VertId(v2);
+            tri.elems._0 = new VertId(v0);
+            tri.elems._1 = new VertId(v1);
+            tri.elems._2 = new VertId(v2);
         }
 
         private static Mesh CreateMeshWithHoles()
@@ -37,20 +37,20 @@ private static Mesh CreateMeshWithHoles()
         public void TestFillHole()
         {
             var mesh = CreateMeshWithHoles();
-            var holes = mesh.Topology.FindHoleRepresentiveEdges();
+            var holes = mesh.topology.FindHoleRepresentiveEdges();
             Assert.That(holes.Size(), Is.EqualTo(2) );
 
             var param = new FillHoleParams();
 
             FillHoles(mesh, holes, param);
-            Assert.That(mesh.Topology.FindHoleRepresentiveEdges().Size(), Is.EqualTo(0));
+            Assert.That(mesh.topology.FindHoleRepresentiveEdges().Size(), Is.EqualTo(0));
         }
 
         [Test]
         public void TestFillHoleNicely()
         {
             var mesh = CreateMeshWithHoles();
-            var holes = mesh.Topology.FindHoleRepresentiveEdges();
+            var holes = mesh.topology.FindHoleRepresentiveEdges();
             Assert.That(holes.Size(), Is.EqualTo(2));
 
             var param = new FillHoleNicelySettings();
@@ -58,14 +58,14 @@ public void TestFillHoleNicely()
             var patch = FillHoleNicely(mesh, holes.At(0), param);
 
             Assert.That( patch.Count, Is.EqualTo(1887) );
-            Assert.That(mesh.Topology.FindHoleRepresentiveEdges().Size(), Is.EqualTo(1));
+            Assert.That(mesh.topology.FindHoleRepresentiveEdges().Size(), Is.EqualTo(1));
         }
 
         [Test]
         public void TestRightBoundary()
         {
             var mesh = CreateMeshWithHoles();
-            var loops = FindRightBoundary(mesh.Topology);
+            var loops = FindRightBoundary(mesh.topology);
             Assert.That(loops.Size(), Is.EqualTo(2));
             Assert.That(loops.At(0).Size(), Is.EqualTo(3));
             Assert.That(loops.At(1).Size(), Is.EqualTo(4));
diff --git a/source/MRDotNet2Test/src/ICPTests.cs b/source/MRDotNet2Test/src/ICPTests.cs
index 79a1f3a54c51..a586aad2a02d 100644
--- a/source/MRDotNet2Test/src/ICPTests.cs
+++ b/source/MRDotNet2Test/src/ICPTests.cs
@@ -16,17 +16,17 @@ public void TestMultiwayICP()
             Box3f maxBBox = new Box3f();
 
             inputs.PushBack( new MeshOrPointsXf(MakeSphere(new SphereParams(1.0f, 1000)), new AffineXf3f()));
-            Box3f bbox = inputs.At(0).Obj.GetObjBoundingBox();
+            Box3f bbox = inputs.At(0).obj.GetObjBoundingBox();
             if (!maxBBox.Valid() || bbox.Volume() > maxBBox.Volume())
                 maxBBox = bbox;
 
             inputs.PushBack(new MeshOrPointsXf(MakeSphere(new SphereParams(1.0f, 1000)), AffineXf3f.Linear(Matrix3f.Rotation(Vector3f.PlusZ(), 0.1f))));
-            bbox = inputs.At(1).Obj.GetObjBoundingBox();
+            bbox = inputs.At(1).obj.GetObjBoundingBox();
             if (!maxBBox.Valid() || bbox.Volume() > maxBBox.Volume())
                 maxBBox = bbox;
 
             MultiwayICPSamplingParameters samplingParams = new MultiwayICPSamplingParameters();
-            samplingParams.SamplingVoxelSize = maxBBox.Diagonal() * 0.03f;
+            samplingParams.samplingVoxelSize = maxBBox.Diagonal() * 0.03f;
 
             MultiwayICP icp = new MultiwayICP(new Vector_MRMeshOrPointsXf_MRObjId(Misc.Move(inputs)), samplingParams);
             ICPProperties iCPProperties = new ICPProperties();
@@ -57,8 +57,8 @@ public void TestICP()
             MeshOrPointsXf flt = new MeshOrPointsXf(torusMove, xf );
             MeshOrPointsXf refer = new MeshOrPointsXf( torusRef, new AffineXf3f());
 
-            var fltSamples = torusMove.Topology.GetValidVerts();
-            var referSamples = torusRef.Topology.GetValidVerts();
+            var fltSamples = torusMove.topology.GetValidVerts();
+            var referSamples = torusRef.topology.GetValidVerts();
             Assert.That(fltSamples is not null);
             Assert.That(referSamples is not null);
 
@@ -71,22 +71,22 @@ public void TestICP()
             Console.WriteLine(icp.GetStatusInfo());
 
             var diffXf = new AffineXf3f();
-            diffXf.A -= newXf.A;
-            diffXf.B -= newXf.B;
-
-            Assert.That(Math.Abs(diffXf.A.X.X), Is.LessThan(1e-6f));
-            Assert.That(Math.Abs(diffXf.A.X.Y), Is.LessThan(1e-6f));
-            Assert.That(Math.Abs(diffXf.A.X.Z), Is.LessThan(1e-6f));
-            Assert.That(Math.Abs(diffXf.A.Y.X), Is.LessThan(1e-6f));
-            Assert.That(Math.Abs(diffXf.A.Y.Y), Is.LessThan(1e-6f));
-            Assert.That(Math.Abs(diffXf.A.Y.Z), Is.LessThan(1e-6f));
-            Assert.That(Math.Abs(diffXf.A.Z.X), Is.LessThan(1e-6f));
-            Assert.That(Math.Abs(diffXf.A.Z.Y), Is.LessThan(1e-6f));
-            Assert.That(Math.Abs(diffXf.A.Z.Z), Is.LessThan(1e-6f));
-
-            Assert.That(Math.Abs(diffXf.B.X), Is.LessThan(1e-6f));
-            Assert.That(Math.Abs(diffXf.B.Y), Is.LessThan(1e-6f));
-            Assert.That(Math.Abs(diffXf.B.Z), Is.LessThan(1e-6f));
+            diffXf.a -= newXf.a;
+            diffXf.b -= newXf.b;
+
+            Assert.That(Math.Abs(diffXf.a.x.x), Is.LessThan(1e-6f));
+            Assert.That(Math.Abs(diffXf.a.x.y), Is.LessThan(1e-6f));
+            Assert.That(Math.Abs(diffXf.a.x.z), Is.LessThan(1e-6f));
+            Assert.That(Math.Abs(diffXf.a.y.x), Is.LessThan(1e-6f));
+            Assert.That(Math.Abs(diffXf.a.y.y), Is.LessThan(1e-6f));
+            Assert.That(Math.Abs(diffXf.a.y.z), Is.LessThan(1e-6f));
+            Assert.That(Math.Abs(diffXf.a.z.x), Is.LessThan(1e-6f));
+            Assert.That(Math.Abs(diffXf.a.z.y), Is.LessThan(1e-6f));
+            Assert.That(Math.Abs(diffXf.a.z.z), Is.LessThan(1e-6f));
+
+            Assert.That(Math.Abs(diffXf.b.x), Is.LessThan(1e-6f));
+            Assert.That(Math.Abs(diffXf.b.y), Is.LessThan(1e-6f));
+            Assert.That(Math.Abs(diffXf.b.z), Is.LessThan(1e-6f));
 
             var pairs = icp.GetRef2FltPairs();
             Assert.That(pairs.Size(), Is.EqualTo(1024));
diff --git a/source/MRDotNet2Test/src/LaplacianTests.cs b/source/MRDotNet2Test/src/LaplacianTests.cs
index eb4d4868fdd7..56de01b9672e 100644
--- a/source/MRDotNet2Test/src/LaplacianTests.cs
+++ b/source/MRDotNet2Test/src/LaplacianTests.cs
@@ -18,12 +18,12 @@ public void TestLaplacian()
             var laplacian = new Laplacian(mesh);
 
             // initialize laplacian
-            var triangulation = mesh.Topology.GetTriangulation();
-            var i0 = triangulation.Front().Elems._0;
-            var i1 = triangulation.Back().Elems._0;
+            var triangulation = mesh.topology.GetTriangulation();
+            var i0 = triangulation.Front().elems._0;
+            var i1 = triangulation.Back().elems._0;
 
-            var ancV0 = mesh.Points.Index(i0);
-            var ancV1 = mesh.Points.Index(i1);
+            var ancV0 = mesh.points.Index(i0);
+            var ancV1 = mesh.points.Index(i1);
 
             EdgeWeights edgeWeights = EdgeWeights.Unit;
             VertexMass vertexMass = VertexMass.Unit;
@@ -31,7 +31,7 @@ public void TestLaplacian()
 
             // fix specific vertices
             VertBitSet freeVerts = new VertBitSet();
-            freeVerts.Resize(mesh.Topology.GetValidVerts().Count());
+            freeVerts.Resize(mesh.topology.GetValidVerts().Count());
             freeVerts.Set(i0, true);
             freeVerts.Set(i1, true);
 
@@ -46,4 +46,4 @@ public void TestLaplacian()
             Assert.That(laplacian is not null);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/source/MRDotNet2Test/src/MRPointsToMeshProjectorTest.cs b/source/MRDotNet2Test/src/MRPointsToMeshProjectorTest.cs
index ac8e5644ce51..16f0f48b59ea 100644
--- a/source/MRDotNet2Test/src/MRPointsToMeshProjectorTest.cs
+++ b/source/MRDotNet2Test/src/MRPointsToMeshProjectorTest.cs
@@ -11,14 +11,14 @@ public void TestPointsToMeshProjector()
         {
             var meshA = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(0));
             var meshB = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(0));
-            
+
             var parameters = new MeshProjectionParameters();
             var shift = new Vector3f(1, 2, 3);
 
-            parameters.Xf = AffineXf3f.Translation(shift);
+            parameters.xf = AffineXf3f.Translation(shift);
 
             var res = FindSignedDistances(meshA, meshB, parameters);
-            Assert.That(res.Size(), Is.EqualTo(meshB.Topology.GetValidVerts().Count()));
+            Assert.That(res.Size(), Is.EqualTo(meshB.topology.GetValidVerts().Count()));
 
             // TODO: iteration
             float resMax = 0f;
diff --git a/source/MRDotNet2Test/src/Main.cs b/source/MRDotNet2Test/src/Main.cs
index 30b48e19503c..e95b5735b024 100644
--- a/source/MRDotNet2Test/src/Main.cs
+++ b/source/MRDotNet2Test/src/Main.cs
@@ -13,16 +13,16 @@ public static int Main(string[] args)
             // Copy it into another mesh.
             Mesh sphere2 = new Mesh(sphere1);
             // Apply some offset.
-            sphere2.Transform(AffineXf3f.Translation(new Vector3f { X = 0.7f }));
+            sphere2.Transform(AffineXf3f.Translation(new Vector3f { x = 0.7f }));
 
             BooleanResult boolean_result = Boolean(sphere1, sphere2, BooleanOperation.Intersection);
             if (!boolean_result)
             {
-                Console.WriteLine($"Failed to perform boolean: {(string)boolean_result.ErrorString}");
+                Console.WriteLine($"Failed to perform boolean: {(string)boolean_result.errorString}");
                 Environment.Exit(1);
             }
 
-            MeshSave.ToAnySupportedFormat(boolean_result.Mesh, "out_boolean.stl");
+            MeshSave.ToAnySupportedFormat(boolean_result.mesh, "out_boolean.stl");
 
             /// ...
 
diff --git a/source/MRDotNet2Test/src/Matrix3Tests.cs b/source/MRDotNet2Test/src/Matrix3Tests.cs
index 56059f1ba9e6..8a47bfc5bf9a 100644
--- a/source/MRDotNet2Test/src/Matrix3Tests.cs
+++ b/source/MRDotNet2Test/src/Matrix3Tests.cs
@@ -11,15 +11,15 @@ public void TestDefaultConstructor()
         {
             var a = new Matrix3f();
 
-            Assert.That(1 == a.X.X);
-            Assert.That(0 == a.X.Y);
-            Assert.That(0 == a.X.Z);
-            Assert.That(0 == a.Y.X);
-            Assert.That(1 == a.Y.Y);
-            Assert.That(0 == a.Y.Z);
-            Assert.That(0 == a.Z.X);
-            Assert.That(0 == a.Z.Y);
-            Assert.That(1 == a.Z.Z);
+            Assert.That(1 == a.x.x);
+            Assert.That(0 == a.x.y);
+            Assert.That(0 == a.x.z);
+            Assert.That(0 == a.y.x);
+            Assert.That(1 == a.y.y);
+            Assert.That(0 == a.y.z);
+            Assert.That(0 == a.z.x);
+            Assert.That(0 == a.z.y);
+            Assert.That(1 == a.z.z);
         }
 
         [Test]
@@ -27,15 +27,15 @@ public void TestConstructor()
         {
             var a = new Matrix3f( new Vector3f(1, 2, 3), new Vector3f(4, 5, 6), new Vector3f(7, 8, 9) );
 
-            Assert.That(1 == a.X.X);
-            Assert.That(2 == a.X.Y);
-            Assert.That(3 == a.X.Z);
-            Assert.That(4 == a.Y.X);
-            Assert.That(5 == a.Y.Y);
-            Assert.That(6 == a.Y.Z);
-            Assert.That(7 == a.Z.X);
-            Assert.That(8 == a.Z.Y);
-            Assert.That(9 == a.Z.Z);
+            Assert.That(1 == a.x.x);
+            Assert.That(2 == a.x.y);
+            Assert.That(3 == a.x.z);
+            Assert.That(4 == a.y.x);
+            Assert.That(5 == a.y.y);
+            Assert.That(6 == a.y.z);
+            Assert.That(7 == a.z.x);
+            Assert.That(8 == a.z.y);
+            Assert.That(9 == a.z.z);
         }
 
         [Test]
@@ -43,45 +43,45 @@ public void TestZeroMatrix()
         {
             var a = Matrix3f.Zero();
 
-            Assert.That(0 == a.X.X);
-            Assert.That(0 == a.X.Y);
-            Assert.That(0 == a.X.Z);
-            Assert.That(0 == a.Y.X);
-            Assert.That(0 == a.Y.Y);
-            Assert.That(0 == a.Y.Z);
-            Assert.That(0 == a.Z.X);
-            Assert.That(0 == a.Z.Y);
-            Assert.That(0 == a.Z.Z);
+            Assert.That(0 == a.x.x);
+            Assert.That(0 == a.x.y);
+            Assert.That(0 == a.x.z);
+            Assert.That(0 == a.y.x);
+            Assert.That(0 == a.y.y);
+            Assert.That(0 == a.y.z);
+            Assert.That(0 == a.z.x);
+            Assert.That(0 == a.z.y);
+            Assert.That(0 == a.z.z);
         }
 
         [Test]
         public void TestRotationAroundAxis()
         {
             var a = Matrix3f.Rotation( new Vector3f( 1, 1, 1 ), 1.0f ) ;
-            Assert.That( 0.69, Is.EqualTo( a.X.X ).Within( 0.01 ) );
-            Assert.That( -0.33, Is.EqualTo( a.X.Y ).Within( 0.01 ) );
-            Assert.That( 0.64, Is.EqualTo( a.X.Z ).Within( 0.01 ) );
-            Assert.That( 0.64, Is.EqualTo( a.Y.X ).Within( 0.01 ) );
-            Assert.That( 0.69, Is.EqualTo( a.Y.Y ).Within( 0.01 ) );
-            Assert.That( -0.33, Is.EqualTo( a.Y.Z ).Within( 0.01 ) );
-            Assert.That( -0.33, Is.EqualTo( a.Z.X ).Within( 0.01 ) );
-            Assert.That( 0.64, Is.EqualTo( a.Z.Y ).Within( 0.01 ) );
-            Assert.That( 0.69, Is.EqualTo( a.Z.Z ).Within( 0.01 ) );
+            Assert.That( 0.69, Is.EqualTo( a.x.x ).Within( 0.01 ) );
+            Assert.That( -0.33, Is.EqualTo( a.x.y ).Within( 0.01 ) );
+            Assert.That( 0.64, Is.EqualTo( a.x.z ).Within( 0.01 ) );
+            Assert.That( 0.64, Is.EqualTo( a.y.x ).Within( 0.01 ) );
+            Assert.That( 0.69, Is.EqualTo( a.y.y ).Within( 0.01 ) );
+            Assert.That( -0.33, Is.EqualTo( a.y.z ).Within( 0.01 ) );
+            Assert.That( -0.33, Is.EqualTo( a.z.x ).Within( 0.01 ) );
+            Assert.That( 0.64, Is.EqualTo( a.z.y ).Within( 0.01 ) );
+            Assert.That( 0.69, Is.EqualTo( a.z.z ).Within( 0.01 ) );
         }
 
         [Test]
         public void TestRotationBetweenTwoVectors()
         {
             var a = Matrix3f.Rotation( new Vector3f( 1, 0, 1), new Vector3f( 0, 1, 1 ) );
-            Assert.That(0.67, Is.EqualTo(a.X.X).Within(0.01));
-            Assert.That(-0.33, Is.EqualTo(a.X.Y).Within(0.01));
-            Assert.That(-0.67, Is.EqualTo(a.X.Z).Within(0.01));
-            Assert.That(0.67, Is.EqualTo(a.Y.X).Within(0.01));
-            Assert.That(0.67, Is.EqualTo(a.Y.Y).Within(0.01));
-            Assert.That(0.33, Is.EqualTo(a.Y.Z).Within(0.01));
-            Assert.That(0.33, Is.EqualTo(a.Z.X).Within(0.01));
-            Assert.That(-0.67, Is.EqualTo(a.Z.Y).Within(0.01));
-            Assert.That(0.67, Is.EqualTo(a.Z.Z).Within(0.01));
+            Assert.That(0.67, Is.EqualTo(a.x.x).Within(0.01));
+            Assert.That(-0.33, Is.EqualTo(a.x.y).Within(0.01));
+            Assert.That(-0.67, Is.EqualTo(a.x.z).Within(0.01));
+            Assert.That(0.67, Is.EqualTo(a.y.x).Within(0.01));
+            Assert.That(0.67, Is.EqualTo(a.y.y).Within(0.01));
+            Assert.That(0.33, Is.EqualTo(a.y.z).Within(0.01));
+            Assert.That(0.33, Is.EqualTo(a.z.x).Within(0.01));
+            Assert.That(-0.67, Is.EqualTo(a.z.y).Within(0.01));
+            Assert.That(0.67, Is.EqualTo(a.z.z).Within(0.01));
         }
 
         [Test]
@@ -92,15 +92,15 @@ public void TestMultiplication()
 
             var c = a * b;
 
-            Assert.That( 84, Is.EqualTo( c.X.X ).Within( 0.01 ) );
-            Assert.That( 90, Is.EqualTo( c.X.Y ).Within( 0.01 ) );
-            Assert.That( 96, Is.EqualTo( c.X.Z ).Within( 0.01 ) );
-            Assert.That( 201, Is.EqualTo( c.Y.X ).Within( 0.01 ) );
-            Assert.That( 216, Is.EqualTo( c.Y.Y ).Within( 0.01 ) );
-            Assert.That( 231, Is.EqualTo( c.Y.Z ).Within( 0.01 ) );
-            Assert.That( 318, Is.EqualTo( c.Z.X ).Within( 0.01 ) );
-            Assert.That( 342, Is.EqualTo( c.Z.Y ).Within( 0.01 ) );
-            Assert.That( 366, Is.EqualTo( c.Z.Z ).Within( 0.01 ) );
+            Assert.That( 84, Is.EqualTo( c.x.x ).Within( 0.01 ) );
+            Assert.That( 90, Is.EqualTo( c.x.y ).Within( 0.01 ) );
+            Assert.That( 96, Is.EqualTo( c.x.z ).Within( 0.01 ) );
+            Assert.That( 201, Is.EqualTo( c.y.x ).Within( 0.01 ) );
+            Assert.That( 216, Is.EqualTo( c.y.y ).Within( 0.01 ) );
+            Assert.That( 231, Is.EqualTo( c.y.z ).Within( 0.01 ) );
+            Assert.That( 318, Is.EqualTo( c.z.x ).Within( 0.01 ) );
+            Assert.That( 342, Is.EqualTo( c.z.y ).Within( 0.01 ) );
+            Assert.That( 366, Is.EqualTo( c.z.z ).Within( 0.01 ) );
         }
 
         [Test]
@@ -111,9 +111,9 @@ public void TestMultiplicationWithVector()
 
             var c = a * b;
 
-            Assert.That( 68, Is.EqualTo( c.X ).Within( 0.01 ) );
-            Assert.That( 167, Is.EqualTo( c.Y ).Within( 0.01 ) );
-            Assert.That( 266, Is.EqualTo( c.Z ).Within( 0.01 ) );
-        }        
+            Assert.That( 68, Is.EqualTo( c.x ).Within( 0.01 ) );
+            Assert.That( 167, Is.EqualTo( c.y ).Within( 0.01 ) );
+            Assert.That( 266, Is.EqualTo( c.z ).Within( 0.01 ) );
+        }
     }
 }
diff --git a/source/MRDotNet2Test/src/MeshCollideTests.cs b/source/MRDotNet2Test/src/MeshCollideTests.cs
index 5d43261183a1..07402aaea3c7 100644
--- a/source/MRDotNet2Test/src/MeshCollideTests.cs
+++ b/source/MRDotNet2Test/src/MeshCollideTests.cs
@@ -18,7 +18,7 @@ public void TestMeshCollidePrecise()
 
             var conv = GetVectorConverters(mpA, mpB);
 
-            var intersections = FindCollidingEdgeTrisPrecise(mpA, mpB, conv.ToInt);
+            var intersections = FindCollidingEdgeTrisPrecise(mpA, mpB, conv.toInt);
             Assert.That(intersections.Size(), Is.EqualTo(152));
             var edgeATriBCount = 0;
             var edgeBTriACount = 0;
@@ -32,7 +32,7 @@ public void TestMeshCollidePrecise()
             Assert.That(edgeATriBCount, Is.EqualTo(80));
             Assert.That(edgeBTriACount, Is.EqualTo(72));
 
-            var contours = OrderIntersectionContours(meshA.Topology, meshB.Topology, intersections);
+            var contours = OrderIntersectionContours(meshA.topology, meshB.topology, intersections);
 
             Assert.That(contours.Size(), Is.EqualTo(4));
             Assert.That(contours.At(0).Size(), Is.EqualTo(71));
@@ -49,7 +49,7 @@ public void TestMeshCollidePrecise()
             ulong posCount = 0;
             for (ulong i = 0; i < aConts.Size(); i++)
             {
-                posCount += aConts.At(i).Intersections.Size();
+                posCount += aConts.At(i).intersections.Size();
             }
 
             Assert.That(posCount, Is.EqualTo(156) );
diff --git a/source/MRDotNet2Test/src/MeshComponents.cs b/source/MRDotNet2Test/src/MeshComponents.cs
index 004a5e438ab6..0246ef89c1ac 100644
--- a/source/MRDotNet2Test/src/MeshComponents.cs
+++ b/source/MRDotNet2Test/src/MeshComponents.cs
@@ -12,7 +12,7 @@ static MeshPart CreateMesh()
             var bigCube = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f));
             var smallCube = MakeCube(Vector3f.Diagonal(0.1f), Vector3f.Diagonal(1.0f));
             var boolResult = Boolean(bigCube, smallCube, BooleanOperation.Union);
-            return new MeshPart(boolResult.Mesh);
+            return new MeshPart(boolResult.mesh);
         }
 
         [Test]
@@ -25,8 +25,8 @@ public void TestComponentsMap()
 
             Assert.That(numComponents == 2);
             Assert.That(map.Size() == 24);
-            Assert.That(map.Index(new FaceId(0)).Id == 0);
-            Assert.That(map.Index(new FaceId(12)).Id == 1);
+            Assert.That(map.Index(new FaceId(0)).id == 0);
+            Assert.That(map.Index(new FaceId(12)).id == 1);
         }
 
         [Test]
diff --git a/source/MRDotNet2Test/src/MeshShapesTest.cs b/source/MRDotNet2Test/src/MeshShapesTest.cs
index f31bdc247bfb..7af8b5bcbc83 100644
--- a/source/MRDotNet2Test/src/MeshShapesTest.cs
+++ b/source/MRDotNet2Test/src/MeshShapesTest.cs
@@ -13,28 +13,28 @@ internal class MeshShapesTest
         public void TestCubeShape()
         {
             var cube = MakeCube(new Vector3f(1.0f, 1.0f, 1.0f), new Vector3f(0, 0, 0));
-            Assert.That(cube.Points.Size() == 8);
+            Assert.That(cube.points.Size() == 8);
         }
 
         [Test]
         public void TestCylinderShape()
         {
             var cylinder = MakeCylinderAdvanced(1.0f, 1.0f, 0.0f, (float)Math.PI * 2, 2.0f, 16);
-            Assert.That(cylinder.Points.Size() == 34 );
+            Assert.That(cylinder.points.Size() == 34 );
         }
 
         [Test]
         public void TestSphereShape()
         {
             var sphere = MakeSphere(new SphereParams(1.0f, 64));
-            Assert.That(sphere.Points.Size() == 64);
+            Assert.That(sphere.points.Size() == 64);
         }
 
         [Test]
         public void TestTorusShape()
         {
             var torus = MakeTorus(1.0f, 2.0f, 16, 16);
-            Assert.That(torus.Points.Size() == 256);
+            Assert.That(torus.points.Size() == 256);
         }
     }
 }
diff --git a/source/MRDotNet2Test/src/MeshTests.cs b/source/MRDotNet2Test/src/MeshTests.cs
index d8b3c6af3562..c9726e087e2e 100644
--- a/source/MRDotNet2Test/src/MeshTests.cs
+++ b/source/MRDotNet2Test/src/MeshTests.cs
@@ -14,8 +14,8 @@ public void TestDoubleAssignment()
         {
             var mesh = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f));
             mesh = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f));
-            Assert.That(mesh.Points.Size() == 8);
-            Assert.That(mesh.Topology.GetValidFaces().Count() == 12);
+            Assert.That(mesh.points.Size() == 8);
+            Assert.That(mesh.topology.GetValidFaces().Count() == 12);
         }
 
         [Test]
@@ -26,8 +26,8 @@ public void TestSaveLoad()
             MeshSave.ToAnySupportedFormat(cubeMesh, tempFile);
 
             var readMesh = MeshLoad.FromAnySupportedFormat(tempFile);
-            Assert.That(cubeMesh.Points.Size() == readMesh.Points.Size());
-            Assert.That(cubeMesh.Topology.GetValidFaces().Count() == readMesh.Topology.GetValidFaces().Count());
+            Assert.That(cubeMesh.points.Size() == readMesh.points.Size());
+            Assert.That(cubeMesh.topology.GetValidFaces().Count() == readMesh.topology.GetValidFaces().Count());
 
             File.Delete(tempFile);
         }
@@ -65,8 +65,8 @@ public void TestSaveLoadCtm()
             MeshSave.ToAnySupportedFormat(cubeMesh, tempFile);
 
             var readMesh = MeshLoad.FromAnySupportedFormat(tempFile);
-            Assert.That(readMesh.Points.Size() == 8);
-            Assert.That(readMesh.Topology.GetValidFaces().Count() == 12);
+            Assert.That(readMesh.points.Size() == 8);
+            Assert.That(readMesh.topology.GetValidFaces().Count() == 12);
 
             File.Delete(tempFile);
         }
@@ -100,7 +100,7 @@ public void TestFromTriangles()
             triangles.Add(new ThreeVertIds(3, 2, 6));
 
             var mesh = Mesh.FromTriangles(points, triangles);
-            Assert.That(mesh.Points.Count == 8);
+            Assert.That(mesh.points.Count == 8);
             Assert.That(mesh.Triangulation.Count == 12);
         }
 
@@ -132,7 +132,7 @@ public void TestFromTrianglesDuplicating()
             triangles.Add(new ThreeVertIds(3, 2, 6));
 
             var mesh = Mesh.FromTrianglesDuplicatingNonManifoldVertices(points, triangles);
-            Assert.That(mesh.Points.Count == 8);
+            Assert.That(mesh.points.Count == 8);
             Assert.That(mesh.Triangulation.Count == 12);
         }
         */
@@ -154,14 +154,14 @@ public void TestTransform()
             var xf = AffineXf3f.Translation(Vector3f.Diagonal(1.0f));
             cubeMesh.Transform(xf);
 
-            Assert.That(cubeMesh.Points.Vec.At(0) == new Vector3f(0.5f, 0.5f, 0.5f));
-            Assert.That(cubeMesh.Points.Vec.At(1) == new Vector3f(0.5f, 1.5f, 0.5f));
-            Assert.That(cubeMesh.Points.Vec.At(2) == new Vector3f(1.5f, 1.5f, 0.5f));
-            Assert.That(cubeMesh.Points.Vec.At(3) == new Vector3f(1.5f, 0.5f, 0.5f));
-            Assert.That(cubeMesh.Points.Vec.At(4) == new Vector3f(0.5f, 0.5f, 1.5f));
-            Assert.That(cubeMesh.Points.Vec.At(5) == new Vector3f(0.5f, 1.5f, 1.5f));
-            Assert.That(cubeMesh.Points.Vec.At(6) == new Vector3f(1.5f, 1.5f, 1.5f));
-            Assert.That(cubeMesh.Points.Vec.At(7) == new Vector3f(1.5f, 0.5f, 1.5f));
+            Assert.That(cubeMesh.points.vec.At(0) == new Vector3f(0.5f, 0.5f, 0.5f));
+            Assert.That(cubeMesh.points.vec.At(1) == new Vector3f(0.5f, 1.5f, 0.5f));
+            Assert.That(cubeMesh.points.vec.At(2) == new Vector3f(1.5f, 1.5f, 0.5f));
+            Assert.That(cubeMesh.points.vec.At(3) == new Vector3f(1.5f, 0.5f, 0.5f));
+            Assert.That(cubeMesh.points.vec.At(4) == new Vector3f(0.5f, 0.5f, 1.5f));
+            Assert.That(cubeMesh.points.vec.At(5) == new Vector3f(0.5f, 1.5f, 1.5f));
+            Assert.That(cubeMesh.points.vec.At(6) == new Vector3f(1.5f, 1.5f, 1.5f));
+            Assert.That(cubeMesh.points.vec.At(7) == new Vector3f(1.5f, 0.5f, 1.5f));
         }
 
         [Test]
@@ -177,29 +177,29 @@ public void TestTransformWithRegion()
             var xf = AffineXf3f.Translation(Vector3f.Diagonal(1.0f));
             cubeMesh.Transform(xf, region);
 
-            Assert.That(cubeMesh.Points.Vec.At(0) == new Vector3f(0.5f, 0.5f, 0.5f));
-            Assert.That(cubeMesh.Points.Vec.At(1) == new Vector3f(-0.5f, 0.5f, -0.5f));
-            Assert.That(cubeMesh.Points.Vec.At(2) == new Vector3f(1.5f, 1.5f, 0.5f));
-            Assert.That(cubeMesh.Points.Vec.At(3) == new Vector3f(0.5f, -0.5f, -0.5f));
-            Assert.That(cubeMesh.Points.Vec.At(4) == new Vector3f(0.5f, 0.5f, 1.5f));
-            Assert.That(cubeMesh.Points.Vec.At(5) == new Vector3f(-0.5f, 0.5f, 0.5f));
-            Assert.That(cubeMesh.Points.Vec.At(6) == new Vector3f(1.5f, 1.5f, 1.5f));
-            Assert.That(cubeMesh.Points.Vec.At(7) == new Vector3f(0.5f, -0.5f, 0.5f));
+            Assert.That(cubeMesh.points.vec.At(0) == new Vector3f(0.5f, 0.5f, 0.5f));
+            Assert.That(cubeMesh.points.vec.At(1) == new Vector3f(-0.5f, 0.5f, -0.5f));
+            Assert.That(cubeMesh.points.vec.At(2) == new Vector3f(1.5f, 1.5f, 0.5f));
+            Assert.That(cubeMesh.points.vec.At(3) == new Vector3f(0.5f, -0.5f, -0.5f));
+            Assert.That(cubeMesh.points.vec.At(4) == new Vector3f(0.5f, 0.5f, 1.5f));
+            Assert.That(cubeMesh.points.vec.At(5) == new Vector3f(-0.5f, 0.5f, 0.5f));
+            Assert.That(cubeMesh.points.vec.At(6) == new Vector3f(1.5f, 1.5f, 1.5f));
+            Assert.That(cubeMesh.points.vec.At(7) == new Vector3f(0.5f, -0.5f, 0.5f));
         }
 
         [Test]
         public void TestLeftTriVerts()
         {
             var cubeMesh = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f));
-            var triVerts = cubeMesh.Topology.GetLeftTriVerts(new EdgeId(0));
-            Assert.That(triVerts.Elems[0].Id, Is.EqualTo(0));
-            Assert.That(triVerts.Elems[1].Id, Is.EqualTo(1));
-            Assert.That(triVerts.Elems[2].Id, Is.EqualTo(2));
-
-            triVerts = cubeMesh.Topology.GetLeftTriVerts(new EdgeId(6));
-            Assert.That(triVerts.Elems[0].Id, Is.EqualTo(2));
-            Assert.That(triVerts.Elems[1].Id, Is.EqualTo(3));
-            Assert.That(triVerts.Elems[2].Id, Is.EqualTo(0));
+            var triVerts = cubeMesh.topology.GetLeftTriVerts(new EdgeId(0));
+            Assert.That(triVerts.elems[0].id, Is.EqualTo(0));
+            Assert.That(triVerts.elems[1].id, Is.EqualTo(1));
+            Assert.That(triVerts.elems[2].id, Is.EqualTo(2));
+
+            triVerts = cubeMesh.topology.GetLeftTriVerts(new EdgeId(6));
+            Assert.That(triVerts.elems[0].id, Is.EqualTo(2));
+            Assert.That(triVerts.elems[1].id, Is.EqualTo(3));
+            Assert.That(triVerts.elems[2].id, Is.EqualTo(0));
         }
 
         /*
@@ -234,7 +234,7 @@ public void TestSaveLoadToObj()
                 if ( loadedMesh is null || loadedXf is null)
                     return;
 
-                Assert.That(loadedMesh.Points.Count == 8);
+                Assert.That(loadedMesh.points.Count == 8);
                 Assert.That(loadedObjs[0].name == "Cube");
                 Assert.That(loadedXf.B.X == 0.0f);
 
@@ -245,7 +245,7 @@ public void TestSaveLoadToObj()
                 if (loadedMesh is null || loadedXf is null)
                     return;
 
-                Assert.That(loadedMesh.Points.Count == 100);
+                Assert.That(loadedMesh.points.Count == 100);
                 Assert.That(loadedObjs[1].name == "LongSphereName");
                 Assert.That(loadedXf.B.X == 0.0f);
 
@@ -260,7 +260,7 @@ public void TestSaveLoadToObj()
                 if (loadedMesh is null || loadedXf is null)
                     return;
 
-                Assert.That(loadedMesh.Points.Count == 8);
+                Assert.That(loadedMesh.points.Count == 8);
                 Assert.That(loadedObjs[0].name == "Cube");
                 Assert.That(loadedXf.B.X == 1.0f);
 
@@ -271,12 +271,12 @@ public void TestSaveLoadToObj()
                 if (loadedMesh is null || loadedXf is null)
                     return;
 
-                Assert.That(loadedMesh.Points.Count == 100);
+                Assert.That(loadedMesh.points.Count == 100);
                 Assert.That(loadedObjs[1].name == "LongSphereName");
                 Assert.That(loadedXf.B.X == -2.0f);
 
                 loadedMesh = loadedObjs[0].mesh;
-                if (loadedMesh is not null) 
+                if (loadedMesh is not null)
                     loadedMesh.Dispose();
 
                 loadedMesh = loadedObjs[1].mesh;
@@ -292,11 +292,11 @@ public void TestSaveLoadToObj()
         public void TestToTriPoint()
         {
             var cubeMesh = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f));
-            var triVerts = cubeMesh.Topology.GetTriVerts(new FaceId(0));
-            var centerPoint = (cubeMesh.Points.Index(triVerts.Elems[1]) + cubeMesh.Points.Index(triVerts.Elems[2])) * 0.5f;
+            var triVerts = cubeMesh.topology.GetTriVerts(new FaceId(0));
+            var centerPoint = (cubeMesh.points.Index(triVerts.elems[1]) + cubeMesh.points.Index(triVerts.elems[2])) * 0.5f;
             var triPoint = cubeMesh.ToTriPoint(new FaceId(0), centerPoint);
-            Assert.That(triPoint.Bary.A, Is.EqualTo(0.5f));
-            Assert.That(triPoint.Bary.B, Is.EqualTo(0.5f));
+            Assert.That(triPoint.bary.a, Is.EqualTo(0.5f));
+            Assert.That(triPoint.bary.b, Is.EqualTo(0.5f));
         }
 
         [Test]
@@ -320,15 +320,15 @@ public void TestCalculatingVolume()
         public void TestAddMesh()
         {
             var cubeMesh = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f));
-            Assert.That(cubeMesh.Topology.GetValidFaces().Count() == 12);
+            Assert.That(cubeMesh.topology.GetValidFaces().Count() == 12);
             var cpyMesh = new Mesh(cubeMesh);
             cubeMesh.AddMesh(cpyMesh);
-            Assert.That(cubeMesh.Topology.GetValidFaces().Count() == 24);
+            Assert.That(cubeMesh.topology.GetValidFaces().Count() == 24);
             FaceBitSet bs = new FaceBitSet(12);
             bs.Set(new FaceId(0));
             MeshPart mp = new MeshPart(cpyMesh, bs);
             cubeMesh.AddMeshPart(mp);
-            Assert.That(cubeMesh.Topology.GetValidFaces().Count() == 25);
+            Assert.That(cubeMesh.topology.GetValidFaces().Count() == 25);
         }
 
         [Test]
@@ -337,28 +337,28 @@ public void TestProjection()
             var p = new Vector3f(1, 2, 3);
             var mp = new MeshPart(MakeSphere(new SphereParams(1.0f, 1000)));
             var projRes = FindProjection(p, mp);
-            Assert.That(projRes.DistSq, Is.EqualTo(7.529f).Within(1e-3));
+            Assert.That(projRes.distSq, Is.EqualTo(7.529f).Within(1e-3));
 
-            Assert.That(projRes.Proj.Face.Id, Is.EqualTo(904));
-            Assert.That(projRes.Proj.Point.X, Is.EqualTo(0.310).Within(1e-3));
-            Assert.That(projRes.Proj.Point.Y, Is.EqualTo(0.507).Within(1e-3));
-            Assert.That(projRes.Proj.Point.Z, Is.EqualTo(0.803).Within(1e-3));
+            Assert.That(projRes.proj.face.id, Is.EqualTo(904));
+            Assert.That(projRes.proj.point.x, Is.EqualTo(0.310).Within(1e-3));
+            Assert.That(projRes.proj.point.y, Is.EqualTo(0.507).Within(1e-3));
+            Assert.That(projRes.proj.point.z, Is.EqualTo(0.803).Within(1e-3));
 
-            Assert.That(projRes.Mtp.E.Id, Is.EqualTo(1640));
-            Assert.That(projRes.Mtp.Bary.A, Is.EqualTo(0.053).Within(1e-3));
-            Assert.That(projRes.Mtp.Bary.B, Is.EqualTo(0.946).Within(1e-3));
+            Assert.That(projRes.mtp.e.id, Is.EqualTo(1640));
+            Assert.That(projRes.mtp.bary.a, Is.EqualTo(0.053).Within(1e-3));
+            Assert.That(projRes.mtp.bary.b, Is.EqualTo(0.946).Within(1e-3));
 
             var xf = AffineXf3f.Translation(Vector3f.Diagonal(1.0f));
             projRes = FindProjection(p, mp, float.MaxValue, xf);
 
-            Assert.That(projRes.Proj.Face.Id, Is.EqualTo(632));
-            Assert.That(projRes.Proj.Point.X, Is.EqualTo(1.000).Within(1e-3));
-            Assert.That(projRes.Proj.Point.Y, Is.EqualTo(1.439).Within(1e-3));
-            Assert.That(projRes.Proj.Point.Z, Is.EqualTo(1.895).Within(1e-3));
+            Assert.That(projRes.proj.face.id, Is.EqualTo(632));
+            Assert.That(projRes.proj.point.x, Is.EqualTo(1.000).Within(1e-3));
+            Assert.That(projRes.proj.point.y, Is.EqualTo(1.439).Within(1e-3));
+            Assert.That(projRes.proj.point.z, Is.EqualTo(1.895).Within(1e-3));
 
-            Assert.That(projRes.Mtp.E.Id, Is.EqualTo(1898));
-            Assert.That(projRes.Mtp.Bary.A, Is.EqualTo(0.5).Within(1e-3));
-            Assert.That(projRes.Mtp.Bary.B, Is.EqualTo(0.0).Within(1e-3));
+            Assert.That(projRes.mtp.e.id, Is.EqualTo(1898));
+            Assert.That(projRes.mtp.bary.a, Is.EqualTo(0.5).Within(1e-3));
+            Assert.That(projRes.mtp.bary.b, Is.EqualTo(0.0).Within(1e-3));
         }
 
         [Test]
@@ -368,17 +368,17 @@ public void TestMeshMeshDistance()
 
             var wholeSphere1 = new MeshPart(sphere1);
             var d11 = FindDistance(wholeSphere1, wholeSphere1);
-            Assert.That(d11.DistSq, Is.EqualTo(0));
+            Assert.That(d11.distSq, Is.EqualTo(0));
 
             var zShift = AffineXf3f.Translation(new Vector3f(0.0f, 0.0f, 3.0f));
             var d1z = FindDistance(wholeSphere1, wholeSphere1, zShift);
-            Assert.That(d1z.DistSq, Is.EqualTo(1));
+            Assert.That(d1z.distSq, Is.EqualTo(1));
 
             Mesh sphere2 = MakeUVSphere(2, 8, 8);
 
             var wholeSphere2 = new MeshPart(sphere2);
             var d12 = FindDistance(wholeSphere1, wholeSphere2);
-            var dist12 = Math.Sqrt(d12.DistSq);
+            var dist12 = Math.Sqrt(d12.distSq);
             Assert.That(dist12, Is.InRange(0.9, 1.0));
         }
 
@@ -388,7 +388,7 @@ public void TestValidPoints()
             Assert.DoesNotThrow(() =>
             {
                 var mesh = MakeSphere(new SphereParams(1.0f, 3000));
-                var count = mesh.Topology.GetValidVerts().Count();
+                var count = mesh.topology.GetValidVerts().Count();
                 Assert.That(count, Is.EqualTo(3000));
                 mesh.Dispose();
             });
@@ -400,8 +400,8 @@ public void TestClone()
             var mesh = MakeSphere(new SphereParams(1.0f, 3000));
             var clone = new Mesh(mesh);
             Assert.That(clone, Is.Not.SameAs(mesh));
-            Assert.That(clone.Points.Size(), Is.EqualTo(mesh.Points.Size()));
-            Assert.That(clone.Topology.GetValidFaces().Count(), Is.EqualTo(mesh.Topology.GetValidFaces().Count()));
+            Assert.That(clone.points.Size(), Is.EqualTo(mesh.points.Size()));
+            Assert.That(clone.topology.GetValidFaces().Count(), Is.EqualTo(mesh.topology.GetValidFaces().Count()));
             mesh.Dispose();
             clone.Dispose();
         }
@@ -410,12 +410,12 @@ public void TestClone()
         public void TestUniteCloseVertices()
         {
             var mesh = MakeSphere(new SphereParams(1.0f, 3000));
-            Assert.That(mesh.Topology.GetValidVerts().Count() == 3000);
+            Assert.That(mesh.topology.GetValidVerts().Count() == 3000);
             var old2new = new VertMap();
             var unitedCount = MeshBuilder.UniteCloseVertices(mesh, 0.1f, false, old2new);
             Assert.That(unitedCount, Is.EqualTo(2230));
-            Assert.That(old2new.Index(new VertId(1000)).Id, Is.EqualTo(42));
-            Assert.That(mesh.Topology.GetValidVerts().Count() < 3000);
+            Assert.That(old2new.Index(new VertId(1000)).id, Is.EqualTo(42));
+            Assert.That(mesh.topology.GetValidVerts().Count() < 3000);
             mesh.Dispose();
         }
 
@@ -434,15 +434,15 @@ public void TestArea()
             cubeMesh.DeleteFaces(faces);
             Assert.That(cubeMesh.Area(), Is.EqualTo(3.0).Within(0.001));
 
-            var holes = FindRightBoundary(cubeMesh.Topology);
+            var holes = FindRightBoundary(cubeMesh.topology);
             Assert.That(holes.Size(), Is.EqualTo(1));
             Assert.That(holes.At(0).Size(), Is.EqualTo(6));
 
-            var hole0 = TrackRightBoundaryLoop(cubeMesh.Topology, holes.At(0).At(0));
+            var hole0 = TrackRightBoundaryLoop(cubeMesh.topology, holes.At(0).At(0));
             Assert.That(hole0.Size(), Is.EqualTo(holes.At(0).Size()));
             for (ulong i = 0; i < hole0.Size(); i++)
             {
-                Assert.That(hole0.At(i).Id, Is.EqualTo(holes.At(0).At(i).Id));
+                Assert.That(hole0.At(i).id, Is.EqualTo(holes.At(0).At(i).id));
             }
         }
 
@@ -452,7 +452,7 @@ public void TestIncidentFacesFromVerts()
             var cubeMesh = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f));
             var verts = new VertBitSet(8, false);
             verts.Set(new VertId(0), true);
-            var faces = GetIncidentFaces(cubeMesh.Topology, verts);
+            var faces = GetIncidentFaces(cubeMesh.topology, verts);
             Assert.That(faces.Count(), Is.EqualTo(6));
         }
 
@@ -462,7 +462,7 @@ public void TestIncidentFacesFromEdges()
             var cubeMesh = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f));
             var edges = new UndirectedEdgeBitSet(12, false);
             edges.Set(new EdgeId(0), true);
-            var faces = GetIncidentFaces(cubeMesh.Topology, edges);
+            var faces = GetIncidentFaces(cubeMesh.topology, edges);
             Assert.That(faces.Count(), Is.EqualTo(8));
         }
 
@@ -473,6 +473,5 @@ public void TestShortEdges()
             var shortEdges = FindShortEdges(new MeshPart( mesh ), 0.1f);
             Assert.That(shortEdges.Count(), Is.EqualTo(256));
         }
-    }    
+    }
 }
-
diff --git a/source/MRDotNet2Test/src/OffsetTests.cs b/source/MRDotNet2Test/src/OffsetTests.cs
index f2ea08ec6885..c0d68c2a2697 100644
--- a/source/MRDotNet2Test/src/OffsetTests.cs
+++ b/source/MRDotNet2Test/src/OffsetTests.cs
@@ -14,28 +14,28 @@ public void TestOffsets()
             var mp = new MeshPart(MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f)));
 
             var parameters = new OffsetParameters();
-            parameters.VoxelSize = SuggestVoxelSize(mp, 8000);
+            parameters.voxelSize = SuggestVoxelSize(mp, 8000);
 
             var offset = OffsetMesh(mp, 0.5f, parameters);
-            Assert.That( offset.Points.Size() == 8792 );
+            Assert.That( offset.points.Size() == 8792 );
 
             offset = McOffsetMesh(mp, 0.5f, parameters);
-            Assert.That( offset.Points.Size() == 8790 );
+            Assert.That( offset.points.Size() == 8790 );
 
             offset = DoubleOffsetMesh(mp, 0.5f, -0.5f, parameters);
-            Assert.That( offset.Points.Size() == 2408 );
+            Assert.That( offset.points.Size() == 2408 );
 
             var sharpParameters = new SharpOffsetParameters();
-            sharpParameters.VoxelSize = SuggestVoxelSize(mp, 8000);
+            sharpParameters.voxelSize = SuggestVoxelSize(mp, 8000);
 
             offset = SharpOffsetMesh(mp, 0.5f, sharpParameters);
-            Assert.That( offset.Points.Size() == 8790 );
+            Assert.That( offset.points.Size() == 8790 );
 
             var generalParameters = new GeneralOffsetParameters();
-            generalParameters.VoxelSize = SuggestVoxelSize(mp, 8000);
+            generalParameters.voxelSize = SuggestVoxelSize(mp, 8000);
 
             offset = GeneralOffsetMesh(mp, 0.5f, generalParameters);
-            Assert.That( offset.Points.Size() == 8790 );
+            Assert.That( offset.points.Size() == 8790 );
         }
 
         [Test]
@@ -44,11 +44,11 @@ public void TestThickenMesh()
             var mp = new MeshPart(MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f)));
 
             var parameters = new GeneralOffsetParameters();
-            parameters.VoxelSize = SuggestVoxelSize(mp, 8000);
+            parameters.voxelSize = SuggestVoxelSize(mp, 8000);
 
-            var offset = ThickenMesh(mp.Mesh, 0.5f, parameters);
+            var offset = ThickenMesh(mp.mesh, 0.5f, parameters);
 
-            Assert.That( offset.Points.Size() == 8798 );
+            Assert.That( offset.points.Size() == 8798 );
         }
     }
 }
diff --git a/source/MRDotNet2Test/src/PointCloudTests.cs b/source/MRDotNet2Test/src/PointCloudTests.cs
index e122ecb31bff..13b3cbc2da8b 100644
--- a/source/MRDotNet2Test/src/PointCloudTests.cs
+++ b/source/MRDotNet2Test/src/PointCloudTests.cs
@@ -28,12 +28,12 @@ public void TestPointCloud()
         {
             var points = MakeCube();
 
-            Assert.That(points.Points.Size() == 8);
-            Assert.That(points.Normals.Size() == 0);
+            Assert.That(points.points.Size() == 8);
+            Assert.That(points.normals.Size() == 0);
 
             var bbox = points.GetBoundingBox();
-            Assert.That(bbox.Min == new Vector3f(0, 0, 0));
-            Assert.That(bbox.Max == new Vector3f(1, 1, 1));
+            Assert.That(bbox.min == new Vector3f(0, 0, 0));
+            Assert.That(bbox.max == new Vector3f(1, 1, 1));
         }
 
         [Test]
@@ -42,7 +42,7 @@ public void TestDisposing()
             Assert.DoesNotThrow(() =>
             {
                 var points = MakeCube();
-                Assert.That(points.ValidPoints.Count() == 8);
+                Assert.That(points.validPoints.Count() == 8);
                 points.Dispose();
             });
         }
@@ -54,8 +54,8 @@ public void TestPointCloudNormals()
             points.AddPoint(new Vector3f(0, 0, 0), new Vector3f(0, 0, 1));
             points.AddPoint(new Vector3f(0, 1, 0), new Vector3f(0, 0, 1));
 
-            Assert.That(points.Points.Size() == 2);
-            Assert.That(points.Points.Size() == 2);
+            Assert.That(points.points.Size() == 2);
+            Assert.That(points.points.Size() == 2);
         }
 
         [Test]
@@ -66,7 +66,7 @@ public void TestSaveLoad()
             PointsSave.ToAnySupportedFormat(points, tempFile);
 
             var readPoints = PointsLoad.FromAnySupportedFormat(tempFile);
-            Assert.That(points.Points.Size() == readPoints.Points.Size());
+            Assert.That(points.points.Size() == readPoints.points.Size());
         }
 
         [Test]
@@ -88,9 +88,9 @@ public void TestTriangulation()
             Assert.That(restored is not null);
             if (restored is not null)
             {
-                Assert.That(restored.Points.Size(), Is.EqualTo(1024));
-                Assert.That(restored.Topology.GetValidVerts().Count(), Is.EqualTo(1024));
-                Assert.That(restored.Topology.FindHoleRepresentiveEdges().Size() == 0);
+                Assert.That(restored.points.Size(), Is.EqualTo(1024));
+                Assert.That(restored.topology.GetValidVerts().Count(), Is.EqualTo(1024));
+                Assert.That(restored.topology.FindHoleRepresentiveEdges().Size() == 0);
             }
         }
 
@@ -109,17 +109,17 @@ public void TestSaveLoadWithColors()
             colors.PushBack(new Color(0.0f, 0.0f, 0.0f));
 
             var saveSettings = new SaveSettings();
-            saveSettings.Colors = colors;
-            
+            saveSettings.colors = colors;
+
             string path = Path.GetTempFileName() + ".ply";
             PointsSave.ToAnySupportedFormat(points, path, saveSettings);
 
             var loadSettings = new PointsLoadSettings();
-            loadSettings.Colors = new VertColors();
+            loadSettings.colors = new VertColors();
             var readPoints = PointsLoad.FromAnySupportedFormat(path, loadSettings);
-            Assert.That(points.Points.Size() == 8);
+            Assert.That(points.points.Size() == 8);
 
-            var readColors = loadSettings.Colors;
+            var readColors = loadSettings.colors;
             Assert.That(colors.Size() == readColors.Size());
             for (ulong i = 0; i < colors.Size(); i++)
             {
@@ -133,9 +133,9 @@ public void TestSaveLoadWithColors()
         public void TestCachedPoints()
         {
             var points = MakeCube();
-            Assert.That(points.Points.Size() == 8);
+            Assert.That(points.points.Size() == 8);
             points.AddPoint(new Vector3f(0, 0, 0));
-            Assert.That(points.Points.Size() == 9);
+            Assert.That(points.points.Size() == 9);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/source/MRDotNet2Test/src/RelaxTest.cs b/source/MRDotNet2Test/src/RelaxTest.cs
index b0321185995c..f61597d27c1b 100644
--- a/source/MRDotNet2Test/src/RelaxTest.cs
+++ b/source/MRDotNet2Test/src/RelaxTest.cs
@@ -14,7 +14,7 @@ public void TestRelax()
             var sphere = MakeSphere(new SphereParams(1.0f, 200));
 
             var parameters = new MeshRelaxParams();
-            parameters.Iterations = 20;
+            parameters.iterations = 20;
 
             var oldVolume = sphere.Volume();
 
@@ -28,7 +28,7 @@ public void TestRelaxKeppVolume()
             var sphere = MakeSphere(new SphereParams(1.0f, 200));
 
             var parameters = new MeshRelaxParams();
-            parameters.Iterations = 20;
+            parameters.iterations = 20;
 
             var oldVolume = sphere.Volume();
 
diff --git a/source/MRDotNet2Test/src/SelfIntersectionsTests.cs b/source/MRDotNet2Test/src/SelfIntersectionsTests.cs
index 7a714cce39c1..70bde15ef8e3 100644
--- a/source/MRDotNet2Test/src/SelfIntersectionsTests.cs
+++ b/source/MRDotNet2Test/src/SelfIntersectionsTests.cs
@@ -7,19 +7,19 @@ namespace MRTest
     internal class SelfIntersectionsTests
     {
         [Test]
-        public void TestSelfIntersections() 
+        public void TestSelfIntersections()
         {
             var mesh = MakeTorusWithSelfIntersections(1.0f, 0.2f, 32, 16);
-            Assert.That( mesh.Topology.GetValidFaces().Count(), Is.EqualTo(1024) );
+            Assert.That( mesh.topology.GetValidFaces().Count(), Is.EqualTo(1024) );
 
             var intersections = SelfIntersections.GetFaces(mesh);
             Assert.That( intersections.Count, Is.EqualTo(128) );
 
             var settings = new SelfIntersections.Settings();
-            settings.Method_ = SelfIntersections.Settings.Method.CutAndFill;
+            settings.method = SelfIntersections.Settings.Method.CutAndFill;
 
             Assert.DoesNotThrow(() => SelfIntersections.Fix(mesh, settings) );
-            Assert.That(mesh.Topology.GetValidFaces().Count(), Is.EqualTo(1194));
+            Assert.That(mesh.topology.GetValidFaces().Count(), Is.EqualTo(1194));
 
             intersections = SelfIntersections.GetFaces(mesh);
             Assert.That(intersections.Count, Is.EqualTo(0));
diff --git a/source/MRDotNet2Test/src/VdbConversions.cs b/source/MRDotNet2Test/src/VdbConversions.cs
index 341f6a10c81a..78693e15bd08 100644
--- a/source/MRDotNet2Test/src/VdbConversions.cs
+++ b/source/MRDotNet2Test/src/VdbConversions.cs
@@ -11,13 +11,7 @@ internal static VdbVolume CreateVolume()
         {
             var mesh = MakeSphere(new SphereParams(1.0f, 3000));
             var settings = new MeshToVolumeParams();
-            /*
-             * TODO: fix struct field assignment
-            settings.VoxelSize = Vector3f.Diagonal(0.1f);
-             */
-            settings.VoxelSize.X = 0.1f;
-            settings.VoxelSize.Y = 0.1f;
-            settings.VoxelSize.Z = 0.1f;
+            settings.voxelSize = Vector3f.Diagonal(0.1f);
             return MeshToVolume(new MeshPart(mesh), settings);
         }
 
@@ -25,33 +19,33 @@ internal static VdbVolume CreateVolume()
         public void TestConversions()
         {
             var vdbVolume = CreateVolume();
-            Assert.That(vdbVolume.Min, Is.EqualTo(0).Within(0.001));
-            Assert.That(vdbVolume.Max, Is.EqualTo(3).Within(0.001));
-            Assert.That(vdbVolume.Dims.X, Is.EqualTo(26));
-            Assert.That(vdbVolume.Dims.Y, Is.EqualTo(26));
-            Assert.That(vdbVolume.Dims.Z, Is.EqualTo(26));
+            Assert.That(vdbVolume.min, Is.EqualTo(0).Within(0.001));
+            Assert.That(vdbVolume.max, Is.EqualTo(3).Within(0.001));
+            Assert.That(vdbVolume.dims.x, Is.EqualTo(26));
+            Assert.That(vdbVolume.dims.y, Is.EqualTo(26));
+            Assert.That(vdbVolume.dims.z, Is.EqualTo(26));
 
             var gridToMeshSettings = new GridToMeshSettings();
             /*
              * TODO: fix struct field assignment
-            gridToMeshSettings.VoxelSize = Vector3f.Diagonal(0.1f);
+            gridToMeshSettings.voxelSize = Vector3f.Diagonal(0.1f);
              */
-            gridToMeshSettings.VoxelSize.X = 0.1f;
-            gridToMeshSettings.VoxelSize.Y = 0.1f;
-            gridToMeshSettings.VoxelSize.Z = 0.1f;
-            gridToMeshSettings.IsoValue = 1;
+            gridToMeshSettings.voxelSize.x = 0.1f;
+            gridToMeshSettings.voxelSize.y = 0.1f;
+            gridToMeshSettings.voxelSize.z = 0.1f;
+            gridToMeshSettings.isoValue = 1;
 
-            var restored = GridToMesh(vdbVolume.Data, gridToMeshSettings);
+            var restored = GridToMesh(vdbVolume.data, gridToMeshSettings);
             var bbox = restored.GetBoundingBox();
 
-            Assert.That(restored.Points.Size(), Is.EqualTo(3748));
-            Assert.That(bbox.Min.X, Is.EqualTo(0.2).Within(0.001));
-            Assert.That(bbox.Min.Y, Is.EqualTo(0.2).Within(0.001));
-            Assert.That(bbox.Min.Z, Is.EqualTo(0.2).Within(0.001));
+            Assert.That(restored.points.Size(), Is.EqualTo(3748));
+            Assert.That(bbox.min.x, Is.EqualTo(0.2).Within(0.001));
+            Assert.That(bbox.min.y, Is.EqualTo(0.2).Within(0.001));
+            Assert.That(bbox.min.z, Is.EqualTo(0.2).Within(0.001));
 
-            Assert.That(bbox.Max.X, Is.EqualTo(2.395).Within(0.001));
-            Assert.That(bbox.Max.Y, Is.EqualTo(2.395).Within(0.001));
-            Assert.That(bbox.Max.Z, Is.EqualTo(2.395).Within(0.001));
+            Assert.That(bbox.max.x, Is.EqualTo(2.395).Within(0.001));
+            Assert.That(bbox.max.y, Is.EqualTo(2.395).Within(0.001));
+            Assert.That(bbox.max.z, Is.EqualTo(2.395).Within(0.001));
         }
 
         [Test]
@@ -70,11 +64,11 @@ public void TestSaveLoad()
             Assert.That(restored.Size(), Is.EqualTo(1));
 
             var readVolume = restored.At(0);
-            Assert.That(readVolume.Dims.X, Is.EqualTo(26));
-            Assert.That(readVolume.Dims.Y, Is.EqualTo(26));
-            Assert.That(readVolume.Dims.Z, Is.EqualTo(26));
-            Assert.That(readVolume.Min, Is.EqualTo(0).Within(0.001));
-            Assert.That(readVolume.Max, Is.EqualTo(3).Within(0.001));
+            Assert.That(readVolume.dims.x, Is.EqualTo(26));
+            Assert.That(readVolume.dims.y, Is.EqualTo(26));
+            Assert.That(readVolume.dims.z, Is.EqualTo(26));
+            Assert.That(readVolume.min, Is.EqualTo(0).Within(0.001));
+            Assert.That(readVolume.max, Is.EqualTo(3).Within(0.001));
 
             File.Delete(tempFile);
         }
@@ -83,43 +77,43 @@ public void TestSaveLoad()
         public void TestUniformResampling()
         {
             var vdbVolume = CreateVolume();
-            var resampledGrid = Resampled(vdbVolume.Data, 2);
+            var resampledGrid = Resampled(vdbVolume.data, 2);
             var resampledVolume = FloatGridToVdbVolume(resampledGrid);
             /*
              * TODO: fix struct field assignment
-            resampledVolume.VoxelSize = vdbVolume.VoxelSize * 2;
+            resampledVolume.voxelSize = vdbVolume.voxelSize * 2;
              */
-            resampledVolume.VoxelSize.X = vdbVolume.VoxelSize.X * 2;
-            resampledVolume.VoxelSize.Y = vdbVolume.VoxelSize.Y * 2;
-            resampledVolume.VoxelSize.Z = vdbVolume.VoxelSize.Z * 2;
+            resampledVolume.voxelSize.x = vdbVolume.voxelSize.x * 2;
+            resampledVolume.voxelSize.y = vdbVolume.voxelSize.y * 2;
+            resampledVolume.voxelSize.z = vdbVolume.voxelSize.z * 2;
 
-            Assert.That(resampledVolume.Dims.X, Is.EqualTo(13));
-            Assert.That(resampledVolume.Dims.Y, Is.EqualTo(13));
-            Assert.That(resampledVolume.Dims.Z, Is.EqualTo(13));
+            Assert.That(resampledVolume.dims.x, Is.EqualTo(13));
+            Assert.That(resampledVolume.dims.y, Is.EqualTo(13));
+            Assert.That(resampledVolume.dims.z, Is.EqualTo(13));
 
-            Assert.That(resampledVolume.VoxelSize.X, Is.EqualTo(0.2f).Within(0.001f));
-            Assert.That(resampledVolume.VoxelSize.Y, Is.EqualTo(0.2f).Within(0.001f));
-            Assert.That(resampledVolume.VoxelSize.Z, Is.EqualTo(0.2f).Within(0.001f));
+            Assert.That(resampledVolume.voxelSize.x, Is.EqualTo(0.2f).Within(0.001f));
+            Assert.That(resampledVolume.voxelSize.y, Is.EqualTo(0.2f).Within(0.001f));
+            Assert.That(resampledVolume.voxelSize.z, Is.EqualTo(0.2f).Within(0.001f));
         }
 
         [Test]
         public void TestResampling()
         {
             var vdbVolume = CreateVolume();
-            var resampledGrid = Resampled(vdbVolume.Data, new Vector3f( 2.0f, 1.0f, 0.5f ) );
+            var resampledGrid = Resampled(vdbVolume.data, new Vector3f( 2.0f, 1.0f, 0.5f ) );
             var resampledVolume = FloatGridToVdbVolume(resampledGrid);
 
-            resampledVolume.VoxelSize.X = vdbVolume.VoxelSize.X * 2;
-            resampledVolume.VoxelSize.Y = vdbVolume.VoxelSize.Y * 1;
-            resampledVolume.VoxelSize.Z = vdbVolume.VoxelSize.Z * 0.5f;
+            resampledVolume.voxelSize.x = vdbVolume.voxelSize.x * 2;
+            resampledVolume.voxelSize.y = vdbVolume.voxelSize.y * 1;
+            resampledVolume.voxelSize.z = vdbVolume.voxelSize.z * 0.5f;
 
-            Assert.That(resampledVolume.Dims.X, Is.EqualTo(13));
-            Assert.That(resampledVolume.Dims.Y, Is.EqualTo(27));
-            Assert.That(resampledVolume.Dims.Z, Is.EqualTo(53));
+            Assert.That(resampledVolume.dims.x, Is.EqualTo(13));
+            Assert.That(resampledVolume.dims.y, Is.EqualTo(27));
+            Assert.That(resampledVolume.dims.z, Is.EqualTo(53));
 
-            Assert.That(resampledVolume.VoxelSize.X, Is.EqualTo(0.2f).Within(0.001f));
-            Assert.That(resampledVolume.VoxelSize.Y, Is.EqualTo(0.1f).Within(0.001f));
-            Assert.That(resampledVolume.VoxelSize.Z, Is.EqualTo(0.05f).Within(0.001f));
+            Assert.That(resampledVolume.voxelSize.x, Is.EqualTo(0.2f).Within(0.001f));
+            Assert.That(resampledVolume.voxelSize.y, Is.EqualTo(0.1f).Within(0.001f));
+            Assert.That(resampledVolume.voxelSize.z, Is.EqualTo(0.05f).Within(0.001f));
 
             var tempFile = Path.GetTempFileName() + ".vdb";
             VoxelsSave.ToAnySupportedFormat(resampledVolume, tempFile);
@@ -132,9 +126,9 @@ public void TestResampling()
             Assert.That(restored.Size(), Is.EqualTo(1));
 
             var readVolume = restored.At(0);
-            Assert.That(readVolume.VoxelSize.X, Is.EqualTo(0.2f).Within(0.001f));
-            Assert.That(readVolume.VoxelSize.Y, Is.EqualTo(0.1f).Within(0.001f));
-            Assert.That(readVolume.VoxelSize.Z, Is.EqualTo(0.05f).Within(0.001f));
+            Assert.That(readVolume.voxelSize.x, Is.EqualTo(0.2f).Within(0.001f));
+            Assert.That(readVolume.voxelSize.y, Is.EqualTo(0.1f).Within(0.001f));
+            Assert.That(readVolume.voxelSize.z, Is.EqualTo(0.05f).Within(0.001f));
 
             File.Delete(tempFile);
         }
@@ -144,19 +138,19 @@ public void TestCropping()
         {
             var vdbVolume = CreateVolume();
             var box = new Box3i();
-            box.Min.X = 2;
-            box.Min.Y = 5;
-            box.Min.Z = 1;
-            box.Max.X = 18;
-            box.Max.Y = 13;
-            box.Max.Z = 23;
-
-            var croppedGrid = Cropped(vdbVolume.Data, box);
+            box.min.x = 2;
+            box.min.y = 5;
+            box.min.z = 1;
+            box.max.x = 18;
+            box.max.y = 13;
+            box.max.z = 23;
+
+            var croppedGrid = Cropped(vdbVolume.data, box);
             var croppedVolume = FloatGridToVdbVolume(croppedGrid);
 
-            Assert.That(croppedVolume.Dims.X, Is.EqualTo(16));
-            Assert.That(croppedVolume.Dims.Y, Is.EqualTo(8));
-            Assert.That(croppedVolume.Dims.Z, Is.EqualTo(22));
+            Assert.That(croppedVolume.dims.x, Is.EqualTo(16));
+            Assert.That(croppedVolume.dims.y, Is.EqualTo(8));
+            Assert.That(croppedVolume.dims.z, Is.EqualTo(22));
         }
 
         [Test]
@@ -164,15 +158,15 @@ public void TestAccessors()
         {
             var vdbVolume = CreateVolume();
             var p = new Vector3i();
-            Assert.That( GetValue( vdbVolume.Data, p ) == 3.0f );
+            Assert.That( GetValue( vdbVolume.data, p ) == 3.0f );
 
-            var region = new VoxelBitSet( (ulong)( vdbVolume.Dims.X * vdbVolume.Dims.Y * vdbVolume.Dims.Z ) );
+            var region = new VoxelBitSet( (ulong)( vdbVolume.dims.x * vdbVolume.dims.y * vdbVolume.dims.z ) );
             region.Set(new VoxelId(0));
-            SetValue( vdbVolume.Data, region, 1.0f );
-            Assert.That( GetValue( vdbVolume.Data, p ) == 1.0f );
+            SetValue( vdbVolume.data, region, 1.0f );
+            Assert.That( GetValue( vdbVolume.data, p ) == 1.0f );
 
-            SetValue( vdbVolume.Data, p, 2.0f );
-            Assert.That( GetValue( vdbVolume.Data, p ) == 2.0f );
+            SetValue( vdbVolume.data, p, 2.0f );
+            Assert.That( GetValue( vdbVolume.data, p ) == 2.0f );
         }
     }
-}
\ No newline at end of file
+}
diff --git a/source/MRDotNet2Test/src/Vector3Tests.cs b/source/MRDotNet2Test/src/Vector3Tests.cs
index 3474dce72063..72c4d26367c9 100644
--- a/source/MRDotNet2Test/src/Vector3Tests.cs
+++ b/source/MRDotNet2Test/src/Vector3Tests.cs
@@ -10,18 +10,18 @@ internal class Vector3Tests
         public void TestConstructor()
         {
             var a = new Vector3f(1, 2, 3);
-            Assert.That(1 == a.X);
-            Assert.That(2 == a.Y);
-            Assert.That(3 == a.Z);
+            Assert.That(1 == a.x);
+            Assert.That(2 == a.y);
+            Assert.That(3 == a.z);
         }
 
         [Test]
         public void TestDefaultConstructor()
         {
             var a = new Vector3f();
-            Assert.That(0 == a.X);
-            Assert.That(0 == a.Y);
-            Assert.That(0 == a.Z);
+            Assert.That(0 == a.x);
+            Assert.That(0 == a.y);
+            Assert.That(0 == a.z);
         }
 
         [Test]
@@ -31,9 +31,9 @@ public void TestAddition()
             var b = new Vector3f(4, 5, 6);
             var c = a + b;
 
-            Assert.That(5 == c.X);
-            Assert.That(7 == c.Y);
-            Assert.That(9 == c.Z);
+            Assert.That(5 == c.x);
+            Assert.That(7 == c.y);
+            Assert.That(9 == c.z);
         }
 
         [Test]
@@ -43,9 +43,9 @@ public void TestSubtraction()
             var b = new Vector3f(6, 5, 4);
             var c = b - a;
 
-            Assert.That(5 == c.X);
-            Assert.That(3 == c.Y);
-            Assert.That(1 == c.Z);            
+            Assert.That(5 == c.x);
+            Assert.That(3 == c.y);
+            Assert.That(1 == c.z);
         }
 
         [Test]
@@ -55,14 +55,14 @@ public void TestMultiplication()
             float k = 2;
             var c = a * k;
 
-            Assert.That(2 == c.X);
-            Assert.That(4 == c.Y);
-            Assert.That(6 == c.Z);
+            Assert.That(2 == c.x);
+            Assert.That(4 == c.y);
+            Assert.That(6 == c.z);
 
             c = k * a;
-            Assert.That(2 == c.X);
-            Assert.That(4 == c.Y);
-            Assert.That(6 == c.Z);
-        }        
+            Assert.That(2 == c.x);
+            Assert.That(4 == c.y);
+            Assert.That(6 == c.z);
+        }
     }
 }
diff --git a/thirdparty/mrbind b/thirdparty/mrbind
index e7dca2462010..567107bf84ad 160000
--- a/thirdparty/mrbind
+++ b/thirdparty/mrbind
@@ -1 +1 @@
-Subproject commit e7dca24620106b0c3260698f168193c2d930db2c
+Subproject commit 567107bf84ad3c84474f02576df1769f91373546