diff --git a/Isosurfacing_3/doc/Isosurfacing_3/Concepts/IsosurfacingDomain_3.h b/Isosurfacing_3/doc/Isosurfacing_3/Concepts/IsosurfacingDomain_3.h
index 2660e013ed9..085c12e9076 100644
--- a/Isosurfacing_3/doc/Isosurfacing_3/Concepts/IsosurfacingDomain_3.h
+++ b/Isosurfacing_3/doc/Isosurfacing_3/Concepts/IsosurfacingDomain_3.h
@@ -44,41 +44,41 @@ public:
   A descriptor that uniquely identifies a vertex.
   Must be a model of the concepts `DefaultConstructible`, `CopyConstructible`, and `Assignable`.
   */
-  typedef unspecified_type Vertex_descriptor;
+  typedef unspecified_type vertex_descriptor;
 
   /*!
   A descriptor that uniquely identifies an edge.
   Must be a model of the concepts `DefaultConstructible`, `CopyConstructible`, and `Assignable`.
   */
-  typedef unspecified_type Edge_descriptor;
+  typedef unspecified_type edge_descriptor;
 
   /*!
   A descriptor that uniquely identifies a cell.
   Must be a model of the concepts `DefaultConstructible`, `CopyConstructible`, and `Assignable`.
   */
-  typedef unspecified_type Cell_descriptor;
+  typedef unspecified_type cell_descriptor;
 
   /*!
   A container for the two vertices of an edge.
-  Must be a model of the concept `RandomAccessContainer` of size `2` whose value type is `Vertex_descriptor`.
+  Must be a model of the concept `RandomAccessContainer` of size `2` whose value type is `vertex_descriptor`.
   */
   typedef unspecified_type Vertices_incident_to_edge;
 
   /*!
   A container for the cells incident to an edge.
-  Must be a model of the concept `ForwardRange` whose value type is `Cell_descriptor`.
+  Must be a model of the concept `ForwardRange` whose value type is `cell_descriptor`.
   */
   typedef unspecified_type Cells_incident_to_edge;
 
   /*!
   A container for the vertices of a cell.
-  Must be a model of the concept `ForwardRange` whose value type is `Vertex_descriptor`.
+  Must be a model of the concept `ForwardRange` whose value type is `vertex_descriptor`.
   */
   typedef unspecified_type Cell_vertices;
 
   /*!
   A container for the edges of a cell.
-  Must be a model of the concept `ForwardRange` whose value type is `Edge_descriptor`.
+  Must be a model of the concept `ForwardRange` whose value type is `edge_descriptor`.
   */
   typedef unspecified_type Cell_edges;
 
@@ -97,7 +97,7 @@ public:
   /*!
   returns the 3D position of the vertex `v`.
   */
-  Point_3 point(const Vertex_descriptor& v) const;
+  Point_3 point(const vertex_descriptor& v) const;
 
   /*!
   returns the value of the values field at the point `p`.
@@ -107,34 +107,34 @@ public:
   /*!
   returns the value of the values field at the vertex `v`.
   */
-  FT value(const Vertex_descriptor& v) const;
+  FT value(const vertex_descriptor& v) const;
 
   /*!
   returns the two vertices incident to the edge `e`.
   */
-  Vertices_incident_to_edge incident_vertices(const Edge_descriptor& e) const;
+  Vertices_incident_to_edge incident_vertices(const edge_descriptor& e) const;
 
   /*!
   returns all the cells incident to the edge `e`, in a geometrically ordered manner around the edge.
   */
-  Cells_incident_to_edge incident_cells(const Edge_descriptor& e) const;
+  Cells_incident_to_edge incident_cells(const edge_descriptor& e) const;
 
   /*!
   returns all the vertices of the cell `c`.
   */
-  Cell_vertices cell_vertices(const Cell_descriptor& c) const;
+  Cell_vertices cell_vertices(const cell_descriptor& c) const;
 
   /*!
   returns all the edges of the cell `c`.
   */
-  Cell_edges cell_edges(const Cell_descriptor& c) const;
+  Cell_edges cell_edges(const cell_descriptor& c) const;
 
   /*!
   iterates over all vertices, and calls the functor `f` on each one.
 
   \tparam ConcurrencyTag decides if the vertices are iterated sequentially or in parallel.
   Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
-  \tparam Functor must implement `void operator()(const Vertex_descriptor& vertex)`
+  \tparam Functor must implement `void operator()(const vertex_descriptor& vertex)`
 
   \param f the functor called on every vertex
   */
@@ -146,7 +146,7 @@ public:
 
   \tparam ConcurrencyTag decides if the edges are iterated sequentially or in parallel.
   Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
-  \tparam Functor must implement `void operator()(const Edge_descriptor& edge)`.
+  \tparam Functor must implement `void operator()(const edge_descriptor& edge)`.
 
   \param f the functor called on every edge
   */
@@ -158,7 +158,7 @@ public:
 
   \tparam ConcurrencyTag decides if the cells are iterated sequentially or in parallel.
   Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
-  \tparam Functor must implement `void operator()(const Cell_descriptor& cell)`.
+  \tparam Functor must implement `void operator()(const cell_descriptor& cell)`.
 
   \param f the functor called on every cell
   */
diff --git a/Isosurfacing_3/doc/Isosurfacing_3/Concepts/IsosurfacingValueField_3.h b/Isosurfacing_3/doc/Isosurfacing_3/Concepts/IsosurfacingValueField_3.h
index 95ee7bbb9e1..39f9eda0a59 100644
--- a/Isosurfacing_3/doc/Isosurfacing_3/Concepts/IsosurfacingValueField_3.h
+++ b/Isosurfacing_3/doc/Isosurfacing_3/Concepts/IsosurfacingValueField_3.h
@@ -33,7 +33,7 @@ public:
   /*!
   * A descriptor that uniquely identifies a vertex (see `IsosurfacingPartition_3`).
   */
-  typedef unspecified_type Vertex_descriptor;
+  typedef unspecified_type vertex_descriptor;
 
   /*!
   returns the value of the value field at the point `p`.
@@ -43,5 +43,5 @@ public:
   /*!
   returns the value of the value field at the vertex `v`.
   */
-  FT operator()(const Vertex_descriptor& v);
+  FT operator()(const vertex_descriptor& v);
 };
diff --git a/Isosurfacing_3/doc/Isosurfacing_3/Concepts/partition_traits.h b/Isosurfacing_3/doc/Isosurfacing_3/Concepts/partition_traits.h
index 2d4446910c0..b0046d220de 100644
--- a/Isosurfacing_3/doc/Isosurfacing_3/Concepts/partition_traits.h
+++ b/Isosurfacing_3/doc/Isosurfacing_3/Concepts/partition_traits.h
@@ -21,73 +21,73 @@ public:
   /*!
    * A vertex descriptor corresponds to a unique vertex in an abstract partition instance.
    */
-  typedef unspecified_type Vertex_descriptor;
+  typedef unspecified_type vertex_descriptor;
 
   /*!
    * An edge descriptor corresponds to a unique edge in an abstract partition instance.
    */
-  typedef unspecified_type Edge_descriptor;
+  typedef unspecified_type edge_descriptor;
 
   /*!
    * A cell descriptor corresponds to a unique edge in an abstract partition instance.
    */
-  typedef unspecified_type Cell_descriptor;
+  typedef unspecified_type cell_descriptor;
 
   /*!
    * A container for the two vertices of an edge.
-   * Must be a model of `RandomAccessContainer` whose `value_type` must be `Vertex_descriptor`.
+   * Must be a model of `RandomAccessContainer` whose `value_type` must be `vertex_descriptor`.
    */
   typedef unspecified_type Vertices_incident_to_edge;
 
   /*!
    * A container for the cells incident to an edge.
-   * Must be a model of `ForwardRange` whose `value_type` must be `Cell_descriptor`.
+   * Must be a model of `ForwardRange` whose `value_type` must be `cell_descriptor`.
    */
   typedef unspecified_type Cells_incident_to_edge;
 
   /*!
    * A container for the vertices of a cell.
-   * Must be a model of `ForwardRange` whose `value_type` must be `Vertex_descriptor`.
+   * Must be a model of `ForwardRange` whose `value_type` must be `vertex_descriptor`.
    */
   typedef unspecified_type Cell_vertices;
 
   /*!
    * A container for the edges of a cell.
-   * Must be a model of `ForwardRange` whose `value_type` must be `Edge_descriptor`.
+   * Must be a model of `ForwardRange` whose `value_type` must be `edge_descriptor`.
    */
   typedef unspecified_type Cell_edges;
 
   /*!
    * \returns the 3D position of the vertex `v`.
    */
-  static Point_3 point(const Vertex_descriptor& v, const IsosurfacingPartition_3& partition);
+  static Point_3 point(const vertex_descriptor& v, const IsosurfacingPartition_3& partition);
 
   /*!
    * \returns the two vertices incident to the edge `e`.
    */
-  static Vertices_incident_to_edge incident_vertices(const Edge_descriptor& e, const IsosurfacingPartition_3& partition);
+  static Vertices_incident_to_edge incident_vertices(const edge_descriptor& e, const IsosurfacingPartition_3& partition);
 
   /*!
    * \returns all the cells incident to the edge `e`, in a geometrically ordered manner around the edge.
    */
-  static Cells_incident_to_edge incident_cells(const Edge_descriptor& e, const IsosurfacingPartition_3& partition);
+  static Cells_incident_to_edge incident_cells(const edge_descriptor& e, const IsosurfacingPartition_3& partition);
 
   /*!
    * \returns all the vertices of the cell `c`.
    */
-  static Cell_vertices cell_vertices(const Cell_descriptor& c, const IsosurfacingPartition_3& partition);
+  static Cell_vertices cell_vertices(const cell_descriptor& c, const IsosurfacingPartition_3& partition);
 
   /*!
    * \returns all the edges of the cell `c`.
    */
-  static Cell_edges cell_edges(const Cell_descriptor& c, const IsosurfacingPartition_3& partition);
+  static Cell_edges cell_edges(const cell_descriptor& c, const IsosurfacingPartition_3& partition);
 
   /*!
    * iterates over all vertices, and calls the functor `f` on each one.
    *
    * \tparam ConcurrencyTag decides if the vertices are iterated sequentially or in parallel.
    * Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
-   * \tparam Functor must implement `void operator()(const Vertex_descriptor& vertex)`
+   * \tparam Functor must implement `void operator()(const vertex_descriptor& vertex)`
    *
    * \param f the functor called on every vertex
    * \param partition the partition whose vertices are being iterated
@@ -100,7 +100,7 @@ public:
    *
    * \tparam ConcurrencyTag decides if the edges are iterated sequentially or in parallel.
    * Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
-   * \tparam Functor must implement `void operator()(const Edge_descriptor& edge)`.
+   * \tparam Functor must implement `void operator()(const edge_descriptor& edge)`.
    *
    * \param f the functor called on every edge
    * \param partition the partition whose edges are being iterated
@@ -113,7 +113,7 @@ public:
    *
    * \tparam ConcurrencyTag decides if the cells are iterated sequentially or in parallel.
    * Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
-   * \tparam Functor must implement `void operator()(const Cell_descriptor& cell)`.
+   * \tparam Functor must implement `void operator()(const cell_descriptor& cell)`.
    *
    * \param f the functor called on every cell
    * \param partition the partition whose cells are being iterated
diff --git a/Isosurfacing_3/include/CGAL/Isosurfacing_3/Gradient_function_3.h b/Isosurfacing_3/include/CGAL/Isosurfacing_3/Gradient_function_3.h
index c7eca506b70..1223367685e 100644
--- a/Isosurfacing_3/include/CGAL/Isosurfacing_3/Gradient_function_3.h
+++ b/Isosurfacing_3/include/CGAL/Isosurfacing_3/Gradient_function_3.h
@@ -43,7 +43,7 @@ public:
   using Vector_3 = typename Geom_traits::Vector_3;
 
   using PT = partition_traits<Partition>;
-  using Vertex_descriptor = typename PT::Vertex_descriptor;
+  using vertex_descriptor = typename PT::vertex_descriptor;
 
 private:
   std::function<Vector_3(const Point_3&)> m_fn;
@@ -78,7 +78,7 @@ public:
   /**
    * \brief evaluates the function at the vertex `v`.
    */
-  const Vector_3& operator()(const Vertex_descriptor& v) const
+  const Vector_3& operator()(const vertex_descriptor& v) const
   {
     return this->operator()(PT::point(v, m_partition));
   }
diff --git a/Isosurfacing_3/include/CGAL/Isosurfacing_3/Interpolated_discrete_gradients_3.h b/Isosurfacing_3/include/CGAL/Isosurfacing_3/Interpolated_discrete_gradients_3.h
index ddcac46293d..9546b79ce2f 100644
--- a/Isosurfacing_3/include/CGAL/Isosurfacing_3/Interpolated_discrete_gradients_3.h
+++ b/Isosurfacing_3/include/CGAL/Isosurfacing_3/Interpolated_discrete_gradients_3.h
@@ -43,7 +43,7 @@ class Interpolated_discrete_gradients_3
   using Point_3 = typename Geom_traits::Point_3;
   using Vector_3 = typename Geom_traits::Vector_3;
 
-  using Vertex_descriptor = typename partition_traits<Grid>::Vertex_descriptor;
+  using vertex_descriptor = typename partition_traits<Grid>::vertex_descriptor;
 
 private:
   const Grid& m_grid;
diff --git a/Isosurfacing_3/include/CGAL/Isosurfacing_3/Interpolated_discrete_values_3.h b/Isosurfacing_3/include/CGAL/Isosurfacing_3/Interpolated_discrete_values_3.h
index 45a3257d4b6..e6e6fa34a0c 100644
--- a/Isosurfacing_3/include/CGAL/Isosurfacing_3/Interpolated_discrete_values_3.h
+++ b/Isosurfacing_3/include/CGAL/Isosurfacing_3/Interpolated_discrete_values_3.h
@@ -43,7 +43,7 @@ class Interpolated_discrete_values_3
   using FT = typename Geom_traits::FT;
   using Point_3 = typename Geom_traits::Point_3;
 
-  using Vertex_descriptor = typename partition_traits<Grid>::Vertex_descriptor;
+  using vertex_descriptor = typename partition_traits<Grid>::vertex_descriptor;
 
 private:
   const Grid& m_grid;
@@ -102,7 +102,7 @@ public:
   /*!
    * returns the value at vertex `v`.
    */
-  FT operator()(const Vertex_descriptor& v) const
+  FT operator()(const vertex_descriptor& v) const
   {
     return this->operator()(v[0], v[1], v[2]);
   }
diff --git a/Isosurfacing_3/include/CGAL/Isosurfacing_3/Value_function_3.h b/Isosurfacing_3/include/CGAL/Isosurfacing_3/Value_function_3.h
index 20c8148321d..8fc9d1b77a9 100644
--- a/Isosurfacing_3/include/CGAL/Isosurfacing_3/Value_function_3.h
+++ b/Isosurfacing_3/include/CGAL/Isosurfacing_3/Value_function_3.h
@@ -44,7 +44,7 @@ public:
   using Point_3 = typename Geom_traits::Point_3;
 
   using PT = partition_traits<Partition>;
-  using Vertex_descriptor = typename PT::Vertex_descriptor;
+  using vertex_descriptor = typename PT::vertex_descriptor;
 
 private:
   std::function<FT(const Point_3&)> m_fn;
@@ -79,7 +79,7 @@ public:
   /**
    * \brief evaluates the function at the vertex `v`
    */
-  FT operator()(const Vertex_descriptor& v) const
+  FT operator()(const vertex_descriptor& v) const
   {
     return this->operator()(PT::point(v, m_partition));
   }
diff --git a/Isosurfacing_3/include/CGAL/Isosurfacing_3/edge_intersection_oracles_3.h b/Isosurfacing_3/include/CGAL/Isosurfacing_3/edge_intersection_oracles_3.h
index 070e66f82c9..ff0f4832ef9 100644
--- a/Isosurfacing_3/include/CGAL/Isosurfacing_3/edge_intersection_oracles_3.h
+++ b/Isosurfacing_3/include/CGAL/Isosurfacing_3/edge_intersection_oracles_3.h
@@ -188,7 +188,7 @@ struct Linear_interpolation_edge_intersection
 struct Ray_marching_edge_intersection
 {
   template <typename Domain>
-  bool operator()(const typename Domain::Edge_descriptor& e,
+  bool operator()(const typename Domain::edge_descriptor& e,
                   const Domain& domain,
                   const typename Domain::Geom_traits::FT isovalue,
                   typename Domain::Geom_traits::Point_3& p) const
diff --git a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/Isosurfacing_domain_3.h b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/Isosurfacing_domain_3.h
index 26e12cdcea7..198ca4f2a20 100644
--- a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/Isosurfacing_domain_3.h
+++ b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/Isosurfacing_domain_3.h
@@ -46,9 +46,9 @@ public:
 
   using PT = CGAL::Isosurfacing::partition_traits<Partition>;
 
-  using Vertex_descriptor = typename PT::Vertex_descriptor;
-  using Edge_descriptor = typename PT::Edge_descriptor;
-  using Cell_descriptor = typename PT::Cell_descriptor;
+  using vertex_descriptor = typename PT::vertex_descriptor;
+  using edge_descriptor = typename PT::edge_descriptor;
+  using cell_descriptor = typename PT::cell_descriptor;
 
   using Vertices_incident_to_edge = typename PT::Vertices_incident_to_edge;
   using Cells_incident_to_edge = typename PT::Cells_incident_to_edge;
@@ -90,13 +90,13 @@ public:
   // The following functions are dispatching to the partition_traits' static functions.
 
   // returns the position of vertex `v`
-  decltype(auto) /*Point_3*/ point(const Vertex_descriptor& v) const
+  decltype(auto) /*Point_3*/ point(const vertex_descriptor& v) const
   {
     return PT::point(v, m_partition);
   }
 
   // returns the value of the function at vertex `v`
-  decltype(auto) /*FT*/ value(const Vertex_descriptor& v) const
+  decltype(auto) /*FT*/ value(const vertex_descriptor& v) const
   {
     return m_values(v);
   }
@@ -114,25 +114,25 @@ public:
   }
 
   // returns a container with the two vertices incident to the edge `e`
-  decltype(auto) /*Vertices_incident_to_edge*/ incident_vertices(const Edge_descriptor& e) const
+  decltype(auto) /*Vertices_incident_to_edge*/ incident_vertices(const edge_descriptor& e) const
   {
     return PT::incident_vertices(e, m_partition);
   }
 
   // returns a container with all cells incident to the edge `e`
-  decltype(auto) /*Cells_incident_to_edge*/ incident_cells(const Edge_descriptor& e) const
+  decltype(auto) /*Cells_incident_to_edge*/ incident_cells(const edge_descriptor& e) const
   {
     return PT::incident_cells(e, m_partition);
   }
 
   // returns a container with all vertices of the cell `c`
-  decltype(auto) /*Cell_vertices*/ cell_vertices(const Cell_descriptor& c) const
+  decltype(auto) /*Cell_vertices*/ cell_vertices(const cell_descriptor& c) const
   {
     return PT::cell_vertices(c, m_partition);
   }
 
   // returns a container with all edges of the cell `c`
-  decltype(auto) /*Cell_edges*/ cell_edges(const Cell_descriptor& c) const
+  decltype(auto) /*Cell_edges*/ cell_edges(const cell_descriptor& c) const
   {
     return PT::cell_edges(c, m_partition);
   }
diff --git a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/dual_contouring_functors.h b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/dual_contouring_functors.h
index f0a94195c5a..5bdfa8670d1 100644
--- a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/dual_contouring_functors.h
+++ b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/dual_contouring_functors.h
@@ -48,7 +48,7 @@ template <typename Domain,
           typename EdgeToPointIDMap,
           typename PointRange,
           typename GradientRange>
-bool cell_position_QEM(const typename Domain::Cell_descriptor& c,
+bool cell_position_QEM(const typename Domain::cell_descriptor& c,
                        const Domain& domain,
                        const bool constrain_to_cell,
                        const EdgeToPointIDMap& edge_to_point_id,
@@ -203,7 +203,7 @@ template <typename Domain,
           typename EdgeToPointIDMap,
           typename CellToPointIDMap,
           typename PolygonRange>
-void generate_face(const typename Domain::Edge_descriptor& e,
+void generate_face(const typename Domain::edge_descriptor& e,
                    const Domain& domain,
                    const typename Domain::Geom_traits::FT isovalue,
                    const bool do_not_triangulate_faces,
@@ -214,7 +214,7 @@ void generate_face(const typename Domain::Edge_descriptor& e,
 {
   using FT = typename Domain::Geom_traits::FT;
 
-  using Cell_descriptor = typename Domain::Cell_descriptor;
+  using cell_descriptor = typename Domain::cell_descriptor;
 
   const auto& vertices = domain.incident_vertices(e);
 
@@ -227,7 +227,7 @@ void generate_face(const typename Domain::Edge_descriptor& e,
   std::vector<std::size_t> vertex_ids;
 
   const auto& icells = domain.incident_cells(e);
-  for(const Cell_descriptor& c : icells)
+  for(const cell_descriptor& c : icells)
   {
     auto it = cell_to_point_id.find(c);
     if(it == cell_to_point_id.end())
@@ -293,9 +293,9 @@ class Dual_contourer<ConcurrencyTag, Domain, DC_Strategy::QEM>
   using Point_3 = typename Geom_traits::Point_3;
   using Vector_3 = typename Geom_traits::Vector_3;
 
-  using Vertex_descriptor = typename Domain::Vertex_descriptor;
-  using Edge_descriptor = typename Domain::Edge_descriptor;
-  using Cell_descriptor = typename Domain::Cell_descriptor;
+  using vertex_descriptor = typename Domain::vertex_descriptor;
+  using edge_descriptor = typename Domain::edge_descriptor;
+  using cell_descriptor = typename Domain::cell_descriptor;
 
   std::mutex m_mutex;
 
@@ -319,8 +319,8 @@ public:
     const bool do_not_triangulate_faces =
       choose_parameter(get_parameter(np, internal_np::do_not_triangulate_faces), false);
 
-    using Edge_to_point_ID_map = std::unordered_map<Edge_descriptor, std::size_t>;
-    using Cell_to_point_ID_map = std::unordered_map<Cell_descriptor, std::size_t>;
+    using Edge_to_point_ID_map = std::unordered_map<edge_descriptor, std::size_t>;
+    using Cell_to_point_ID_map = std::unordered_map<cell_descriptor, std::size_t>;
 
     Edge_to_point_ID_map edge_to_point_id;
     Cell_to_point_ID_map cell_to_point_id;
@@ -330,11 +330,11 @@ public:
 
     // ---------------------------------------------------------------------------------------------
     // construct the intersection of the surface at active edges
-    auto edge_positioner = [&](const Edge_descriptor& e)
+    auto edge_positioner = [&](const edge_descriptor& e)
     {
       const auto& evs = domain.incident_vertices(e);
-      const Vertex_descriptor& v0 = evs[0];
-      const Vertex_descriptor& v1 = evs[1];
+      const vertex_descriptor& v0 = evs[0];
+      const vertex_descriptor& v1 = evs[1];
       const Point_3& p0 = domain.point(v0);
       const Point_3& p1 = domain.point(v1);
       const FT val0 = domain.value(v0);
@@ -362,10 +362,10 @@ public:
     std::ofstream out_active_edges("active_edges.polylines");
     for(const auto& ei : edge_to_point_id)
     {
-      const Edge_descriptor& e = ei.first;
+      const edge_descriptor& e = ei.first;
       const auto& evs = domain.incident_vertices(e);
-      const Vertex_descriptor& v0 = evs[0];
-      const Vertex_descriptor& v1 = evs[1];
+      const vertex_descriptor& v0 = evs[0];
+      const vertex_descriptor& v1 = evs[1];
       const Point_3& p0 = domain.point(v0);
       const Point_3& p1 = domain.point(v1);
 
@@ -387,7 +387,7 @@ public:
 
     // ---------------------------------------------------------------------------------------------
     // create a vertex for each cell that has at least one active edge
-    auto cell_positioner = [&](const Cell_descriptor& c)
+    auto cell_positioner = [&](const cell_descriptor& c)
     {
       Point_3 p;
       if(cell_position_QEM(c, domain, constrain_to_cell, edge_to_point_id,
@@ -402,7 +402,7 @@ public:
 
     // ---------------------------------------------------------------------------------------------
     // connect vertices around edges to form faces
-    auto face_generator = [&](const Edge_descriptor& e)
+    auto face_generator = [&](const edge_descriptor& e)
     {
       generate_face(e, domain, isovalue, do_not_triangulate_faces,
                     edge_to_point_id, cell_to_point_id, m_mutex, polygons);
@@ -425,9 +425,9 @@ class Dual_contourer<ConcurrencyTag, Domain, DC_Strategy::Centroid_of_edge_inter
   using Point_3 = typename Geom_traits::Point_3;
   using Vector_3 = typename Geom_traits::Vector_3;
 
-  using Vertex_descriptor = typename Domain::Vertex_descriptor;
-  using Edge_descriptor = typename Domain::Edge_descriptor;
-  using Cell_descriptor = typename Domain::Cell_descriptor;
+  using vertex_descriptor = typename Domain::vertex_descriptor;
+  using edge_descriptor = typename Domain::edge_descriptor;
+  using cell_descriptor = typename Domain::cell_descriptor;
 
   std::mutex m_mutex;
 
@@ -449,8 +449,8 @@ public:
     bool do_not_triangulate_faces =
       choose_parameter(get_parameter(np, internal_np::do_not_triangulate_faces), false);
 
-    using Edge_to_point_ID_map = std::unordered_map<Edge_descriptor, std::size_t>;
-    using Cell_to_point_ID_map = std::unordered_map<Cell_descriptor, std::size_t>;
+    using Edge_to_point_ID_map = std::unordered_map<edge_descriptor, std::size_t>;
+    using Cell_to_point_ID_map = std::unordered_map<cell_descriptor, std::size_t>;
 
     Edge_to_point_ID_map edge_to_point_id;
     Cell_to_point_ID_map cell_to_point_id;
@@ -458,11 +458,11 @@ public:
     std::vector<Point_3> edge_points;
 
     // ---------------------------------------------------------------------------------------------
-    auto edge_positioner = [&](const Edge_descriptor& e)
+    auto edge_positioner = [&](const edge_descriptor& e)
     {
       const auto& evs = domain.incident_vertices(e);
-      const Vertex_descriptor& v0 = evs[0];
-      const Vertex_descriptor& v1 = evs[1];
+      const vertex_descriptor& v0 = evs[0];
+      const vertex_descriptor& v1 = evs[1];
       const Point_3& p0 = domain.point(v0);
       const Point_3& p1 = domain.point(v1);
       const FT val0 = domain.value(v0);
@@ -483,7 +483,7 @@ public:
       points.insert(points.end(), edge_points.begin(), edge_points.end());
 
     // ---------------------------------------------------------------------------------------------
-    auto cell_positioner = [&](const Cell_descriptor& c)
+    auto cell_positioner = [&](const cell_descriptor& c)
     {
       typename Geom_traits::Compute_x_3 x_coord = domain.geom_traits().compute_x_3_object();
       typename Geom_traits::Compute_y_3 y_coord = domain.geom_traits().compute_y_3_object();
@@ -492,7 +492,7 @@ public:
 
       // compute edge intersections
       std::vector<Point_3> edge_intersections;
-      for(const Edge_descriptor& e : domain.cell_edges(c))
+      for(const edge_descriptor& e : domain.cell_edges(c))
       {
         const auto it = edge_to_point_id.find(e);
         if(it == edge_to_point_id.end())
@@ -522,7 +522,7 @@ public:
     domain.template for_each_cell<ConcurrencyTag>(cell_positioner);
 
     // ---------------------------------------------------------------------------------------------
-    auto face_generator = [&](const Edge_descriptor& e)
+    auto face_generator = [&](const edge_descriptor& e)
     {
       generate_face(e, domain, isovalue, do_not_triangulate_faces,
                     edge_to_point_id, cell_to_point_id, m_mutex, polygons);
@@ -540,9 +540,9 @@ class Dual_contourer<ConcurrencyTag, Domain, DC_Strategy::Cell_center>
   using Point_3 = typename Geom_traits::Point_3;
   using Vector_3 = typename Geom_traits::Vector_3;
 
-  using Vertex_descriptor = typename Domain::Vertex_descriptor;
-  using Edge_descriptor = typename Domain::Edge_descriptor;
-  using Cell_descriptor = typename Domain::Cell_descriptor;
+  using vertex_descriptor = typename Domain::vertex_descriptor;
+  using edge_descriptor = typename Domain::edge_descriptor;
+  using cell_descriptor = typename Domain::cell_descriptor;
 
   std::mutex m_mutex;
 
@@ -564,8 +564,8 @@ public:
     bool do_not_triangulate_faces =
       choose_parameter(get_parameter(np, internal_np::do_not_triangulate_faces), false);
 
-    using Edge_to_point_ID_map = std::unordered_map<Edge_descriptor, std::size_t>;
-    using Cell_to_point_ID_map = std::unordered_map<Cell_descriptor, std::size_t>;
+    using Edge_to_point_ID_map = std::unordered_map<edge_descriptor, std::size_t>;
+    using Cell_to_point_ID_map = std::unordered_map<cell_descriptor, std::size_t>;
 
     Edge_to_point_ID_map edge_to_point_id;
     Cell_to_point_ID_map cell_to_point_id;
@@ -573,7 +573,7 @@ public:
     std::vector<Point_3> edge_points;
 
     // ---------------------------------------------------------------------------------------------
-    auto edge_positioner = [&](const Edge_descriptor& e)
+    auto edge_positioner = [&](const edge_descriptor& e)
     {
       typename Geom_traits::Compute_x_3 x_coord = domain.geom_traits().compute_x_3_object();
       typename Geom_traits::Compute_y_3 y_coord = domain.geom_traits().compute_y_3_object();
@@ -581,8 +581,8 @@ public:
       typename Geom_traits::Construct_point_3 point = domain.geom_traits().construct_point_3_object();
 
       const auto& evs = domain.incident_vertices(e);
-      const Vertex_descriptor& v0 = evs[0];
-      const Vertex_descriptor& v1 = evs[1];
+      const vertex_descriptor& v0 = evs[0];
+      const vertex_descriptor& v1 = evs[1];
 
       const FT val_0 = domain.value(v0);
       const FT val_1 = domain.value(v1);
@@ -603,7 +603,7 @@ public:
       points.insert(points.end(), edge_points.begin(), edge_points.end());
 
     // ---------------------------------------------------------------------------------------------
-    auto cell_positioner = [&](const Cell_descriptor& c)
+    auto cell_positioner = [&](const cell_descriptor& c)
     {
       typename Geom_traits::Compute_x_3 x_coord = domain.geom_traits().compute_x_3_object();
       typename Geom_traits::Compute_y_3 y_coord = domain.geom_traits().compute_y_3_object();
@@ -644,7 +644,7 @@ public:
     domain.template for_each_cell<ConcurrencyTag>(cell_positioner);
 
     // ---------------------------------------------------------------------------------------------
-    auto face_generator = [&](const Edge_descriptor& e)
+    auto face_generator = [&](const edge_descriptor& e)
     {
       generate_face(e, domain, isovalue, do_not_triangulate_faces,
                     edge_to_point_id, cell_to_point_id, m_mutex, polygons);
diff --git a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/marching_cubes_functors.h b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/marching_cubes_functors.h
index 58f537a9cdf..1767c01da2c 100644
--- a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/marching_cubes_functors.h
+++ b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/marching_cubes_functors.h
@@ -103,19 +103,19 @@ template <typename Domain,
           typename Corners,
           typename Values>
 std::size_t get_cell_corners(const Domain& domain,
-                             const typename Domain::Cell_descriptor& cell,
+                             const typename Domain::cell_descriptor& cell,
                              const typename Domain::Geom_traits::FT isovalue,
                              Corners& corners,
                              Values& values)
 {
-  using Vertex_descriptor = typename Domain::Vertex_descriptor;
+  using vertex_descriptor = typename Domain::vertex_descriptor;
 
   const auto& vertices = domain.cell_vertices(cell);
 
   // collect function values and build index
   std::size_t v_id = 0;
   std::bitset<Domain::VERTICES_PER_CELL> index = 0;
-  for(const Vertex_descriptor& v : vertices)
+  for(const vertex_descriptor& v : vertices)
   {
     values[v_id] = domain.value(v);
     if(values[v_id] >= isovalue)
@@ -128,7 +128,7 @@ std::size_t get_cell_corners(const Domain& domain,
     return static_cast<std::size_t>(index.to_ullong());
 
   v_id = 0;
-  for(const Vertex_descriptor& v : vertices)
+  for(const vertex_descriptor& v : vertices)
     corners[v_id++] = domain.point(v);
 
   return static_cast<std::size_t>(index.to_ullong());
@@ -139,7 +139,7 @@ template <typename Corners,
           typename Values,
           typename Domain,
           typename Vertices>
-void MC_construct_vertices(const typename Domain::Cell_descriptor& cell,
+void MC_construct_vertices(const typename Domain::cell_descriptor& cell,
                            const std::size_t i_case,
                            const Corners& corners,
                            const Values& values,
@@ -148,7 +148,7 @@ void MC_construct_vertices(const typename Domain::Cell_descriptor& cell,
                            Vertices& vertices)
 {
   using Cell_edges = typename Domain::Cell_edges;
-  using Edge_descriptor = typename Domain::Edge_descriptor;
+  using edge_descriptor = typename Domain::edge_descriptor;
 
   const Cell_edges& cell_edges = domain.cell_edges(cell);
 
@@ -156,7 +156,7 @@ void MC_construct_vertices(const typename Domain::Cell_descriptor& cell,
   std::size_t flag = 1;
   std::size_t e_id = 0;
 
-  for(const Edge_descriptor& e : cell_edges)
+  for(const edge_descriptor& e : cell_edges)
   {
     CGAL_USE(e);
 
@@ -253,7 +253,7 @@ public:
   using FT = typename Geom_traits::FT;
   using Point_3 = typename Geom_traits::Point_3;
 
-  using Cell_descriptor = typename Domain::Cell_descriptor;
+  using cell_descriptor = typename Domain::cell_descriptor;
 
 #ifdef CGAL_LINKED_WITH_TBB
   using Triangles = tbb::enumerable_thread_specific<std::vector<std::array<Point_3, 3>>>;
@@ -283,7 +283,7 @@ public:
 
 public:
   // computes one cell
-  void operator()(const Cell_descriptor& cell)
+  void operator()(const cell_descriptor& cell)
   {
     CGAL_precondition(m_domain.cell_vertices(cell).size() == 8);
     CGAL_precondition(m_domain.cell_edges(cell).size() == 12);
diff --git a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/partition_traits_Cartesian_grid.h b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/partition_traits_Cartesian_grid.h
index 322a75d5a56..01fea948b70 100644
--- a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/partition_traits_Cartesian_grid.h
+++ b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/partition_traits_Cartesian_grid.h
@@ -48,31 +48,31 @@ struct partition_traits<Cartesian_grid_3<GeomTraits, MemoryPolicy> >
   using Grid = Cartesian_grid_3<GeomTraits, MemoryPolicy>;
 
   // identifies a vertex by its (i, j, k) indices
-  using Vertex_descriptor = std::array<std::size_t, 3>;
+  using vertex_descriptor = std::array<std::size_t, 3>;
 
   // identifies an edge by its starting vertex (i, j, k) and the direction x -> 0, y -> 1, z -> 2
-  using Edge_descriptor = CG_Edge_descriptor;
+  using edge_descriptor = CG_Edge_descriptor;
 
   // identifies a cell by its corner vertex with the smallest (i, j, k) index
-  using Cell_descriptor = CG_Cell_descriptor;
+  using cell_descriptor = CG_Cell_descriptor;
 
   static constexpr Cell_type CELL_TYPE = CUBICAL_CELL;
   static constexpr std::size_t VERTICES_PER_CELL = 8;
   static constexpr std::size_t EDGES_PER_CELL = 12;
 
-  using Vertices_incident_to_edge = std::array<Vertex_descriptor, 2>;
-  using Cells_incident_to_edge = std::array<Cell_descriptor, 4>;
-  using Cell_vertices = std::array<Vertex_descriptor, VERTICES_PER_CELL>;
-  using Cell_edges = std::array<Edge_descriptor, EDGES_PER_CELL>;
+  using Vertices_incident_to_edge = std::array<vertex_descriptor, 2>;
+  using Cells_incident_to_edge = std::array<cell_descriptor, 4>;
+  using Cell_vertices = std::array<vertex_descriptor, VERTICES_PER_CELL>;
+  using Cell_edges = std::array<edge_descriptor, EDGES_PER_CELL>;
 
-  static decltype(auto) /*Point_3*/ point(const Vertex_descriptor& v,
+  static decltype(auto) /*Point_3*/ point(const vertex_descriptor& v,
                                           const Grid& g)
   {
     return g.point(v[0], v[1], v[2]);
   }
 
   // returns a container with the two vertices incident to edge e
-  static Vertices_incident_to_edge incident_vertices(const Edge_descriptor& e,
+  static Vertices_incident_to_edge incident_vertices(const edge_descriptor& e,
                                                      const Grid&)
   {
     Vertices_incident_to_edge ev;
@@ -83,7 +83,7 @@ struct partition_traits<Cartesian_grid_3<GeomTraits, MemoryPolicy> >
   }
 
   // returns a container with all cells incident to edge e
-  static Cells_incident_to_edge incident_cells(const Edge_descriptor& e,
+  static Cells_incident_to_edge incident_cells(const edge_descriptor& e,
                                                const Grid&)
   {
     // lookup the neighbor cells relative to the edge
@@ -103,7 +103,7 @@ struct partition_traits<Cartesian_grid_3<GeomTraits, MemoryPolicy> >
   }
 
   // returns a container with all vertices of cell c
-  static Cell_vertices cell_vertices(const Cell_descriptor& c,
+  static Cell_vertices cell_vertices(const cell_descriptor& c,
                                      const Grid&)
   {
     Cell_vertices cv;
@@ -119,7 +119,7 @@ struct partition_traits<Cartesian_grid_3<GeomTraits, MemoryPolicy> >
   }
 
   // returns a container with all edges of cell c
-  static Cell_edges cell_edges(const Cell_descriptor& c,
+  static Cell_edges cell_edges(const cell_descriptor& c,
                                const Grid&)
   {
     Cell_edges ce;
diff --git a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/partition_traits_Octree.h b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/partition_traits_Octree.h
index 0916ba1b590..af38e5ad28a 100644
--- a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/partition_traits_Octree.h
+++ b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/partition_traits_Octree.h
@@ -44,45 +44,45 @@ struct partition_traits<internal::Octree_wrapper<GeomTraits> >
   using Octree = internal::Octree_wrapper<GeomTraits>;
 
 public:
-  using Vertex_descriptor = typename Octree::Vertex_handle;
-  using Edge_descriptor = typename Octree::Edge_handle;
-  using Cell_descriptor = typename Octree::Voxel_handle;
+  using vertex_descriptor = typename Octree::Vertex_handle;
+  using edge_descriptor = typename Octree::Edge_handle;
+  using cell_descriptor = typename Octree::Voxel_handle;
 
   static constexpr Cell_type CELL_TYPE = CUBICAL_CELL;
   static constexpr std::size_t VERTICES_PER_CELL = 8;
   static constexpr std::size_t EDGES_PER_CELL = 12;
 
-  using Vertices_incident_to_edge = std::array<Vertex_descriptor, 2>;
-  using Cells_incident_to_edge = std::array<Cell_descriptor, 4>;  // @todo: not always 4
-  using Cell_vertices = std::array<Vertex_descriptor, 8>;
-  using Cell_edges = std::array<Edge_descriptor, 12>;
+  using Vertices_incident_to_edge = std::array<vertex_descriptor, 2>;
+  using Cells_incident_to_edge = std::array<cell_descriptor, 4>;  // @todo: not always 4
+  using Cell_vertices = std::array<vertex_descriptor, 8>;
+  using Cell_edges = std::array<edge_descriptor, 12>;
 
 public:
-  static decltype(auto) /*Point_3*/ point(const Vertex_descriptor& v,
+  static decltype(auto) /*Point_3*/ point(const vertex_descriptor& v,
                                           const Octree& o)
   {
     return o.point(v);
   }
 
-  static Vertices_incident_to_edge incident_vertices(const Edge_descriptor& e,
+  static Vertices_incident_to_edge incident_vertices(const edge_descriptor& e,
                                                      const Octree& o)
   {
     return o.edge_vertices(e);
   }
 
-  static Cells_incident_to_edge incident_cells(const Edge_descriptor& e,
+  static Cells_incident_to_edge incident_cells(const edge_descriptor& e,
                                                const Octree& o)
   {
     return o.edge_voxels(e);
   }
 
-  static Cell_vertices cell_vertices(const Cell_descriptor& c,
+  static Cell_vertices cell_vertices(const cell_descriptor& c,
                                      const Octree& o)
   {
     return o.voxel_vertices(c);
   }
 
-  static Cell_edges cell_edges(const Cell_descriptor& c,
+  static Cell_edges cell_edges(const cell_descriptor& c,
                                const Octree& o)
   {
     return o.voxel_edges(c);
@@ -93,7 +93,7 @@ public:
                               const Octree& o,
                               const CGAL::Sequential_tag)
   {
-    for(const Vertex_descriptor& v : o.leaf_vertices())
+    for(const vertex_descriptor& v : o.leaf_vertices())
       f(v);
   }
 
@@ -102,7 +102,7 @@ public:
                             const Octree& o,
                             Sequential_tag)
   {
-    for(const Edge_descriptor& e : o.leaf_edges())
+    for(const edge_descriptor& e : o.leaf_edges())
       f(e);
   }
 
@@ -111,7 +111,7 @@ public:
                             const Octree& o,
                             CGAL::Sequential_tag)
   {
-    for(const Cell_descriptor& v : o.leaf_voxels())
+    for(const cell_descriptor& v : o.leaf_voxels())
       f(v);
   }
 
diff --git a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/topologically_correct_marching_cubes_functors.h b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/topologically_correct_marching_cubes_functors.h
index 5d15704320e..7da4918a7f7 100644
--- a/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/topologically_correct_marching_cubes_functors.h
+++ b/Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/topologically_correct_marching_cubes_functors.h
@@ -72,8 +72,8 @@ private:
   using FT = typename Geom_traits::FT;
   using Point_3 = typename Geom_traits::Point_3;
 
-  using Edge_descriptor = typename Domain::Edge_descriptor;
-  using Cell_descriptor = typename Domain::Cell_descriptor;
+  using edge_descriptor = typename Domain::edge_descriptor;
+  using cell_descriptor = typename Domain::cell_descriptor;
 
   using Point_index = std::size_t;
   using Edge_index = std::array<std::size_t, 4>;
@@ -140,7 +140,7 @@ public:
       m_point_counter(0)
   { }
 
-  void operator()(const Cell_descriptor& cell)
+  void operator()(const cell_descriptor& cell)
   {
     std::array<FT, 8> values;
     std::array<Point_3, 8> corners;
@@ -206,7 +206,7 @@ public:
   }
 
 private:
-  Edge_index compute_edge_index(const Cell_descriptor& cell, int edge)
+  Edge_index compute_edge_index(const cell_descriptor& cell, int edge)
   {
     // edge is in 0 - 11
 
@@ -293,7 +293,7 @@ private:
     m_triangles.push_back({p0, p1, p2});
   }
 
-  bool p_slice(const Cell_descriptor& cell,
+  bool p_slice(const cell_descriptor& cell,
                const FT i0,
                const std::array<Point_3, 8>& corners,
                const std::array<FT, 8>& values,
diff --git a/Isosurfacing_3/test/Isosurfacing_3/test_isosurfacing_concepts.cpp b/Isosurfacing_3/test/Isosurfacing_3/test_isosurfacing_concepts.cpp
index 6c96b51464e..6240fb429f9 100644
--- a/Isosurfacing_3/test/Isosurfacing_3/test_isosurfacing_concepts.cpp
+++ b/Isosurfacing_3/test/Isosurfacing_3/test_isosurfacing_concepts.cpp
@@ -73,9 +73,9 @@ struct MC_Domain
   typedef Traits<K> Geom_traits;
   typedef typename Geom_traits::FT FT;
   typedef typename Geom_traits::Point_3 Point_3;
-  typedef std::size_t Vertex_descriptor;
-  typedef std::size_t Edge_descriptor;
-  typedef std::size_t Cell_descriptor;
+  typedef std::size_t vertex_descriptor;
+  typedef std::size_t edge_descriptor;
+  typedef std::size_t cell_descriptor;
   typedef std::vector<std::size_t> Vertices_incident_to_edge;
   typedef std::vector<std::size_t> Cells_incident_to_edge;
   typedef std::vector<std::size_t> Cell_vertices;
@@ -83,15 +83,15 @@ struct MC_Domain
 
   Geom_traits geom_traits() const { return Geom_traits(); }
 
-  Point_3 point(const Vertex_descriptor& /*v*/) const { return CGAL::ORIGIN; }
+  Point_3 point(const vertex_descriptor& /*v*/) const { return CGAL::ORIGIN; }
 
   FT value(const Point_3& /*p*/) const { return 0; }
-  FT value(const Vertex_descriptor& /*v*/) const { return 0; }
+  FT value(const vertex_descriptor& /*v*/) const { return 0; }
 
-  Vertices_incident_to_edge incident_vertices(const Edge_descriptor& /*e*/) const { return {}; }
-  Cells_incident_to_edge incident_cells(const Edge_descriptor& /*e*/) const { return {}; }
-  Cell_vertices cell_vertices(const Cell_descriptor& /*c*/) const { return {}; }
-  Cell_edges cell_edges(const Cell_descriptor& /*c*/) const { return {}; }
+  Vertices_incident_to_edge incident_vertices(const edge_descriptor& /*e*/) const { return {}; }
+  Cells_incident_to_edge incident_cells(const edge_descriptor& /*e*/) const { return {}; }
+  Cell_vertices cell_vertices(const cell_descriptor& /*c*/) const { return {}; }
+  Cell_edges cell_edges(const cell_descriptor& /*c*/) const { return {}; }
 
   template <typename ConcurrencyTag, typename Functor>
   void for_each_vertex(Functor& /*f*/) const { }