diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 3b9e2c2101dd9a2c13a186080675fa3b030f974a..5bd1c4d571b16702318c6dbba5e39f9c89dc6664 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -36,6 +36,7 @@ build-img:
             -DCMAKE_MODULE_PATH=$PWD/build
             -DCMAKE_BUILD_TYPE=Debug
             -DCSG_CGAL_ENABLED=${ENABLE_CGAL}
+            -DCMAKE_CXX_FLAGS="-pedantic-errors"
     - cmake --build build --target unit_tests_csg
     - cd build
     - ctest
diff --git a/src/csg/tests/levelset/boolean.t.cpp b/src/csg/tests/levelset/boolean.t.cpp
index 71486d5145ca860e7cb2bca396f8ec93148d0b35..f39af1da76a6e8cdf63b7c17896fcabb12795a6f 100644
--- a/src/csg/tests/levelset/boolean.t.cpp
+++ b/src/csg/tests/levelset/boolean.t.cpp
@@ -9,8 +9,12 @@ namespace {
 
 TEST_CASE("Union3D", "[Levelset Boolean]") {
   // Create a union of a cube of size 12 and a sphere of radius 8
-  csg::Cube my_cub{.name = std::nullopt, .size = {12, 12, 12}, .center = true};
-  csg::Sphere my_sph{.name = std::nullopt, .radius = 8};
+  csg::Cube my_cub;
+  my_cub.size = {12, 12, 12};
+  my_cub.center = true;
+
+  csg::Sphere my_sph;
+  my_sph.radius = 8;
 
   auto my_union = csg::Union3D();
   my_union.objs.push_back(my_cub);
@@ -35,8 +39,12 @@ TEST_CASE("Union3D", "[Levelset Boolean]") {
 
 TEST_CASE("Intersection3D", "[Levelset Boolean]") {
   // Create an of a cube of size 12 and a sphere of radius 8
-  csg::Cube my_cub{.name = std::nullopt, .size = {12, 12, 12}, .center = true};
-  csg::Sphere my_sph{.name = std::nullopt, .radius = 8};
+  csg::Cube my_cub;
+  my_cub.size = {12, 12, 12};
+  my_cub.center = true;
+
+  csg::Sphere my_sph;
+  my_sph.radius = 8;
 
   auto my_in = csg::Intersection3D();
   my_in.objs.push_back(my_cub);
@@ -61,8 +69,12 @@ TEST_CASE("Intersection3D", "[Levelset Boolean]") {
 
 TEST_CASE("Difference3D", "[Levelset Boolean]") {
   // Create an of a cube of size 12 and remove a sphere of radius 8
-  csg::Cube my_cub{.name = std::nullopt, .size = {12, 12, 12}, .center = true};
-  csg::Sphere my_sph{.name = std::nullopt, .radius = 8};
+  csg::Cube my_cub;
+  my_cub.size = {12, 12, 12};
+  my_cub.center = true;
+
+  csg::Sphere my_sph;
+  my_sph.radius = 8;
 
   csg::Union3D my_union;
   my_union.objs.push_back(my_sph);
diff --git a/src/csg/tests/levelset/empty.t.cpp b/src/csg/tests/levelset/empty.t.cpp
index ef29f4fc7b1050e23d9772b6e27a15e899644a15..e03b8ffc07e516489dba4a354ca03757b8f36f2d 100644
--- a/src/csg/tests/levelset/empty.t.cpp
+++ b/src/csg/tests/levelset/empty.t.cpp
@@ -24,8 +24,12 @@ TEST_CASE("Empty Difference3D", "[Levelset Boolean]") {
 
 TEST_CASE("Empty Difference2D", "[Levelset Boolean]") {
   double height = 100, radius = 10;
-  auto my_lin_ext = csg::LinearExtrude{
-      .height = 100, .center = false, .scale = {1, 1}, .group = csg::Union2D()};
+  csg::LinearExtrude my_lin_ext;
+  my_lin_ext.height = 100;
+  my_lin_ext.center = false;
+  my_lin_ext.scale = {1, 1};
+  my_lin_ext.group = csg::Union2D();
+
   auto my_diff = csg::Difference2D();
 
   my_lin_ext.center = false;
@@ -42,4 +46,4 @@ TEST_CASE("Empty Difference2D", "[Levelset Boolean]") {
   CHECK_FALSE(0 < my_levelset(9, 0, 0));
 }
 
-}
+} // namespace
diff --git a/src/csg/tests/levelset/extrude.t.cpp b/src/csg/tests/levelset/extrude.t.cpp
index 8706dd08465a7e0f835d39255a36fe7c311fd445..f057d787bba230ba7cdb206bd920f35491b000c8 100644
--- a/src/csg/tests/levelset/extrude.t.cpp
+++ b/src/csg/tests/levelset/extrude.t.cpp
@@ -8,9 +8,14 @@ namespace {
 
 TEST_CASE("linear", "[Levelset Extrude]") {
   double height = 100, radius = 10;
-  auto my_lin_ext = csg::LinearExtrude{
-      .height = 100, .center = false, .scale = {1, 1}, .group = csg::Union2D()};
-  csg::Circle my_cir{.name = std::nullopt, .radius = radius};
+  csg::LinearExtrude my_lin_ext;
+  my_lin_ext.height = 100;
+  my_lin_ext.center = false;
+  my_lin_ext.scale = {1, 1};
+  my_lin_ext.group = csg::Union2D();
+
+  csg::Circle my_cir;
+  my_cir.radius = radius;
 
   SECTION("Not centered") {
     my_lin_ext.center = false;
@@ -100,10 +105,15 @@ TEST_CASE("linear", "[Levelset Extrude]") {
 }
 
 TEST_CASE("two shape linear extrude", "[Levelset Extrude]") {
-  auto my_lin_ext = csg::LinearExtrude{
-      .height = 100, .center = true, .scale = {1, 1}, .group = csg::Union2D()};
+  csg::LinearExtrude my_lin_ext;
+  my_lin_ext.height = 100;
+  my_lin_ext.center = true;
+  my_lin_ext.scale = {1, 1};
+  my_lin_ext.group = csg::Union2D();
+
+  csg::Circle my_cir;
+  my_cir.radius = 1;
 
-  csg::Circle my_cir{.name = std::nullopt, .radius = 1};
   my_lin_ext.group.objs.push_back(my_cir);
 
   auto my_mat = csg::Mulmatrix2D({{1, 0}}, {{0, 1}});
@@ -133,9 +143,13 @@ TEST_CASE("two shape linear extrude", "[Levelset Extrude]") {
 }
 
 TEST_CASE("simple torus", "[Levelset Extrude]") {
-  auto my_rot_ext = csg::RotateExtrude{.angle = 360, .group = csg::Union2D()};
+  csg::RotateExtrude my_rot_ext;
+  my_rot_ext.angle = 360;
+  my_rot_ext.group = csg::Union2D();
+
+  csg::Circle my_cir;
+  my_cir.radius = 1;
 
-  csg::Circle my_cir{.name = std::nullopt, .radius = 1};
   auto my_mat = csg::Mulmatrix2D({{1, 0}}, {{0, 1}});
   my_mat.translation = {2, 0};
   my_mat.group.objs.push_back(my_cir);
@@ -166,8 +180,11 @@ TEST_CASE("Linear extrude of a triangle with hole", "[Levelset Primitives]") {
   double ht = 100.0, outer = 100.0, inner = 80.0;
   double thick = outer - inner;
 
-  auto my_lin_ext = csg::LinearExtrude{
-      .height = ht, .center = true, .scale = {1, 1}, .group = csg::Union2D()};
+  csg::LinearExtrude my_lin_ext;
+  my_lin_ext.height = ht;
+  my_lin_ext.center = true;
+  my_lin_ext.scale = {1, 1};
+  my_lin_ext.group = csg::Union2D();
 
   // A 100 x 100 right triangle with a 80 x 80 hole formed by using a polygon
   // and extrude
@@ -190,9 +207,9 @@ TEST_CASE("Linear extrude of a triangle with hole", "[Levelset Primitives]") {
   csg::Union2D my_union;
   my_union.objs.push_back(my_inner_tri);
 
-  auto my_diff = csg::Difference2D{
-      .first_obj = std::make_shared<csg::Type2D>(my_outer_tri),
-      .next_objs = csg::Union2D(my_union)};
+  csg::Difference2D my_diff;
+  my_diff.first_obj = std::make_shared<csg::Type2D>(my_outer_tri);
+  my_diff.next_objs = csg::Union2D(my_union);
 
   my_lin_ext.group.objs.push_back(my_diff);
 
@@ -248,9 +265,13 @@ TEST_CASE("Linear extrude of a triangle with hole", "[Levelset Primitives]") {
 #endif
 
 TEST_CASE("sliced torus", "[Levelset Extrude]") {
-  auto my_rot_ext = csg::RotateExtrude{.angle = 45, .group = csg::Union2D()};
+  csg::RotateExtrude my_rot_ext;
+  my_rot_ext.angle = 45;
+  my_rot_ext.group = csg::Union2D();
+
+  csg::Circle my_cir;
+  my_cir.radius = 1;
 
-  csg::Circle my_cir{.name = std::nullopt, .radius = 1};
   auto my_mat = csg::Mulmatrix2D({{1, 0}}, {{0, 1}});
   my_mat.translation = {2, 0};
   my_mat.group.objs.push_back(my_cir);
@@ -283,12 +304,16 @@ TEST_CASE("sliced torus", "[Levelset Extrude]") {
 
 TEST_CASE("linear with twist", "[Levelset Extrude]") {
   double height = 10, radius = 1;
-  auto my_lin_ext = csg::LinearExtrude{.height = height,
-                                       .center = false,
-                                       .scale = {1, 1},
-                                       .twist = 320,
-                                       .group = csg::Union2D()};
-  csg::Circle my_cir{.name = std::nullopt, .radius = radius};
+  csg::LinearExtrude my_lin_ext;
+  my_lin_ext.height = height;
+  my_lin_ext.center = false;
+  my_lin_ext.scale = {1, 1};
+  my_lin_ext.twist = 320;
+  my_lin_ext.group = csg::Union2D();
+
+  csg::Circle my_cir;
+  my_cir.radius = radius;
+
   auto my_mat = csg::Mulmatrix2D({{1, 0}}, {{0, 1}});
   my_mat.translation = {2, 0};
   my_mat.group.objs.push_back(my_cir);
diff --git a/src/csg/tests/levelset/internal_flow.t.cpp b/src/csg/tests/levelset/internal_flow.t.cpp
index 230c7e263de6b2a935356d86ce41b2f5ec7f8daf..b85efdb05ce3bd81926bf7e6dc154a10f89c0b3f 100644
--- a/src/csg/tests/levelset/internal_flow.t.cpp
+++ b/src/csg/tests/levelset/internal_flow.t.cpp
@@ -9,8 +9,12 @@ namespace {
 
 TEST_CASE("union internal flow", "[Levelset Internal Flow]") {
   // Create a union of a cube of size 12 and a sphere of radius 8
-  csg::Cube my_cub{.name = std::nullopt, .size = {12, 12, 12}, .center = true};
-  csg::Sphere my_sph{.name = std::nullopt, .radius = 8};
+  csg::Cube my_cub;
+  my_cub.size = {12, 12, 12};
+  my_cub.center = true;
+
+  csg::Sphere my_sph;
+  my_sph.radius = 8;
 
   auto my_union = csg::Union3D();
   my_union.objs.push_back(my_cub);
@@ -37,7 +41,8 @@ TEST_CASE("union internal flow", "[Levelset Internal Flow]") {
 
 TEST_CASE("CsgIF copy constructor", "[Levelset Internal Flow]") {
 
-  csg::Sphere my_sph{.name = std::nullopt, .radius = 10};
+  csg::Sphere my_sph;
+  my_sph.radius = 10;
 
   auto my_tree = std::make_shared<csg::Tree>();
   my_tree->top.objs.push_back(my_sph);
diff --git a/src/csg/tests/levelset/primitives.t.cpp b/src/csg/tests/levelset/primitives.t.cpp
index 57690ecd6f75cc160c68e2eef0e5475f318d3306..ca409d75e2042e7af54f95f9e59876cc5fd1a523 100644
--- a/src/csg/tests/levelset/primitives.t.cpp
+++ b/src/csg/tests/levelset/primitives.t.cpp
@@ -7,8 +7,10 @@ namespace {
 
 TEST_CASE("Cylinder", "[Levelset Primitives]") {
 
-  csg::Cylinder my_cyl{
-      .name = std::nullopt, .radius = 1, .height = 2, .center = false};
+  csg::Cylinder my_cyl;
+  my_cyl.radius = 1;
+  my_cyl.height = 2;
+  my_cyl.center = false;
 
   SECTION("Not Centered") {
     my_cyl.center = false;
@@ -78,7 +80,9 @@ TEST_CASE("Cylinder", "[Levelset Primitives]") {
 
 TEST_CASE("Cube", "[Levelset Primitives]") {
 
-  csg::Cube my_cub{.name = std::nullopt, .size = {2, 3, 5}, .center = false};
+  csg::Cube my_cub;
+  my_cub.size = {2, 3, 5};
+  my_cub.center = false;
 
   SECTION("Not Centered") {
     my_cub.center = false;
@@ -156,7 +160,8 @@ TEST_CASE("Cube", "[Levelset Primitives]") {
 
 TEST_CASE("Sphere", "[Levelset Primitives]") {
 
-  csg::Sphere my_sph{.name = std::nullopt, .radius = 10};
+  csg::Sphere my_sph;
+  my_sph.radius = 10;
 
   auto my_tree = std::make_shared<csg::Tree>();
   my_tree->top.objs.push_back(my_sph);
@@ -190,11 +195,11 @@ TEST_CASE("Cone", "[Levelset Primitives]") {
 
   SECTION("radius1 < radius 2; regular)") {
 
-    csg::Cone my_cone{.name = std::nullopt,
-                      .radius1 = 0,
-                      .radius2 = 1,
-                      .height = 2,
-                      .center = false};
+    csg::Cone my_cone;
+    my_cone.radius1 = 0;
+    my_cone.radius2 = 1;
+    my_cone.height = 2;
+    my_cone.center = false;
 
     SECTION("Untruncated") {
       my_cone.radius1 = 0;
@@ -474,11 +479,11 @@ TEST_CASE("Cone", "[Levelset Primitives]") {
   }
 
   SECTION("radius1 > radius2; inverted") {
-    csg::Cone my_cone{.name = std::nullopt,
-                      .radius1 = 1,
-                      .radius2 = 0,
-                      .height = 2,
-                      .center = false};
+    csg::Cone my_cone;
+    my_cone.radius1 = 1;
+    my_cone.radius2 = 0;
+    my_cone.height = 2;
+    my_cone.center = false;
 
     SECTION("Untruncated") {
       my_cone.radius2 = 0;
diff --git a/src/csg/tests/levelset/transform.t.cpp b/src/csg/tests/levelset/transform.t.cpp
index 8e48f5c2a34d7d4e07cd96f5983e043e0abd6247..22d41480615d37c0592fc19820abf43be72b3a39 100644
--- a/src/csg/tests/levelset/transform.t.cpp
+++ b/src/csg/tests/levelset/transform.t.cpp
@@ -10,8 +10,10 @@ namespace {
 
 TEST_CASE("Translation", "[Levelset Transform]") {
 
-  csg::Cylinder my_cyl{
-      .name = std::nullopt, .radius = 2, .height = 20, .center = true};
+  csg::Cylinder my_cyl;
+  my_cyl.radius = 2;
+  my_cyl.height = 20;
+  my_cyl.center = true;
 
   auto my_mat = csg::Mulmatrix3D({{1, 0, 0}}, {{0, 1, 0}}, {{0, 0, 1}});
   my_mat.translation = {100, 200, 300};
@@ -43,8 +45,10 @@ TEST_CASE("Translation", "[Levelset Transform]") {
 TEST_CASE("90° Rotation around y-axis, rotating z-axis into x-axis",
           "[Levelset Transform]") {
 
-  csg::Cylinder my_cyl{
-      .name = std::nullopt, .radius = 2, .height = 20, .center = false};
+  csg::Cylinder my_cyl;
+  my_cyl.radius = 2;
+  my_cyl.height = 20;
+  my_cyl.center = false;
 
   auto my_mat = csg::Mulmatrix3D({{0, 0, 1}}, {{0, 1, 0}}, {{-1, 0, 0}});
   my_mat.translation = {0, 0, 0};
@@ -88,8 +92,11 @@ TEST_CASE("90° rotation + translation of cylinder", "[Levelset Transform]") {
   double radius = 4.5, height = 10;
   double Cx = 10, Cy = 5, Cz = 5;
 
-  csg::Cylinder my_cyl{
-      .name = std::nullopt, .radius = radius, .height = height, .center = true};
+  csg::Cylinder my_cyl;
+  my_cyl.radius = radius;
+  my_cyl.height = height;
+  my_cyl.center = true;
+
   auto my_mat = csg::Mulmatrix3D({{0, 0, 1}}, {{0, 1, 0}}, {{-1, 0, 0}});
   my_mat.translation = {Cx, Cy, Cz};
   my_mat.group.objs.push_back(my_cyl);
@@ -134,8 +141,9 @@ TEST_CASE("90° rotation + translation of cylinder", "[Levelset Transform]") {
 TEST_CASE("45° Rotation around y-axis", "[Levelset Transform]") {
 
   double side = 20;
-  csg::Cube my_cub{
-      .name = std::nullopt, .size = {side, side, side}, .center = true};
+  csg::Cube my_cub;
+  my_cub.size = {side, side, side};
+  my_cub.center = true;
 
   auto my_mat = csg::Mulmatrix3D({{0.707107, 0, 0.707107}}, {{0, 1, 0}},
                                  {{-0.707107, 0, 0.707107}});
@@ -203,10 +211,10 @@ TEST_CASE("Skewed with shear y along z", "[Levelset Transform]") {
   double radius = 10, height = 10;
   double skew_yz = 0.7;
 
-  csg::Cylinder my_cyl{.name = std::nullopt,
-                       .radius = radius,
-                       .height = height,
-                       .center = false};
+  csg::Cylinder my_cyl;
+  my_cyl.radius = radius;
+  my_cyl.height = height,
+  my_cyl.center = false;
 
   auto my_mat = csg::Mulmatrix3D({{1, 0, 0}}, {{0, 1, skew_yz}}, {{0, 0, 1}});
   my_mat.translation = {0, 0, 0};