diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 6d4efcc..166fe68 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -8,4 +8,4 @@ endif()
 
 add_subdirectory(app)
 add_subdirectory(core)
-add_subdirectory(drivers)
\ No newline at end of file
+add_subdirectory(meshers)
\ No newline at end of file
diff --git a/src/drivers/CMakeLists.txt b/src/drivers/CMakeLists.txt
deleted file mode 100644
index 68b8c03..0000000
--- a/src/drivers/CMakeLists.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-message(STATUS "Creating build system for tessellator-drivers")
-
-add_library(tessellator-drivers
-    "DriverBase.cpp"
-    "StructuredDriver.cpp"
-)
-target_link_libraries(tessellator-drivers tessellator-core tessellator-utils)
-
-if (TESSELLATOR_ENABLE_CGAL)
-    target_sources(tessellator-drivers PRIVATE
-        "OffgridDriver.cpp"
-    )
-    target_link_libraries(tessellator-drivers tessellator-cgal)
-endif()
-
-if(TESSELLATOR_EXECUTION_POLICIES)
-    add_definitions(-DTESSELLATOR_EXECUTION_POLICIES)
-    find_package(TBB CONFIG REQUIRED)
-    target_link_libraries(tessellator-drivers TBB::tbb)
-endif()
\ No newline at end of file
diff --git a/src/meshers/CMakeLists.txt b/src/meshers/CMakeLists.txt
new file mode 100644
index 0000000..2db38ed
--- /dev/null
+++ b/src/meshers/CMakeLists.txt
@@ -0,0 +1,20 @@
+message(STATUS "Creating build system for tessellator-meshers")
+
+add_library(tessellator-meshers
+    "MesherBase.cpp"
+    "StructuredMesher.cpp"
+)
+target_link_libraries(tessellator-meshers tessellator-core tessellator-utils)
+
+if (TESSELLATOR_ENABLE_CGAL)
+    target_sources(tessellator-meshers PRIVATE
+        "OffgridMesher.cpp"
+    )
+    target_link_libraries(tessellator-meshers tessellator-cgal)
+endif()
+
+if(TESSELLATOR_EXECUTION_POLICIES)
+    add_definitions(-DTESSELLATOR_EXECUTION_POLICIES)
+    find_package(TBB CONFIG REQUIRED)
+    target_link_libraries(tessellator-meshers TBB::tbb)
+endif()
\ No newline at end of file
diff --git a/src/drivers/DriverBase.cpp b/src/meshers/MesherBase.cpp
similarity index 77%
rename from src/drivers/DriverBase.cpp
rename to src/meshers/MesherBase.cpp
index 84dab76..bb92f78 100644
--- a/src/drivers/DriverBase.cpp
+++ b/src/meshers/MesherBase.cpp
@@ -1,4 +1,4 @@
-#include "DriverBase.h"
+#include "MesherBase.h"
 
 #include <iostream>
 
@@ -6,14 +6,14 @@
 #include "utils/GridTools.h"
 
 namespace meshlib {
-namespace drivers {
+namespace meshers {
 
 
 using namespace utils;
 using namespace meshTools;
 
 
-void DriverBase::log(const std::string& msg, std::size_t level)
+void MesherBase::log(const std::string& msg, std::size_t level)
 {
     std::cout << "[Tessellator] ";
     for (std::size_t i = 0; i < level; i++) {
@@ -23,21 +23,21 @@ void DriverBase::log(const std::string& msg, std::size_t level)
     std::cout << msg << std::endl;
 }
 
-void DriverBase::logNumberOfQuads(std::size_t nQuads)
+void MesherBase::logNumberOfQuads(std::size_t nQuads)
 {
     std::stringstream msg;
     msg << "Mesh contains " << nQuads << " quads.";
     log(msg.str(), 2);
 }
 
-void DriverBase::logNumberOfTriangles(std::size_t nTris)
+void MesherBase::logNumberOfTriangles(std::size_t nTris)
 {
     std::stringstream msg;
     msg << "Mesh contains " << nTris << " triangles.";
     log(msg.str(), 2);
 }
 
-void DriverBase::logNumberOfLines(std::size_t nLines)
+void MesherBase::logNumberOfLines(std::size_t nLines)
 {
     std::stringstream msg;
     msg << "Mesh contains " << nLines << " lines.";
@@ -45,14 +45,14 @@ void DriverBase::logNumberOfLines(std::size_t nLines)
 }
 
 
-void DriverBase::logNumberOfNodes(std::size_t nNodes)
+void MesherBase::logNumberOfNodes(std::size_t nNodes)
 {
     std::stringstream msg;
     msg << "Mesh contains " << nNodes << " nodes.";
     log(msg.str(), 2);
 }
 
-void DriverBase::logGridSize(const Grid& g)
+void MesherBase::logGridSize(const Grid& g)
 {
     std::stringstream msg;
     msg << "Grid size is "
@@ -60,7 +60,7 @@ void DriverBase::logGridSize(const Grid& g)
     log(msg.str(), 2);
 }
 
-DriverBase::DriverBase(const Mesh& inputMesh) : originalGrid_{inputMesh.grid}{
+MesherBase::MesherBase(const Mesh& inputMesh) : originalGrid_{inputMesh.grid}{
 
     logGridSize(inputMesh.grid);
     logNumberOfTriangles(countMeshElementsIf(inputMesh, isTriangle));
@@ -68,11 +68,11 @@ DriverBase::DriverBase(const Mesh& inputMesh) : originalGrid_{inputMesh.grid}{
     enlargedGrid_ = getEnlargedGridIncludingAllElements(inputMesh);
 }
 
-Mesh DriverBase::buildSurfaceMesh(const Mesh& inputMesh) {
+Mesh MesherBase::buildSurfaceMesh(const Mesh& inputMesh) {
     return buildMeshFilteringElements(inputMesh, isNotTetrahedron);
 }
 
-Grid DriverBase::buildNonSlicingGrid(const Grid& primal, const Grid& enlarged)
+Grid MesherBase::buildNonSlicingGrid(const Grid& primal, const Grid& enlarged)
 {
     assert(primal.size() >= 2);
     assert(enlarged.size() >= 2);
@@ -92,7 +92,7 @@ Grid DriverBase::buildNonSlicingGrid(const Grid& primal, const Grid& enlarged)
     return resultGrid;
 }
 
-Grid DriverBase::buildSlicingGrid(const Grid& primal, const Grid& enlarged)
+Grid MesherBase::buildSlicingGrid(const Grid& primal, const Grid& enlarged)
 {
     const auto nonSlicing{ buildNonSlicingGrid(primal, enlarged) };
     Grid r;
diff --git a/src/drivers/DriverBase.h b/src/meshers/MesherBase.h
similarity index 82%
rename from src/drivers/DriverBase.h
rename to src/meshers/MesherBase.h
index 41664f4..857bf37 100644
--- a/src/drivers/DriverBase.h
+++ b/src/meshers/MesherBase.h
@@ -1,15 +1,15 @@
 #pragma once
 
 #include "types/Mesh.h"
-#include "DriverInterface.h"
+#include "MesherInterface.h"
 
 namespace meshlib {
-namespace drivers {
+namespace meshers {
 
-class DriverBase : public DriverInterface {
+class MesherBase : public MesherInterface {
 public:
-    DriverBase(const Mesh& in);
-    virtual ~DriverBase() = default;
+    MesherBase(const Mesh& in);
+    virtual ~MesherBase() = default;
     virtual Mesh mesh() const = 0;
 
 protected:
diff --git a/src/drivers/DriverInterface.h b/src/meshers/MesherInterface.h
similarity index 61%
rename from src/drivers/DriverInterface.h
rename to src/meshers/MesherInterface.h
index 5380af4..fdce554 100644
--- a/src/drivers/DriverInterface.h
+++ b/src/meshers/MesherInterface.h
@@ -2,11 +2,11 @@
 
 #include "types/Mesh.h"
 
-namespace meshlib::drivers {
+namespace meshlib::meshers {
 
-    class DriverInterface {
+    class MesherInterface {
     public:
-        virtual ~DriverInterface() = default;
+        virtual ~MesherInterface() = default;
         virtual Mesh mesh() const = 0;
 
     protected:
diff --git a/src/drivers/OffgridDriver.cpp b/src/meshers/OffgridMesher.cpp
similarity index 87%
rename from src/drivers/OffgridDriver.cpp
rename to src/meshers/OffgridMesher.cpp
index 620a5f8..d125bc9 100644
--- a/src/drivers/OffgridDriver.cpp
+++ b/src/meshers/OffgridMesher.cpp
@@ -1,6 +1,6 @@
-#include "OffgridDriver.h"
+#include "OffgridMesher.h"
 
-#include "DriverBase.h"
+#include "MesherBase.h"
 #include "core/Slicer.h"
 #include "core/Collapser.h"
 #include "core/Smoother.h"
@@ -13,7 +13,7 @@
 #include "utils/Cleaner.h"
 #include "utils/MeshTools.h"
 
-namespace meshlib::drivers {
+namespace meshlib::meshers {
 
 using namespace utils;
 using namespace meshTools;
@@ -40,8 +40,8 @@ Mesh buildVolumeMesh(const Mesh& inputMesh, const std::set<GroupId>& volumeGroup
     return resultMesh;
 }
 
-OffgridDriver::OffgridDriver(const Mesh& in, const OffgridDriverOptions& opts) :
-    DriverBase::DriverBase(in),
+OffgridMesher::OffgridMesher(const Mesh& in, const OffgridMesherOptions& opts) :
+    MesherBase::MesherBase(in),
     opts_{ opts }
 {        
     log("Preparing volumes.");
@@ -59,16 +59,16 @@ OffgridDriver::OffgridDriver(const Mesh& in, const OffgridDriverOptions& opts) :
     log("Initial hull mesh built succesfully.");
 }
 
-Mesh OffgridDriver::buildSurfaceMesh(const Mesh& inputMesh, const std::set<GroupId>& volumeGroups)
+Mesh OffgridMesher::buildSurfaceMesh(const Mesh& inputMesh, const std::set<GroupId>& volumeGroups)
 {
-    auto resultMesh = DriverBase::buildSurfaceMesh(inputMesh);
+    auto resultMesh = MesherBase::buildSurfaceMesh(inputMesh);
     for (const auto& gId : volumeGroups) {
         resultMesh.groups[gId].elements.clear();
     }
     return resultMesh;
 }
 
-void OffgridDriver::process(Mesh& mesh) const
+void OffgridMesher::process(Mesh& mesh) const
 {
     const auto slicingGrid{ buildSlicingGrid(originalGrid_, enlargedGrid_) };
     
@@ -113,7 +113,7 @@ void OffgridDriver::process(Mesh& mesh) const
     }
 }
 
-Mesh OffgridDriver::mesh() const 
+Mesh OffgridMesher::mesh() const 
 {
     log("Building primal mesh.");
     Mesh res{ volumeMesh_ };
@@ -127,7 +127,7 @@ Mesh OffgridDriver::mesh() const
     return res;
 }
 
-Filler OffgridDriver::fill(const std::vector<Priority>& groupPriorities) const
+Filler OffgridMesher::fill(const std::vector<Priority>& groupPriorities) const
 {
     log("Building primal filler.", 1);
     
@@ -138,7 +138,7 @@ Filler OffgridDriver::fill(const std::vector<Priority>& groupPriorities) const
     };
 }
 
-Filler OffgridDriver::dualFill(const std::vector<Priority>& groupPriorities) const
+Filler OffgridMesher::dualFill(const std::vector<Priority>& groupPriorities) const
 {
     log("Building dual filler.", 1);
     const auto dGrid{ GridTools{ originalGrid_ }.getExtendedDualGrid() };
diff --git a/src/drivers/OffgridDriver.h b/src/meshers/OffgridMesher.h
similarity index 66%
rename from src/drivers/OffgridDriver.h
rename to src/meshers/OffgridMesher.h
index 7843fb3..3196595 100644
--- a/src/drivers/OffgridDriver.h
+++ b/src/meshers/OffgridMesher.h
@@ -2,18 +2,18 @@
 
 #include "cgal/filler/Filler.h"
 #include "types/Mesh.h"
-#include "DriverBase.h"
-#include "OffgridDriverOptions.h"
+#include "MesherBase.h"
+#include "OffgridMesherOptions.h"
 
 namespace meshlib {
-namespace drivers {
+namespace meshers {
 
 using namespace cgal;
 
-class OffgridDriver : public DriverBase {
+class OffgridMesher : public MesherBase {
 public:
-    OffgridDriver(const Mesh& in, const OffgridDriverOptions& opts = OffgridDriverOptions());
-    virtual ~OffgridDriver() = default;
+    OffgridMesher(const Mesh& in, const OffgridMesherOptions& opts = OffgridMesherOptions());
+    virtual ~OffgridMesher() = default;
     Mesh mesh() const;
 
     filler::Filler fill(
@@ -22,7 +22,7 @@ class OffgridDriver : public DriverBase {
         const std::vector<Priority>& groupPriorities = std::vector<Priority>()) const;
 
 private:
-    OffgridDriverOptions opts_;
+    OffgridMesherOptions opts_;
 
     Mesh volumeMesh_;
     Mesh surfaceMesh_;
diff --git a/src/drivers/OffgridDriverOptions.h b/src/meshers/OffgridMesherOptions.h
similarity index 82%
rename from src/drivers/OffgridDriverOptions.h
rename to src/meshers/OffgridMesherOptions.h
index 82be3ee..b43c2c8 100644
--- a/src/drivers/OffgridDriverOptions.h
+++ b/src/meshers/OffgridMesherOptions.h
@@ -2,9 +2,9 @@
 
 #include "core/SnapperOptions.h"
 
-namespace meshlib::drivers {
+namespace meshlib::meshers {
 
-class OffgridDriverOptions {
+class OffgridMesherOptions {
 public:
 
     bool forceSlicing = true;
diff --git a/src/drivers/StructuredDriver.cpp b/src/meshers/StructuredMesher.cpp
similarity index 84%
rename from src/drivers/StructuredDriver.cpp
rename to src/meshers/StructuredMesher.cpp
index 7e35bf7..cf6c895 100644
--- a/src/drivers/StructuredDriver.cpp
+++ b/src/meshers/StructuredMesher.cpp
@@ -1,4 +1,4 @@
-#include "StructuredDriver.h"
+#include "StructuredMesher.h"
 
 #include <iostream>
 
@@ -11,22 +11,22 @@
 #include "utils/MeshTools.h"
 #include "utils/GridTools.h"
 
-namespace meshlib::drivers {
+namespace meshlib::meshers {
 
 using namespace utils;
 using namespace core;
 using namespace meshTools;
 
 
-Mesh StructuredDriver::buildSurfaceMesh(const Mesh& inputMesh, const Mesh & volumeSurface)
+Mesh StructuredMesher::buildSurfaceMesh(const Mesh& inputMesh, const Mesh & volumeSurface)
 {
-    auto resultMesh = DriverBase::buildSurfaceMesh(inputMesh);
+    auto resultMesh = MesherBase::buildSurfaceMesh(inputMesh);
     mergeMesh(resultMesh, volumeSurface);
     return resultMesh;
 }
 
-StructuredDriver::StructuredDriver(const Mesh& inputMesh, int decimalPlacesInCollapser) :
-    DriverBase(inputMesh),
+StructuredMesher::StructuredMesher(const Mesh& inputMesh, int decimalPlacesInCollapser) :
+    MesherBase(inputMesh),
     decimalPlacesInCollapser_(decimalPlacesInCollapser)
 {
     log("Preparing surfaces.");
@@ -38,7 +38,7 @@ StructuredDriver::StructuredDriver(const Mesh& inputMesh, int decimalPlacesInCol
     log("Initial hull mesh built succesfully.");
 }
 
-void StructuredDriver::process(Mesh& mesh) const
+void StructuredMesher::process(Mesh& mesh) const
 {
     
     const auto slicingGrid{ buildSlicingGrid(originalGrid_, enlargedGrid_) };
@@ -73,7 +73,7 @@ void StructuredDriver::process(Mesh& mesh) const
 }
 
 
-Mesh StructuredDriver::mesh() const
+Mesh StructuredMesher::mesh() const
 {
     log("Building primal mesh.");
     Mesh resultMesh{ surfaceMesh_ };
diff --git a/src/drivers/StructuredDriver.h b/src/meshers/StructuredMesher.h
similarity index 55%
rename from src/drivers/StructuredDriver.h
rename to src/meshers/StructuredMesher.h
index d9e04ea..79f82c0 100644
--- a/src/drivers/StructuredDriver.h
+++ b/src/meshers/StructuredMesher.h
@@ -1,14 +1,14 @@
 #pragma once
 
 #include "types/Mesh.h"
-#include "DriverBase.h"
+#include "MesherBase.h"
 
-namespace meshlib::drivers {
+namespace meshlib::meshers {
 
-class StructuredDriver : public DriverBase {
+class StructuredMesher : public MesherBase {
 public:
-	StructuredDriver(const Mesh& in, int decimalPlacesInCollapser = 4);
-	virtual ~StructuredDriver() = default;
+	StructuredMesher(const Mesh& in, int decimalPlacesInCollapser = 4);
+	virtual ~StructuredMesher() = default;
 	Mesh mesh() const;
 
 private:
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index e800941..3f2abe8 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -7,7 +7,7 @@ include_directories(
 	${PROJECT_SOURCE_DIR}/src/
 	${PROJECT_SOURCE_DIR}/src/app/
 	${PROJECT_SOURCE_DIR}/src/core/
-	${PROJECT_SOURCE_DIR}/src/drivers/
+	${PROJECT_SOURCE_DIR}/src/meshers/
 	${PROJECT_SOURCE_DIR}/src/utils/
 	${PROJECT_SOURCE_DIR}/src/types/
 	${PROJECT_SOURCE_DIR}/test/
@@ -28,12 +28,12 @@ add_executable(tessellator_tests
 	"utils/GeometryTest.cpp"
 	"utils/GridToolsTest.cpp"
 	"utils/MeshToolsTest.cpp"
-    "drivers/StructuredDriverTest.cpp"
+    "meshers/StructuredMesherTest.cpp"
 )
 
 
 target_link_libraries(tessellator_tests	
-	tessellator-drivers
+	tessellator-meshers
 	tessellator-app
     GTest::gtest 
 	GTest::gtest_main
@@ -56,7 +56,7 @@ if (TESSELLATOR_ENABLE_CGAL)
 		"cgal/filler/FillerToolsTest.cpp"
 		"core/SmootherTest.cpp"
 		"core/SmootherToolsTest.cpp"
-		"drivers/OffgridDriverTest.cpp"
+		"meshers/OffgridMesherTest.cpp"
 	)	
 endif()
 
diff --git a/test/drivers/OffgridDriverTest.cpp b/test/meshers/OffgridMesherTest.cpp
similarity index 74%
rename from test/drivers/OffgridDriverTest.cpp
rename to test/meshers/OffgridMesherTest.cpp
index 6d4c128..542f8d6 100644
--- a/test/drivers/OffgridDriverTest.cpp
+++ b/test/meshers/OffgridMesherTest.cpp
@@ -2,40 +2,40 @@
 #include "MeshFixtures.h"
 #include "MeshTools.h"
 
-#include "drivers/OffgridDriver.h"
+#include "meshers/OffgridMesher.h"
 #include "utils/Geometry.h"
 
-namespace meshlib::drivers {
+namespace meshlib::meshers {
 using namespace meshFixtures;
 using namespace utils::meshTools;
 using namespace cgal::filler;
 
-class OffgridDriverTest : public ::testing::Test {
+class OffgridMesherTest : public ::testing::Test {
 public:
-    static OffgridDriverOptions buildSnappedOptions() {
-        OffgridDriverOptions opts;
+    static OffgridMesherOptions buildSnappedOptions() {
+        OffgridMesherOptions opts;
         opts.collapseInternalPoints = true;
         opts.snap = true;
         return opts;
     }
 
-    static OffgridDriverOptions buildAdaptedOptions() {
-        OffgridDriverOptions opts;
+    static OffgridMesherOptions buildAdaptedOptions() {
+        OffgridMesherOptions opts;
         opts.collapseInternalPoints = true;
         opts.snap = false;
         return opts;
     }
 
-    static OffgridDriverOptions buildRawOptions() {
-        OffgridDriverOptions opts;
+    static OffgridMesherOptions buildRawOptions() {
+        OffgridMesherOptions opts;
         opts.forceSlicing = true;
         opts.collapseInternalPoints = false;
         opts.snap = false;
         return opts;
     }
 
-    static OffgridDriverOptions buildBareOptions() {
-        OffgridDriverOptions opts;
+    static OffgridMesherOptions buildBareOptions() {
+        OffgridMesherOptions opts;
         opts.forceSlicing = false;
         opts.collapseInternalPoints = false;
         opts.snap = false;
@@ -86,12 +86,12 @@ class OffgridDriverTest : public ::testing::Test {
 
 };
 
-TEST_F(OffgridDriverTest, cubes_overlap_different_materials)
+TEST_F(OffgridMesherTest, cubes_overlap_different_materials)
 {
     auto opts{ buildAdaptedOptions() };
     opts.volumeGroups = { 0, 1 };
 
-    auto r{ OffgridDriver{ buildTwoCubesWithOffsetMesh(1.0), opts }.mesh() };
+    auto r{ OffgridMesher{ buildTwoCubesWithOffsetMesh(1.0), opts }.mesh() };
 
     ASSERT_EQ(2, r.groups.size());
 
@@ -99,7 +99,7 @@ TEST_F(OffgridDriverTest, cubes_overlap_different_materials)
     EXPECT_EQ(20, r.groups[1].elements.size());
 }
 
-TEST_F(OffgridDriverTest, two_materials_with_overlap_no_intersect)
+TEST_F(OffgridMesherTest, two_materials_with_overlap_no_intersect)
 {
     auto opts = buildAdaptedOptions();
     
@@ -107,14 +107,14 @@ TEST_F(OffgridDriverTest, two_materials_with_overlap_no_intersect)
     {
         Mesh oneMat = buildTwoMaterialsMesh();
         oneMat.groups.pop_back();
-        OffgridDriver mesher(oneMat, opts);
+        OffgridMesher mesher(oneMat, opts);
         ASSERT_NO_THROW(outOneMat = mesher.mesh());
     }
 
     Mesh outTwoMats;
     {
         Mesh twoMats = buildTwoMaterialsMesh();
-        OffgridDriver mesher(twoMats, opts);
+        OffgridMesher mesher(twoMats, opts);
         ASSERT_NO_THROW(outTwoMats = mesher.mesh());
     }
     
@@ -122,12 +122,12 @@ TEST_F(OffgridDriverTest, two_materials_with_overlap_no_intersect)
     ASSERT_EQ(2, outTwoMats.groups.size());   
 }
 
-TEST_F(OffgridDriverTest, two_materials_with_no_overlap_same_as_one_material)
+TEST_F(OffgridMesherTest, two_materials_with_no_overlap_same_as_one_material)
 {
     auto opts = buildAdaptedOptions();
     double stepSize = 1.0;
 
-    Mesh m = OffgridDriver(buildPlane45TwoMaterialsMesh(stepSize), opts).mesh();
+    Mesh m = OffgridMesher(buildPlane45TwoMaterialsMesh(stepSize), opts).mesh();
 
     VecD n = utils::Geometry::normal(
         utils::Geometry::asTriV(m.groups[0].elements[0], m.coordinates)
@@ -141,79 +141,79 @@ TEST_F(OffgridDriverTest, two_materials_with_no_overlap_same_as_one_material)
     }
 }
 
-TEST_F(OffgridDriverTest, plane45_size1_grid_adapted) 
+TEST_F(OffgridMesherTest, plane45_size1_grid_adapted) 
 {
-    OffgridDriver mesher(buildPlane45Mesh(1.0), buildAdaptedOptions());
+    OffgridMesher mesher(buildPlane45Mesh(1.0), buildAdaptedOptions());
     Mesh out;
     ASSERT_NO_THROW(out = mesher.mesh());
     EXPECT_EQ(2, out.groups[0].elements.size());
 }
 
-TEST_F(OffgridDriverTest, plane45_size1_grid_raw)
+TEST_F(OffgridMesherTest, plane45_size1_grid_raw)
 {
-    OffgridDriver mesher(buildPlane45Mesh(1.0), buildRawOptions());
+    OffgridMesher mesher(buildPlane45Mesh(1.0), buildRawOptions());
     Mesh out;
     ASSERT_NO_THROW(out = mesher.mesh());
     EXPECT_EQ(4, out.groups[0].elements.size());
 }
 
-TEST_F(OffgridDriverTest, tri_non_uniform_grid_adapted)
+TEST_F(OffgridMesherTest, tri_non_uniform_grid_adapted)
 {
     Mesh out;
-    ASSERT_NO_THROW(out = OffgridDriver(buildTriNonUniformGridMesh(), buildAdaptedOptions()).mesh());
+    ASSERT_NO_THROW(out = OffgridMesher(buildTriNonUniformGridMesh(), buildAdaptedOptions()).mesh());
 
     EXPECT_EQ(0, countRepeatedElements(out));
     EXPECT_EQ(27, out.groups[0].elements.size());
 }
 
-TEST_F(OffgridDriverTest, tri_non_uniform_grid_snapped)
+TEST_F(OffgridMesherTest, tri_non_uniform_grid_snapped)
 {
     auto opts = buildSnappedOptions();
     opts.snapperOptions.forbiddenLength = 0.25;
 
     Mesh out;
-    ASSERT_NO_THROW(out = OffgridDriver(buildTriNonUniformGridMesh(), opts).mesh());
+    ASSERT_NO_THROW(out = OffgridMesher(buildTriNonUniformGridMesh(), opts).mesh());
 
     EXPECT_EQ(0, countRepeatedElements(out));
     EXPECT_EQ(24, out.groups[0].elements.size());
 }
 
-TEST_F(OffgridDriverTest, tet_size1_grid_raw) 
+TEST_F(OffgridMesherTest, tet_size1_grid_raw) 
 {
-    OffgridDriver mesher(buildTetMesh(1.0), buildRawOptions());
+    OffgridMesher mesher(buildTetMesh(1.0), buildRawOptions());
     Mesh out;
     ASSERT_NO_THROW(out = mesher.mesh());
     EXPECT_EQ(4, out.groups[0].elements.size());
 }
-TEST_F(OffgridDriverTest, tet_size1_grid_adapted) 
+TEST_F(OffgridMesherTest, tet_size1_grid_adapted) 
 {
-    OffgridDriver mesher(buildTetMesh(1.0), buildAdaptedOptions());
+    OffgridMesher mesher(buildTetMesh(1.0), buildAdaptedOptions());
     Mesh out;
     ASSERT_NO_THROW(out = mesher.mesh());
     EXPECT_EQ(4, out.groups[0].elements.size());
 }
 
-TEST_F(OffgridDriverTest, bowtie_corner_size5_grid_raw)
+TEST_F(OffgridMesherTest, bowtie_corner_size5_grid_raw)
 {
-    OffgridDriver mesher(buildCornerBowtieMesh(5.0), buildRawOptions());
+    OffgridMesher mesher(buildCornerBowtieMesh(5.0), buildRawOptions());
     Mesh out;
     ASSERT_NO_THROW(out = mesher.mesh());
     EXPECT_EQ(6, countMeshElementsIf(out, isTriangle));
 }
 
-TEST_F(OffgridDriverTest, bowtie_corner_size5_grid_adapted)
+TEST_F(OffgridMesherTest, bowtie_corner_size5_grid_adapted)
 {
 
-    OffgridDriver mesher(buildCornerBowtieMesh(5.0), buildAdaptedOptions());
+    OffgridMesher mesher(buildCornerBowtieMesh(5.0), buildAdaptedOptions());
     Mesh out;
     ASSERT_NO_THROW(out = mesher.mesh());
     EXPECT_EQ(6, countMeshElementsIf(out, isTriangle));
 }
 
-TEST_F(OffgridDriverTest, plane45_size05_grid_adapted) 
+TEST_F(OffgridMesherTest, plane45_size05_grid_adapted) 
 {
  
-    OffgridDriver mesher(buildPlane45Mesh(0.5), buildAdaptedOptions());
+    OffgridMesher mesher(buildPlane45Mesh(0.5), buildAdaptedOptions());
     
     Mesh out;
 
@@ -221,9 +221,9 @@ TEST_F(OffgridDriverTest, plane45_size05_grid_adapted)
     EXPECT_EQ(8, out.groups[0].elements.size());
 }
 
-TEST_F(OffgridDriverTest, tets_sharing_edge_adapted)
+TEST_F(OffgridMesherTest, tets_sharing_edge_adapted)
 {
-    OffgridDriver mesher(buildTetsSharingEdgeMesh(), buildAdaptedOptions());
+    OffgridMesher mesher(buildTetsSharingEdgeMesh(), buildAdaptedOptions());
 
     {
         Mesh out;
@@ -231,10 +231,10 @@ TEST_F(OffgridDriverTest, tets_sharing_edge_adapted)
     }
 }
 
-TEST_F(OffgridDriverTest, plane45_size05_grid_raw)
+TEST_F(OffgridMesherTest, plane45_size05_grid_raw)
 {
 
-    OffgridDriver mesher(buildPlane45Mesh(0.5), buildRawOptions());
+    OffgridMesher mesher(buildPlane45Mesh(0.5), buildRawOptions());
 
     Mesh out;
 
@@ -242,9 +242,9 @@ TEST_F(OffgridDriverTest, plane45_size05_grid_raw)
     EXPECT_EQ(12, out.groups[0].elements.size());
 }
 
-TEST_F(OffgridDriverTest, plane45_size025_grid_adapted) {
+TEST_F(OffgridMesherTest, plane45_size025_grid_adapted) {
 
-    OffgridDriver mesher(buildPlane45Mesh(0.25), buildAdaptedOptions());
+    OffgridMesher mesher(buildPlane45Mesh(0.25), buildAdaptedOptions());
 
     Mesh out;
 
@@ -252,10 +252,10 @@ TEST_F(OffgridDriverTest, plane45_size025_grid_adapted) {
     EXPECT_EQ(32, countMeshElementsIf(out, isTriangle));
 }
 
-TEST_F(OffgridDriverTest, plane45_size025_grid_raw) 
+TEST_F(OffgridMesherTest, plane45_size025_grid_raw) 
 {
 
-    OffgridDriver mesher(buildPlane45Mesh(0.25), buildRawOptions());
+    OffgridMesher mesher(buildPlane45Mesh(0.25), buildRawOptions());
 
     Mesh out;
 
@@ -263,27 +263,27 @@ TEST_F(OffgridDriverTest, plane45_size025_grid_raw)
     EXPECT_EQ(40, countMeshElementsIf(out, isTriangle));
 }
 
-TEST_F(OffgridDriverTest, bowtie_two_triangles_adapted)
+TEST_F(OffgridMesherTest, bowtie_two_triangles_adapted)
 {
 
-    OffgridDriver mesher(buildTwoTrianglesFromBowtieCoarseMesh(), buildAdaptedOptions());
+    OffgridMesher mesher(buildTwoTrianglesFromBowtieCoarseMesh(), buildAdaptedOptions());
     
     Mesh out;
     Mesh dual;
     ASSERT_NO_THROW(out = mesher.mesh());
 }
 
-TEST_F(OffgridDriverTest, bowtie_subset_1_adapted)
+TEST_F(OffgridMesherTest, bowtie_subset_1_adapted)
 {
 
-    OffgridDriver mesher(buildBowtieSubset1Mesh(), buildAdaptedOptions());
+    OffgridMesher mesher(buildBowtieSubset1Mesh(), buildAdaptedOptions());
 
     Mesh out;
 
     ASSERT_NO_THROW(out = mesher.mesh());
 }
 
-TEST_F(OffgridDriverTest, tri) 
+TEST_F(OffgridMesherTest, tri) 
 {
 
     Mesh in;
@@ -307,10 +307,10 @@ TEST_F(OffgridDriverTest, tri)
         in = Mesh{ grid, coords, groups };
     }
     
-    OffgridDriverOptions opts;
+    OffgridMesherOptions opts;
     opts.snap = false;
 
-    OffgridDriver mesher(in, opts);
+    OffgridMesher mesher(in, opts);
 
     Mesh out;
     ASSERT_NO_THROW(out = mesher.mesh());
@@ -323,7 +323,7 @@ TEST_F(OffgridDriverTest, tri)
 
 }
 
-TEST_F(OffgridDriverTest, tri_dual)
+TEST_F(OffgridMesherTest, tri_dual)
 {
 
     Mesh in;
@@ -344,10 +344,10 @@ TEST_F(OffgridDriverTest, tri_dual)
         in = Mesh{ grid, coords, groups };
     }
 
-    OffgridDriverOptions opts;
+    OffgridMesherOptions opts;
     opts.snap = false;
 
-    OffgridDriver mesher(in, opts);
+    OffgridMesher mesher(in, opts);
     EXPECT_EQ(1, mesher.mesh().countElems());
 
     Filler d{ mesher.dualFill() };    
@@ -360,7 +360,7 @@ TEST_F(OffgridDriverTest, tri_dual)
     EXPECT_EQ(1, d.getEdgeFilling(CellIndex{ Cell{{1,1,0}}, Z }).lins[0].size());
 }
 
-TEST_F(OffgridDriverTest, smoother_generates_triangles_crossing_grid) 
+TEST_F(OffgridMesherTest, smoother_generates_triangles_crossing_grid) 
 {
     Mesh m;
     {
@@ -391,10 +391,10 @@ TEST_F(OffgridDriverTest, smoother_generates_triangles_crossing_grid)
     auto opts = buildAdaptedOptions();
         
     opts.decimalPlacesInCollapser = 0;
-    ASSERT_NO_THROW(OffgridDriver(m, opts).mesh());
+    ASSERT_NO_THROW(OffgridMesher(m, opts).mesh());
 }
 
-TEST_F(OffgridDriverTest, smoother_generates_triangles_crossing_grid_2)
+TEST_F(OffgridMesherTest, smoother_generates_triangles_crossing_grid_2)
 {
     Mesh m;
     {
@@ -421,10 +421,10 @@ TEST_F(OffgridDriverTest, smoother_generates_triangles_crossing_grid_2)
     auto opts = buildAdaptedOptions();
 
     opts.decimalPlacesInCollapser = 0;
-    ASSERT_NO_THROW(OffgridDriver(m, opts).mesh());
+    ASSERT_NO_THROW(OffgridMesher(m, opts).mesh());
 }
 
-TEST_F(OffgridDriverTest, smoother_generates_triangles_crossing_grid_3)
+TEST_F(OffgridMesherTest, smoother_generates_triangles_crossing_grid_3)
 {
     Mesh m;
     {
@@ -448,19 +448,19 @@ TEST_F(OffgridDriverTest, smoother_generates_triangles_crossing_grid_3)
     auto opts = buildAdaptedOptions();
 
     opts.decimalPlacesInCollapser = 2;
-    ASSERT_NO_THROW(OffgridDriver(m, opts).mesh());
+    ASSERT_NO_THROW(OffgridMesher(m, opts).mesh());
 }
 
-TEST_F(OffgridDriverTest, smoother_generates_triangles_crossing_grid_4)
+TEST_F(OffgridMesherTest, smoother_generates_triangles_crossing_grid_4)
 {
 
     auto opts = buildAdaptedOptions();
     opts.decimalPlacesInCollapser = 2;
     
-    ASSERT_NO_THROW(OffgridDriver(buildCylinderPatchMesh(), opts).mesh());
+    ASSERT_NO_THROW(OffgridMesher(buildCylinderPatchMesh(), opts).mesh());
 }
 
-TEST_F(OffgridDriverTest, smoother_generates_triangles_crossing_grid_5)
+TEST_F(OffgridMesherTest, smoother_generates_triangles_crossing_grid_5)
 {
     Mesh m;
     {
@@ -484,12 +484,12 @@ TEST_F(OffgridDriverTest, smoother_generates_triangles_crossing_grid_5)
     auto opts = buildAdaptedOptions();
     opts.decimalPlacesInCollapser = 1;
 
-    ASSERT_NO_THROW(OffgridDriver(m, opts).mesh());
+    ASSERT_NO_THROW(OffgridMesher(m, opts).mesh());
 }
 
-TEST_F(OffgridDriverTest, cube_1x1x1_volume_size_0c25_grid_raw)
+TEST_F(OffgridMesherTest, cube_1x1x1_volume_size_0c25_grid_raw)
 {
-    OffgridDriver mesher(buildCubeVolumeMesh(0.25), buildRawOptions());
+    OffgridMesher mesher(buildCubeVolumeMesh(0.25), buildRawOptions());
 
     Mesh out;
     ASSERT_NO_THROW(out = mesher.mesh());
@@ -497,48 +497,48 @@ TEST_F(OffgridDriverTest, cube_1x1x1_volume_size_0c25_grid_raw)
     EXPECT_EQ(192, countMeshElementsIf(out, isTriangle));
 }
 
-TEST_F(OffgridDriverTest, cube_1x1x1_volume_size_0c5_grid_raw)
+TEST_F(OffgridMesherTest, cube_1x1x1_volume_size_0c5_grid_raw)
 {
 
-    OffgridDriver mesher(buildCubeVolumeMesh(0.5), buildRawOptions());
+    OffgridMesher mesher(buildCubeVolumeMesh(0.5), buildRawOptions());
     Mesh out;
     ASSERT_NO_THROW(out = mesher.mesh());
     EXPECT_EQ(48, countMeshElementsIf(out, isTriangle));
 
 }
 
-TEST_F(OffgridDriverTest, cube_1x1x1_volume_size_1c0_grid_raw)
+TEST_F(OffgridMesherTest, cube_1x1x1_volume_size_1c0_grid_raw)
 {
     Mesh out;
-    ASSERT_NO_THROW(out = OffgridDriver(buildCubeVolumeMesh(1.0), buildRawOptions()).mesh());
+    ASSERT_NO_THROW(out = OffgridMesher(buildCubeVolumeMesh(1.0), buildRawOptions()).mesh());
     
     EXPECT_EQ(12, countMeshElementsIf(out, isTriangle));
 }
 
-TEST_F(OffgridDriverTest, cube_1x1x1_volume_size_1c0_grid_snapped)
+TEST_F(OffgridMesherTest, cube_1x1x1_volume_size_1c0_grid_snapped)
 {
     Mesh p;
 
-    OffgridDriver mesher(buildCubeVolumeMesh(1.0), buildSnappedOptions());
+    OffgridMesher mesher(buildCubeVolumeMesh(1.0), buildSnappedOptions());
     ASSERT_NO_THROW(p = mesher.mesh());
 
     EXPECT_EQ(12, countMeshElementsIf(p, isTriangle));
 }
 
-TEST_F(OffgridDriverTest, cube_1x1x1_surface_treat_as_volume)
+TEST_F(OffgridMesherTest, cube_1x1x1_surface_treat_as_volume)
 {
     Mesh p;
 
     auto opts{ buildSnappedOptions()};
     opts.volumeGroups = { 0 };
 
-    OffgridDriver mesher(buildCubeSurfaceMesh(1.0), opts);
+    OffgridMesher mesher(buildCubeSurfaceMesh(1.0), opts);
     ASSERT_NO_THROW(p = mesher.mesh());
     
     EXPECT_EQ(12, countMeshElementsIf(p, isTriangle));
 }
 
-TEST_F(OffgridDriverTest, slab_surface_treat_as_volume)
+TEST_F(OffgridMesherTest, slab_surface_treat_as_volume)
 {
 
     auto opts{ buildSnappedOptions() };
@@ -546,24 +546,24 @@ TEST_F(OffgridDriverTest, slab_surface_treat_as_volume)
     opts.volumeGroups = { 0 };
     
     Mesh p;
-    ASSERT_NO_THROW(p = OffgridDriver(buildSlabSurfaceMesh(1.0, 0.01), opts).mesh());
+    ASSERT_NO_THROW(p = OffgridMesher(buildSlabSurfaceMesh(1.0, 0.01), opts).mesh());
     
     EXPECT_EQ(4, countMeshElementsIf(p, isTriangle));
 }
 
-TEST_F(OffgridDriverTest, plane45_size1_grid)
+TEST_F(OffgridMesherTest, plane45_size1_grid)
 {
-    OffgridDriverOptions vOpts;
+    OffgridMesherOptions vOpts;
     vOpts.collapseInternalPoints = false;
     vOpts.snap = false;
 
     Mesh vMsh;
-    ASSERT_NO_THROW(vMsh = OffgridDriver(buildPlane45Mesh(1.0), vOpts).mesh());
+    ASSERT_NO_THROW(vMsh = OffgridMesher(buildPlane45Mesh(1.0), vOpts).mesh());
 }
 
-TEST_F(OffgridDriverTest, tet_size1_grid)
+TEST_F(OffgridMesherTest, tet_size1_grid)
 {
-    OffgridDriver mesher(buildTetMesh(1.0), OffgridDriverOptions ());
+    OffgridMesher mesher(buildTetMesh(1.0), OffgridMesherOptions ());
 
     Mesh msh;
     ASSERT_NO_THROW(msh = mesher.mesh());
@@ -571,9 +571,9 @@ TEST_F(OffgridDriverTest, tet_size1_grid)
     EXPECT_EQ(4, countMeshElementsIf(msh, isTriangle));
 }
 
-TEST_F(OffgridDriverTest, tet_with_inner_point_size1_grid)
+TEST_F(OffgridMesherTest, tet_with_inner_point_size1_grid)
 {
-    OffgridDriver mesher(buildTetMeshWithInnerPoint(1.0), OffgridDriverOptions());
+    OffgridMesher mesher(buildTetMeshWithInnerPoint(1.0), OffgridMesherOptions());
 
     Mesh msh;
     ASSERT_NO_THROW(msh = mesher.mesh());
@@ -581,9 +581,9 @@ TEST_F(OffgridDriverTest, tet_with_inner_point_size1_grid)
     EXPECT_EQ(4, countMeshElementsIf(msh, isTriangle));
 }
 
-TEST_F(OffgridDriverTest, elementsPartiallyOutOfGrid_bare)
+TEST_F(OffgridMesherTest, elementsPartiallyOutOfGrid_bare)
 {
-    OffgridDriver h{ buildTriPartiallyOutOfGridMesh(0.5), buildBareOptions() };
+    OffgridMesher h{ buildTriPartiallyOutOfGridMesh(0.5), buildBareOptions() };
      
     EXPECT_EQ(2, countMeshElementsIf(h.mesh(), isTriangle));
 
@@ -595,9 +595,9 @@ TEST_F(OffgridDriverTest, elementsPartiallyOutOfGrid_bare)
     EXPECT_TRUE(f.getFillingState({ Cell({ 3, 3, 1 }), Z }).partial());
 }
 
-TEST_F(OffgridDriverTest, elementsPartiallyOutOfGrid_raw)
+TEST_F(OffgridMesherTest, elementsPartiallyOutOfGrid_raw)
 {
-    OffgridDriver h{ buildTriPartiallyOutOfGridMesh(0.5), buildRawOptions() };
+    OffgridMesher h{ buildTriPartiallyOutOfGridMesh(0.5), buildRawOptions() };
 
     EXPECT_EQ(32, countMeshElementsIf(h.mesh(), isTriangle));
 
@@ -608,9 +608,9 @@ TEST_F(OffgridDriverTest, elementsPartiallyOutOfGrid_raw)
     EXPECT_TRUE(f.getFillingState({ Cell({ 3, 3, 1 }), Z }).partial());
 }
 
-TEST_F(OffgridDriverTest, elementsPartiallyOutOfGrid_dual_bare)
+TEST_F(OffgridMesherTest, elementsPartiallyOutOfGrid_dual_bare)
 {
-    OffgridDriver h{ buildTriPartiallyOutOfGridMesh(1.0), buildBareOptions() };
+    OffgridMesher h{ buildTriPartiallyOutOfGridMesh(1.0), buildBareOptions() };
 
     EXPECT_EQ(2, countMeshElementsIf(h.mesh(), isTriangle));
 
@@ -621,7 +621,7 @@ TEST_F(OffgridDriverTest, elementsPartiallyOutOfGrid_dual_bare)
     EXPECT_TRUE(df.getFillingState({ Cell({ 0, 1, 1 }), Z }).full());
 }
 
-TEST_F(OffgridDriverTest, elementsTotallyOutOfGrid)
+TEST_F(OffgridMesherTest, elementsTotallyOutOfGrid)
 {
     Mesh m = buildTriPartiallyOutOfGridMesh(1.0);
     m.coordinates = {
@@ -630,7 +630,7 @@ TEST_F(OffgridDriverTest, elementsTotallyOutOfGrid)
         Coordinate({ 70.0,  70.0,   70.0}),
     };
 
-    OffgridDriver h{ m };
+    OffgridMesher h{ m };
 
     EXPECT_EQ(0, countMeshElementsIf(h.mesh(), isTriangle));
 
@@ -638,7 +638,7 @@ TEST_F(OffgridDriverTest, elementsTotallyOutOfGrid)
     EXPECT_EQ(0, h.dualFill().getMeshFilling().countElems());
 }
 
-TEST_F(OffgridDriverTest, snapping_issue)
+TEST_F(OffgridMesherTest, snapping_issue)
 {
     Mesh m;
     m.grid =  buildProblematicTriMesh2().grid;
@@ -650,14 +650,14 @@ TEST_F(OffgridDriverTest, snapping_issue)
     m.groups = { Group{} };
     m.groups[0].elements = { {{0,1,2}} };
 
-    OffgridDriverOptions opts;
+    OffgridMesherOptions opts;
     opts.snapperOptions.edgePoints = 0;
     opts.snapperOptions.forbiddenLength = 0.1;
     
-    ASSERT_NO_THROW(OffgridDriver(m, opts).mesh());
+    ASSERT_NO_THROW(OffgridMesher(m, opts).mesh());
 }
 
-TEST_F(OffgridDriverTest, meshed_with_holes_issue)
+TEST_F(OffgridMesherTest, meshed_with_holes_issue)
 {
     Mesh m;
     m.grid = buildProblematicTriMesh2().grid;
@@ -670,7 +670,7 @@ TEST_F(OffgridDriverTest, meshed_with_holes_issue)
     m.groups[0].elements = { {{0,1,2}} };
 
     Mesh out;
-    ASSERT_NO_THROW(out = OffgridDriver(m, buildRawOptions()).mesh());
+    ASSERT_NO_THROW(out = OffgridMesher(m, buildRawOptions()).mesh());
 
     EXPECT_LT(374, countMeshElementsIf(out, isTriangle));
 }
diff --git a/test/drivers/StructuredDriverTest.cpp b/test/meshers/StructuredMesherTest.cpp
similarity index 92%
rename from test/drivers/StructuredDriverTest.cpp
rename to test/meshers/StructuredMesherTest.cpp
index cbb3aae..d863df2 100644
--- a/test/drivers/StructuredDriverTest.cpp
+++ b/test/meshers/StructuredMesherTest.cpp
@@ -1,19 +1,19 @@
 #include "gtest/gtest.h"
 #include "MeshFixtures.h"
 
-#include "drivers/StructuredDriver.h"
+#include "meshers/StructuredMesher.h"
 
 #include "utils/Geometry.h"
 #include "utils/GridTools.h"
 
-namespace meshlib::drivers {
+namespace meshlib::meshers {
 
 using namespace meshFixtures;
 using namespace utils;
 using namespace meshTools;
 
 
-class StructuredDriverTest : public ::testing::Test {
+class StructuredMesherTest : public ::testing::Test {
 public:
     static std::size_t countRepeatedElements(const Mesh& m)
     {
@@ -74,7 +74,7 @@ class StructuredDriverTest : public ::testing::Test {
     }
 };
 
-TEST_F(StructuredDriverTest, testStructuredLinesWithUniformGrid)
+TEST_F(StructuredMesherTest, testStructuredLinesWithUniformGrid)
 {
 
     float lowerCoordinateValue = -0.5;
@@ -123,7 +123,7 @@ TEST_F(StructuredDriverTest, testStructuredLinesWithUniformGrid)
     };
 
     Mesh resultMesh;
-    ASSERT_NO_THROW(resultMesh = StructuredDriver(inputMesh, 2).mesh());
+    ASSERT_NO_THROW(resultMesh = StructuredMesher(inputMesh, 2).mesh());
 
     EXPECT_EQ(0, countRepeatedElements(resultMesh));
 
@@ -131,7 +131,7 @@ TEST_F(StructuredDriverTest, testStructuredLinesWithUniformGrid)
 }
 
 
-TEST_F(StructuredDriverTest, testStructuredLinesWithRectilinearGrid)
+TEST_F(StructuredMesherTest, testStructuredLinesWithRectilinearGrid)
 {
     float lowerCoordinateValue = -0.5;
     float upperCoordinateValue = 0.5;
@@ -181,17 +181,17 @@ TEST_F(StructuredDriverTest, testStructuredLinesWithRectilinearGrid)
     };
 
     Mesh resultMesh;
-    ASSERT_NO_THROW(resultMesh = StructuredDriver(inputMesh, 2).mesh());
+    ASSERT_NO_THROW(resultMesh = StructuredMesher(inputMesh, 2).mesh());
 
     EXPECT_EQ(0, countRepeatedElements(resultMesh));
 
     assertMeshEqual(resultMesh, expectedMesh);
 }
 
-TEST_F(StructuredDriverTest, testTriNonUniformGridStructured)
+TEST_F(StructuredMesherTest, testTriNonUniformGridStructured)
 {
     Mesh out;
-    ASSERT_NO_THROW(out = StructuredDriver(buildTriNonUniformGridMesh(), 4).mesh());
+    ASSERT_NO_THROW(out = StructuredMesher(buildTriNonUniformGridMesh(), 4).mesh());
 
     EXPECT_EQ(0, countRepeatedElements(out));
     EXPECT_EQ(35, out.groups[0].elements.size());
@@ -202,7 +202,7 @@ TEST_F(StructuredDriverTest, testTriNonUniformGridStructured)
 
 
 
-TEST_F(StructuredDriverTest, DISABLED_testStructuredTriangleWithUniformGrid)
+TEST_F(StructuredMesherTest, DISABLED_testStructuredTriangleWithUniformGrid)
 {
 
     float lowerCoordinateValue = -0.5;
@@ -224,7 +224,7 @@ TEST_F(StructuredDriverTest, DISABLED_testStructuredTriangleWithUniformGrid)
     };
 
     Mesh resultMesh;
-    ASSERT_NO_THROW(resultMesh = StructuredDriver(inputMesh, 2).mesh());
+    ASSERT_NO_THROW(resultMesh = StructuredMesher(inputMesh, 2).mesh());
 
     EXPECT_EQ(0, countRepeatedElements(resultMesh));
     EXPECT_EQ(48, resultMesh.groups[0].elements.size());
diff --git a/vcpkg.json b/vcpkg.json
index 5912af1..d4ed077 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -8,7 +8,7 @@
   ],
   "features": {
     "cgal": {
-      "description": "Enables CGAL features: Offgrid Driver, manifolding, repairer, etc.",
+      "description": "Enables CGAL features: Offgrid mesher, manifolding, repairer, etc.",
       "dependencies": ["cgal", "eigen3"]
     }
   }