diff --git a/Core/include/Acts/Detector/Blueprint.hpp b/Core/include/Acts/Detector/Blueprint.hpp
index b3724f3fec5..e593c45b034 100644
--- a/Core/include/Acts/Detector/Blueprint.hpp
+++ b/Core/include/Acts/Detector/Blueprint.hpp
@@ -10,10 +10,10 @@
 
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Definitions/Common.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Geometry/VolumeBounds.hpp"
 #include "Acts/Utilities/AxisDefinitions.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 #include "Acts/Utilities/StringHelpers.hpp"
 
 #include <map>
@@ -99,7 +99,7 @@ struct Node final {
   std::vector<AxisDirection> binning = {};
 
   /// Portal proto material binning
-  std::map<unsigned int, BinningDescription> portalMaterialBinning = {};
+  std::map<unsigned int, std::vector<ProtoAxis>> portalMaterialBinning = {};
 
   /// Auxiliary information
   std::vector<std::string> auxiliary = {};
diff --git a/Core/include/Acts/Detector/CylindricalContainerBuilder.hpp b/Core/include/Acts/Detector/CylindricalContainerBuilder.hpp
index 2abc41327fb..475608b54ae 100644
--- a/Core/include/Acts/Detector/CylindricalContainerBuilder.hpp
+++ b/Core/include/Acts/Detector/CylindricalContainerBuilder.hpp
@@ -10,11 +10,11 @@
 
 #include "Acts/Detector/Blueprint.hpp"
 #include "Acts/Detector/DetectorComponents.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Detector/interface/IDetectorComponentBuilder.hpp"
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/Utilities/AxisDefinitions.hpp"
 #include "Acts/Utilities/Logger.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <map>
 #include <memory>
@@ -56,7 +56,7 @@ class CylindricalContainerBuilder : public IDetectorComponentBuilder {
     /// The geometry id generator
     std::shared_ptr<const IGeometryIdGenerator> geoIdGenerator = nullptr;
     /// Material binning to be assigned to portals
-    std::map<unsigned int, BinningDescription> portalMaterialBinning = {};
+    std::map<unsigned int, std::vector<ProtoAxis>> portalMaterialBinning = {};
     /// An eventual reverse geometry id generation
     bool geoIdReverseGen = false;
     /// Auxiliary information, mainly for screen output
diff --git a/Core/include/Acts/Detector/DetectorVolumeBuilder.hpp b/Core/include/Acts/Detector/DetectorVolumeBuilder.hpp
index 6cb5e6647db..4360f19c2ac 100644
--- a/Core/include/Acts/Detector/DetectorVolumeBuilder.hpp
+++ b/Core/include/Acts/Detector/DetectorVolumeBuilder.hpp
@@ -9,10 +9,10 @@
 #pragma once
 
 #include "Acts/Detector/DetectorComponents.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Detector/interface/IDetectorComponentBuilder.hpp"
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/Utilities/Logger.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <memory>
 #include <string>
@@ -43,7 +43,7 @@ class DetectorVolumeBuilder : public IDetectorComponentBuilder {
     /// The geometry id generator
     std::shared_ptr<const IGeometryIdGenerator> geoIdGenerator = nullptr;
     /// Material binning to be assigned to portals
-    std::map<unsigned int, BinningDescription> portalMaterialBinning = {};
+    std::map<unsigned int, std::vector<ProtoAxis>> portalMaterialBinning = {};
     /// Add eventual internal volume to root
     bool addInternalsToRoot = false;
     /// Auxiliary information
diff --git a/Core/include/Acts/Detector/LayerStructureBuilder.hpp b/Core/include/Acts/Detector/LayerStructureBuilder.hpp
index 02fd726824e..51750a42d60 100644
--- a/Core/include/Acts/Detector/LayerStructureBuilder.hpp
+++ b/Core/include/Acts/Detector/LayerStructureBuilder.hpp
@@ -10,15 +10,13 @@
 
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Detector/DetectorComponents.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Detector/ProtoSupport.hpp"
 #include "Acts/Detector/interface/IInternalStructureBuilder.hpp"
 #include "Acts/Detector/interface/ISurfacesProvider.hpp"
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/Surfaces/Surface.hpp"
-#include "Acts/Utilities/BinningData.hpp"
-#include "Acts/Utilities/BinningType.hpp"
 #include "Acts/Utilities/Logger.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <array>
 #include <cstddef>
@@ -84,7 +82,7 @@ class LayerStructureBuilder : public IInternalStructureBuilder {
     /// Definition of Supports
     std::vector<ProtoSupport> supports = {};
     /// Definition of Binnings
-    std::vector<ProtoBinning> binnings = {};
+    std::vector<ProtoAxis> binnings = {};
     /// Optional extent (if already parsed), will trigger binning autorange
     /// check
     std::optional<Extent> extent = std::nullopt;
diff --git a/Core/include/Acts/Detector/MultiWireStructureBuilder.hpp b/Core/include/Acts/Detector/MultiWireStructureBuilder.hpp
index 48159bf806c..3967ea0fac6 100644
--- a/Core/include/Acts/Detector/MultiWireStructureBuilder.hpp
+++ b/Core/include/Acts/Detector/MultiWireStructureBuilder.hpp
@@ -9,13 +9,13 @@
 #pragma once
 
 #include "Acts/Detector/LayerStructureBuilder.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Detector/interface/IDetectorComponentBuilder.hpp"
 #include "Acts/Detector/interface/IExternalStructureBuilder.hpp"
 #include "Acts/Detector/interface/IInternalStructureBuilder.hpp"
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/Logger.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <iostream>
 #include <string>
@@ -41,7 +41,7 @@ class MultiWireStructureBuilder {
     std::vector<double> mlBounds = {};
 
     // The binning of the multi wire structure
-    std::vector<ProtoBinning> mlBinning = {};
+    std::vector<ProtoAxis> mlBinning = {};
 
     /// A tolerance config
     float toleranceOverlap = 10.;
diff --git a/Core/include/Acts/Detector/ProtoBinning.hpp b/Core/include/Acts/Detector/ProtoBinning.hpp
deleted file mode 100644
index 231405d5991..00000000000
--- a/Core/include/Acts/Detector/ProtoBinning.hpp
+++ /dev/null
@@ -1,192 +0,0 @@
-// This file is part of the ACTS project.
-//
-// Copyright (C) 2016 CERN for the benefit of the ACTS project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-#pragma once
-
-#include "Acts/Definitions/Algebra.hpp"
-#include "Acts/Definitions/Common.hpp"
-#include "Acts/Utilities/AxisDefinitions.hpp"
-#include "Acts/Utilities/BinUtility.hpp"
-
-#include <sstream>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-namespace Acts::Experimental {
-
-/// @brief  Simple helper class to define a binning structure
-///
-/// @note no checks are performed on the consistency, this is
-/// only for convenience that the binning can be defined and then
-/// translated into concrete axis types
-struct ProtoBinning {
-  /// The axis direction
-  AxisDirection axisDir;
-  /// The axis type: equidistant or variable
-  Acts::AxisType axisType = Acts::AxisType::Equidistant;
-  /// The axis boundary type: Open, Bound or Closed
-  Acts::AxisBoundaryType boundaryType = Acts::AxisBoundaryType::Bound;
-  /// The binning edges
-  std::vector<double> edges = {};
-  /// An expansion for the filling (in bins)
-  std::size_t expansion = 0u;
-  /// Indication if this is an auto-range binning
-  bool autorange = false;
-
-  /// Convenience constructors - for variable binning
-  ///
-  /// @param aDir the value/cast in which this is binned
-  /// @param bType the axis boundary type
-  /// @param e the bin edges (variable binning)
-  /// @param exp the expansion (in bins)
-  ProtoBinning(AxisDirection aDir, Acts::AxisBoundaryType bType,
-               const std::vector<double>& e, std::size_t exp = 0u)
-      : axisDir(aDir),
-        axisType(Acts::AxisType::Variable),
-        boundaryType(bType),
-        edges(e),
-        expansion(exp) {
-    if (edges.size() < 2u) {
-      throw std::invalid_argument(
-          "ProtoBinning: Invalid binning, at least two edges are needed.");
-    }
-  }
-
-  /// Convenience constructors - for equidistant binning
-  ///
-  /// @param aDir the value/cast in which this is binned
-  /// @param bType the axis boundary type
-  /// @param minE the lowest edge of the binning
-  /// @param maxE the highest edge of the binning
-  /// @param nbins the number of bins
-  /// @param exp the expansion (in bins)
-  ProtoBinning(AxisDirection aDir, Acts::AxisBoundaryType bType, double minE,
-               double maxE, std::size_t nbins, std::size_t exp = 0u)
-      : axisDir(aDir), boundaryType(bType), expansion(exp) {
-    if (minE >= maxE) {
-      std::string msg = "ProtoBinning: Invalid axis range for direction '";
-      msg += axisDirectionName(axisDir);
-      msg += "', min edge (" + std::to_string(minE) + ") ";
-      msg += " needs to be smaller than max edge (";
-      msg += std::to_string(maxE) + ").";
-      throw std::invalid_argument(msg);
-    }
-    if (nbins < 1u) {
-      throw std::invalid_argument(
-          "ProtoBinning: Invalid binning, at least one bin is needed.");
-    }
-
-    double stepE = (maxE - minE) / nbins;
-    edges.reserve(nbins + 1);
-    for (std::size_t i = 0; i <= nbins; i++) {
-      edges.push_back(minE + i * stepE);
-    }
-  }
-
-  /// Placeholder constructors - for equidistant binning
-  ///
-  /// @note this is designed to give a binning prescription
-  /// when the actual extent is not yet evaluated, only works
-  /// for equidistant binning obviously
-  ///
-  /// @param aDir the value/cast in which this is binned
-  /// @param bType the axis boundary type
-  /// @param nbins the number of bins
-  /// @param exp the expansion (in bins)
-  ProtoBinning(AxisDirection aDir, Acts::AxisBoundaryType bType,
-               std::size_t nbins, std::size_t exp = 0u)
-      : axisDir(aDir),
-        boundaryType(bType),
-        edges(nbins + 1, 0.),
-        expansion(exp),
-        autorange(true) {}
-
-  // Return the number of bins
-  std::size_t bins() const { return edges.size() - 1u; }
-
-  // Screen output
-  std::string toString() const {
-    std::stringstream ss;
-    ss << "ProtoBinning: " << bins() << " bins in "
-       << axisDirectionName(axisDir);
-    ss << (axisType == Acts::AxisType::Variable ? ", variable "
-                                                : ", equidistant ");
-    if (!autorange) {
-      ss << "within [" << edges.front() << ", " << edges.back() << "] ";
-    } else {
-      ss << "within automatic range";
-    }
-    return ss.str();
-  }
-};
-
-/// @brief A binning description, it helps for screen output
-struct BinningDescription {
-  /// Convert the binning description into a bin utility
-  ///
-  /// @param binUtility the bin utility to be converted into a BinningDescription
-  static BinningDescription fromBinUtility(const BinUtility& binUtility) {
-    BinningDescription bDesc;
-    for (const auto& bData : binUtility.binningData()) {
-      // One proto binning per binning data
-      Acts::AxisBoundaryType boundaryType =
-          bData.option == open ? Acts::AxisBoundaryType::Bound
-                               : Acts::AxisBoundaryType::Closed;
-      std::vector<double> edges;
-      if (bData.type == equidistant) {
-        bDesc.binning.push_back(ProtoBinning(bData.binvalue, boundaryType,
-                                             bData.min, bData.max, bData.bins(),
-                                             0u));
-
-      } else {
-        std::for_each(bData.boundaries().begin(), bData.boundaries().end(),
-                      [&](double edge) { edges.push_back(edge); });
-        bDesc.binning.push_back(
-            ProtoBinning(bData.binvalue, boundaryType, edges, 0u));
-      }
-    }
-    return bDesc;
-  }
-
-  /// Convert to a BinUtility - only basic types are supported
-  ///
-  BinUtility toBinUtility() const {
-    BinUtility binUtility;
-    for (const auto& b : binning) {
-      Acts::BinningOption bOption =
-          b.boundaryType == Acts::AxisBoundaryType::Bound ? Acts::open
-                                                          : Acts::closed;
-      if (b.axisType == Acts::AxisType::Equidistant) {
-        binUtility += BinUtility(b.bins(), b.edges.front(), b.edges.back(),
-                                 bOption, b.axisDir);
-      } else {
-        std::vector<float> edges;
-        std::for_each(b.edges.begin(), b.edges.end(),
-                      [&](double edge) { edges.push_back(edge); });
-        binUtility += BinUtility(edges, bOption, b.axisDir);
-      }
-    }
-    return binUtility;
-  }
-
-  /// The contained binnings
-  std::vector<ProtoBinning> binning;
-
-  // Screen output
-  std::string toString() const {
-    std::stringstream ss;
-    ss << "BinningDescription: " << binning.size() << "D" << std::endl;
-    for (const auto& b : binning) {
-      ss << "  " << b.toString() << std::endl;
-    }
-    return ss.str();
-  }
-};
-
-}  // namespace Acts::Experimental
diff --git a/Core/include/Acts/Detector/ProtoSupport.hpp b/Core/include/Acts/Detector/ProtoSupport.hpp
index 2c02bd2ba22..e9f5417290c 100644
--- a/Core/include/Acts/Detector/ProtoSupport.hpp
+++ b/Core/include/Acts/Detector/ProtoSupport.hpp
@@ -10,10 +10,10 @@
 
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Definitions/Common.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/AxisDefinitions.hpp"
 #include "Acts/Utilities/BinningData.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <optional>
 #include <stdexcept>
@@ -63,7 +63,7 @@ struct ProtoSupport {
   std::shared_ptr<Surface> surface = nullptr;
 
   /// The (optional) binning description for proto material
-  std::optional<BinningDescription> protoMaterialBinning = std::nullopt;
+  std::optional<std::vector<ProtoAxis>> protoMaterialBinning = std::nullopt;
 
   /// Potential splits into planar approximations (valid for cylinder/disc)
   unsigned int splits = 1u;
diff --git a/Core/include/Acts/Detector/detail/IndexedSurfacesGenerator.hpp b/Core/include/Acts/Detector/detail/IndexedSurfacesGenerator.hpp
index 08fc8043d99..039a6add303 100644
--- a/Core/include/Acts/Detector/detail/IndexedSurfacesGenerator.hpp
+++ b/Core/include/Acts/Detector/detail/IndexedSurfacesGenerator.hpp
@@ -17,89 +17,113 @@
 #include <array>
 #include <memory>
 
-namespace Acts::Experimental::detail {
+namespace Acts::detail::IndexedSurfacesGenerator {
 
-/// @brief  A templated indexed grid generator.
+/// Factory method to create a 1D indexed surface grid
 ///
-/// This Generator creates a InternalNavigationDelegate delegate
-/// which can then be used in the DetectorVolume class for updating
-/// given surface candidates based on an index grid.
-///
-/// It allows for:
-/// - certain indices being forcly assigned to all bins
-/// - a chosen expansion to fill indices in neighborhood bins
-///
-/// @tparam objects_container the objects container
-template <typename surface_container, template <typename> class indexed_updator>
-struct IndexedSurfacesGenerator {
-  /// The surfaces to be indexed
-  /// (including surfaces that are assigned to all bins)
-  surface_container surfaces = {};
-  // Indices of surfaces that are to be assigned to all bins
-  std::vector<std::size_t> assignToAll = {};
-  /// The binning for the indexing
-  std::vector<AxisDirection> bValues = {};
-  // Bin expansion
-  std::vector<std::size_t> binExpansion = {};
-  /// The transform into the local binning schema
-  Transform3 transform = Transform3::Identity();
-  /// Screen output logger
-  std::unique_ptr<const Logger> oLogger =
-      getDefaultLogger("IndexedSurfacesGenerator", Logging::INFO);
-
-  /// Create the Surface candidate updator
-  ///
-  /// @tparam axis_generator does generate the axis of the grid
-  /// @tparam reference_generator does generate the reference query points
-  ///
-  /// @param gctx the geometry context
-  /// @param aGenerator the axis generator
-  /// @param rGenerator the reference generataor
-  ///
-  /// @return an InternalNavigationDelegate
-  template <typename axis_generator, typename reference_generator>
-  InternalNavigationDelegate operator()(
-      const GeometryContext& gctx, const axis_generator& aGenerator,
-      const reference_generator& rGenerator) const {
-    ACTS_DEBUG("Indexing " << surfaces.size() << " surface, "
-                           << assignToAll.size() << " of which into all bins.");
-    // Create the grid with the provided axis generator
-    using GridType =
-        typename axis_generator::template grid_type<std::vector<std::size_t>>;
-    GridType grid(std::move(aGenerator()));
-
-    std::array<AxisDirection, decltype(grid)::DIM> bvArray = {};
-    for (auto [ibv, bv] : enumerate(bValues)) {
-      bvArray[ibv] = bv;
-    }
-
-    indexed_updator<GridType> indexedSurfaces(std::move(grid), bvArray,
-                                              transform);
-    // Fill the bin indices
-    IndexedGridFiller filler{binExpansion};
-    filler.oLogger = oLogger->cloneWithSuffix("_filler");
+/// @param gctx the geometry context
+/// @param surfaces the surfaces to be indexed
+/// @param rGenerator the reference generator
+/// @param pAxis the proto axis
+/// @param assignToAll the indices assigned to all bins
+/// @param transform the transform into the local binning schema
+/// @return an internal navigation delegate
+template <template <typename> class indexed_updator, typename surface_container,
+          typename reference_generator>
+Experimental::InternalNavigationDelegate createInternalNavigation(
+    const GeometryContext& gctx, const surface_container& surfaces,
+    const reference_generator& rGenerator, const ProtoAxis& pAxis,
+    const std::vector<std::size_t> assignToAll = {},
+    const Transform3 transform = Transform3::Identity()) {
+  // Let the axis create the grid
+  return pAxis.getAxis().visit([&]<typename AxisTypeA>(const AxisTypeA& axis) {
+    Grid<std::vector<std::size_t>, AxisTypeA> grid(axis);
+
+    // Prepare the indexed updator
+    std::array<AxisDirection, 1u> axisDirs = {pAxis.getAxisDirection()};
+    indexed_updator<decltype(grid)> indexedSurfaces(std::move(grid), axisDirs,
+                                                    transform);
+
+    // Prepare the filling
+    Experimental::InternalNavigationDelegate nStateUpdater;
+
+    std::vector<std::size_t> fillExpansion = {pAxis.getFillExpansion()};
+    Experimental::detail::IndexedGridFiller filler{fillExpansion};
     filler.fill(gctx, indexedSurfaces, surfaces, rGenerator, assignToAll);
 
     // The portal delegate
-    AllPortalsNavigation allPortals;
+    Experimental::AllPortalsNavigation allPortals;
 
     // The chained delegate: indexed surfaces and all portals
     using DelegateType =
-        IndexedSurfacesAllPortalsNavigation<decltype(grid), indexed_updator>;
+        Experimental::IndexedSurfacesAllPortalsNavigation<decltype(grid),
+                                                          indexed_updator>;
     auto indexedSurfacesAllPortals = std::make_unique<const DelegateType>(
         std::tie(allPortals, indexedSurfaces));
 
     // Create the delegate and connect it
-    InternalNavigationDelegate nStateUpdater;
     nStateUpdater.connect<&DelegateType::update>(
         std::move(indexedSurfacesAllPortals));
+
     return nStateUpdater;
-  }
+  });
+}
+
+/// Factory method to create a 2D indexed surface grid
+///
+/// @param gctx the geometry context
+/// @param surfaces the surfaces to be indexed
+/// @param rGenerator the reference generator
+/// @param pAxisA the first proto axis
+/// @param pAxisB the second proto axis
+/// @param assignToAll the indices assigned to all bins
+/// @param transform the transform into the local binning schema
+///
+/// @return an internal navigation delegate
+template <template <typename> class indexed_updator, typename surface_container,
+          typename reference_generator>
+Experimental::InternalNavigationDelegate createInternalNavigation(
+    const GeometryContext& gctx, const surface_container& surfaces,
+    const reference_generator& rGenerator, const ProtoAxis& pAxisA,
+    const ProtoAxis& pAxisB, const std::vector<std::size_t> assignToAll = {},
+    const Transform3 transform = Transform3::Identity()) {
+  // Let the axes create the grid
+  return pAxisA.getAxis().visit([&]<typename AxisTypeA>(
+                                    const AxisTypeA& axisA) {
+    return pAxisB.getAxis().visit([&]<typename AxisTypeB>(
+                                      const AxisTypeB& axisB) {
+      Grid<std::vector<std::size_t>, AxisTypeA, AxisTypeB> grid(axisA, axisB);
+      Experimental::InternalNavigationDelegate nStateUpdater;
+
+      // Prepare the indexed updator
+      std::array<AxisDirection, 2u> axisDirs = {pAxisA.getAxisDirection(),
+                                                pAxisB.getAxisDirection()};
+      indexed_updator<decltype(grid)> indexedSurfaces(std::move(grid), axisDirs,
+                                                      transform);
+
+      std::vector<std::size_t> fillExpansion = {pAxisA.getFillExpansion(),
+                                                pAxisB.getFillExpansion()};
+
+      Experimental::detail::IndexedGridFiller filler{fillExpansion};
+      filler.fill(gctx, indexedSurfaces, surfaces, rGenerator, assignToAll);
+
+      // The portal delegate
+      Experimental::AllPortalsNavigation allPortals;
+
+      // The chained delegate: indexed surfaces and all portals
+      using DelegateType =
+          Experimental::IndexedSurfacesAllPortalsNavigation<decltype(grid),
+                                                            indexed_updator>;
+      auto indexedSurfacesAllPortals = std::make_unique<const DelegateType>(
+          std::tie(allPortals, indexedSurfaces));
+
+      // Create the delegate and connect it
+      nStateUpdater.connect<&DelegateType::update>(
+          std::move(indexedSurfacesAllPortals));
 
-  /// Access to the logger
-  ///
-  /// @return a const reference to the logger
-  const Logger& logger() const { return *oLogger; }
-};
+      return nStateUpdater;
+    });
+  });
+}
 
-}  // namespace Acts::Experimental::detail
+}  // namespace Acts::detail::IndexedSurfacesGenerator
diff --git a/Core/include/Acts/Detector/detail/ProtoMaterialHelper.hpp b/Core/include/Acts/Detector/detail/ProtoMaterialHelper.hpp
index a43e96ac521..9649197bf50 100644
--- a/Core/include/Acts/Detector/detail/ProtoMaterialHelper.hpp
+++ b/Core/include/Acts/Detector/detail/ProtoMaterialHelper.hpp
@@ -9,16 +9,13 @@
 #pragma once
 
 #include "Acts/Geometry/GeometryContext.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 namespace Acts {
 
 class Surface;
 
-namespace Experimental {
-
-struct BinningDescription;
-
-namespace detail::ProtoMaterialHelper {
+namespace Experimental::detail::ProtoMaterialHelper {
 
 /// @brief Method that attaches proto material to a surface given
 /// a proto binning description
@@ -29,10 +26,9 @@ namespace detail::ProtoMaterialHelper {
 ///
 /// @return an (eventual) updated binning description for structured
 ///         screen logging output
-BinningDescription attachProtoMaterial(const GeometryContext& gctx,
-                                       Surface& surface,
-                                       const BinningDescription& bDescription);
+std::vector<ProtoAxis> attachProtoMaterial(
+    const GeometryContext& gctx, Surface& surface,
+    const std::vector<ProtoAxis>& bDescription);
 
-}  // namespace detail::ProtoMaterialHelper
-}  // namespace Experimental
+}  // namespace Experimental::detail::ProtoMaterialHelper
 }  // namespace Acts
diff --git a/Core/include/Acts/Geometry/MaterialDesignatorBlueprintNode.hpp b/Core/include/Acts/Geometry/MaterialDesignatorBlueprintNode.hpp
index dbb4663fe71..e8bef689bef 100644
--- a/Core/include/Acts/Geometry/MaterialDesignatorBlueprintNode.hpp
+++ b/Core/include/Acts/Geometry/MaterialDesignatorBlueprintNode.hpp
@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Geometry/BlueprintNode.hpp"
 #include "Acts/Geometry/PortalShell.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <variant>
 
@@ -27,8 +27,7 @@ class MaterialDesignatorBlueprintNode final : public BlueprintNode {
   // @TODO: This needs cuboid volume storage as well
   // @TODO: I don't love the type
   using BinningConfig = std::variant<std::vector<
-      std::tuple<CylinderVolumeBounds::Face, Experimental::ProtoBinning,
-                 Experimental::ProtoBinning>>>;
+      std::tuple<CylinderVolumeBounds::Face, ProtoAxis, ProtoAxis>>>;
 
   /// Main constructor for the material designator node.
   /// @param name The name of the node (for debug only)
@@ -89,8 +88,7 @@ class MaterialDesignatorBlueprintNode final : public BlueprintNode {
   void handleCylinderBinning(
       CylinderPortalShell& cylShell,
       const std::vector<
-          std::tuple<CylinderPortalShell::Face, Experimental::ProtoBinning,
-                     Experimental::ProtoBinning>>& binning,
+          std::tuple<CylinderPortalShell::Face, ProtoAxis, ProtoAxis>>& binning,
       const Logger& logger);
 
   std::string m_name{};
diff --git a/Core/include/Acts/Material/ProtoSurfaceMaterial.hpp b/Core/include/Acts/Material/ProtoSurfaceMaterial.hpp
index 8b6dfed3287..c2703dda699 100644
--- a/Core/include/Acts/Material/ProtoSurfaceMaterial.hpp
+++ b/Core/include/Acts/Material/ProtoSurfaceMaterial.hpp
@@ -9,12 +9,13 @@
 #pragma once
 
 #include "Acts/Definitions/Algebra.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Material/ISurfaceMaterial.hpp"
 #include "Acts/Material/MaterialSlab.hpp"
 #include "Acts/Utilities/BinUtility.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <iosfwd>
+#include <vector>
 
 namespace Acts {
 
@@ -96,7 +97,7 @@ class ProtoSurfaceMaterialT : public ISurfaceMaterial {
   /// @param sl is the output stream
   std::ostream& toStream(std::ostream& sl) const final {
     sl << "Acts::ProtoSurfaceMaterial : " << std::endl;
-    sl << m_binning.toString() << std::endl;
+    sl << m_binning << std::endl;
     return sl;
   }
 
@@ -110,7 +111,6 @@ class ProtoSurfaceMaterialT : public ISurfaceMaterial {
 
 using ProtoSurfaceMaterial = ProtoSurfaceMaterialT<Acts::BinUtility>;
 
-using ProtoGridSurfaceMaterial =
-    ProtoSurfaceMaterialT<Acts::Experimental::BinningDescription>;
+using ProtoGridSurfaceMaterial = ProtoSurfaceMaterialT<std::vector<ProtoAxis>>;
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Utilities/BinUtility.hpp b/Core/include/Acts/Utilities/BinUtility.hpp
index 79d59ddadfa..8ae8581cf10 100644
--- a/Core/include/Acts/Utilities/BinUtility.hpp
+++ b/Core/include/Acts/Utilities/BinUtility.hpp
@@ -13,6 +13,7 @@
 #include "Acts/Utilities/BinningData.hpp"
 #include "Acts/Utilities/BinningType.hpp"
 #include "Acts/Utilities/Enumerate.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <array>
 #include <cstddef>
@@ -101,6 +102,30 @@ class BinUtility {
 
   BinUtility(BinUtility&& sbu) = default;
 
+  /// Create from ProtoAxis
+  ///
+  /// @param pAxis the ProtoAxis to be used
+  explicit BinUtility(const ProtoAxis& pAxis)
+      : m_binningData(),
+        m_transform(Transform3::Identity()),
+        m_itransform(Transform3::Identity()) {
+    m_binningData.reserve(3);
+    m_binningData.push_back(BinningData(pAxis));
+  }
+
+  /// Create from ProtoAxis
+  ///
+  /// @param pAxes the ProtoAxes to be used
+  BinUtility(const std::vector<ProtoAxis>& pAxes)
+      : m_binningData(),
+        m_transform(Transform3::Identity()),
+        m_itransform(Transform3::Identity()) {
+    m_binningData.reserve(3);
+    for (const auto& pAxis : pAxes) {
+      m_binningData.push_back(BinningData(pAxis));
+    }
+  }
+
   /// Assignment operator
   ///
   /// @param sbu is the source bin utility
diff --git a/Core/include/Acts/Utilities/BinningData.hpp b/Core/include/Acts/Utilities/BinningData.hpp
index 904429f64be..cfe948c17ab 100644
--- a/Core/include/Acts/Utilities/BinningData.hpp
+++ b/Core/include/Acts/Utilities/BinningData.hpp
@@ -12,6 +12,7 @@
 #include "Acts/Utilities/AxisDefinitions.hpp"
 #include "Acts/Utilities/BinningType.hpp"
 #include "Acts/Utilities/Helpers.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 #include "Acts/Utilities/ThrowAssert.hpp"
 #include "Acts/Utilities/VectorHelpers.hpp"
 
@@ -174,6 +175,31 @@ class BinningData {
     }
   }
 
+  /// Constructor from ProtoAxis
+  ///
+  /// @param pAxis is the ProtoAxis object
+  ///
+  explicit BinningData(const ProtoAxis& pAxis)
+      : binvalue(pAxis.getAxisDirection()), subBinningData(nullptr) {
+    const auto& axis = pAxis.getAxis();
+    type = axis.getType() == AxisType::Equidistant ? equidistant : arbitrary;
+    option = axis.getBoundaryType() == AxisBoundaryType::Closed ? closed : open;
+    min = static_cast<float>(axis.getMin());
+    max = static_cast<float>(axis.getMax());
+    m_bins = axis.getNBins();
+    step = (max - min) / (1. * m_bins);
+    zdim = (m_bins == 1);
+    m_boundaries.reserve(axis.getBinEdges().size());
+    for (const auto& edge : axis.getBinEdges()) {
+      m_boundaries.push_back(static_cast<float>(edge));
+    }
+    m_totalBins = m_bins;
+    m_totalBoundaries = m_boundaries;
+    // Set the search function pointer based on axis type
+    m_functionPtr = (type == equidistant) ? &searchEquidistantWithBoundary
+                                          : &searchInVectorWithBoundary;
+  }
+
   /// Assignment operator
   ///
   /// @param bdata is the source object
diff --git a/Core/include/Acts/Utilities/ProtoAxis.hpp b/Core/include/Acts/Utilities/ProtoAxis.hpp
index 48163a016b9..fe124a03622 100644
--- a/Core/include/Acts/Utilities/ProtoAxis.hpp
+++ b/Core/include/Acts/Utilities/ProtoAxis.hpp
@@ -31,8 +31,11 @@ class ProtoAxis {
   /// @param aDir the value/cast in which this is binned
   /// @param abType the axis boundary type
   /// @param edges the bin edges (variable binning)
+  /// @param fillExpansion the number of bins to both sides
+  /// that should also be filled with the content to create
+  /// an enforced bin overlap with objects
   ProtoAxis(AxisDirection aDir, Acts::AxisBoundaryType abType,
-            const std::vector<double>& edges);
+            const std::vector<double>& edges, std::size_t fillExpansion = 0);
 
   /// Convenience constructors - for equidistant binning
   ///
@@ -41,20 +44,33 @@ class ProtoAxis {
   /// @param minE the lowest edge of the binning
   /// @param maxE the highest edge of the binning
   /// @param nbins the number of bins
+  /// @param fillExpansion the number of bins to both sides
+  /// that should also be filled with the content to create
+  /// an enforced bin overlap with objects
   ProtoAxis(AxisDirection aDir, AxisBoundaryType abType, double minE,
-            double maxE, std::size_t nbins);
+            double maxE, std::size_t nbins, std::size_t fillExpansion = 0);
 
   /// Placeholder constructor for auto-range binning
   ///
   /// @param aDir the value/cast in which this is binned
   /// @param abType the axis boundary type
   /// @param nbins the number of bins
+  /// @param fillExpansion the number of bins to both sides
+  /// that should also be filled with the content to create
+  /// an enforced bin overlap with objects
   ///
   /// @note that auto-range is only supported for equidistant binning
-  ProtoAxis(AxisDirection aDir, AxisBoundaryType abType, std::size_t nbins);
+  ProtoAxis(AxisDirection aDir, AxisBoundaryType abType, std::size_t nbins,
+            std::size_t fillExpansion = 0);
+
+  /// Custom copy constructor
+  /// @param other is the right hand side ProtoAxis
+  ProtoAxis(const ProtoAxis& other);
+
+  /// Custom assignment operator
+  /// @param other is the right hand side ProtoAxis
+  ProtoAxis& operator=(const ProtoAxis& other);
 
-  ProtoAxis(const ProtoAxis&) = delete;
-  ProtoAxis& operator=(const ProtoAxis&) = delete;
   ProtoAxis(ProtoAxis&&) = default;
   ProtoAxis& operator=(ProtoAxis&&) = default;
 
@@ -68,10 +84,17 @@ class ProtoAxis {
   /// @return @c AxisType of this axis
   const IAxis& getAxis() const;
 
-  /// Set the range, this will change auto-range to false
+  /// Set the range, in case of autorange, this
+  /// will toggle the autorange flag to false
+  ///
+  /// @throws an exception if minE > maxE
+  ///
+  /// @note In case of variable binning, it will clip the bins outside
+  /// the new range off, i.e. it will potentially change the number
+  /// of bins.
   ///
-  /// @throws std::invalid_argument if the axis is not auto-range
-  /// @throws std::invalid_argument if the axis is not equidistant
+  /// @note In case of equidistant binning, it will adapt the bin size,
+  /// and NOT change the number of bins.
   ///
   /// @param minE the lowest edge of the binning
   /// @param maxE the highest edge of the binning
@@ -80,6 +103,9 @@ class ProtoAxis {
   /// @brief check if this is an auto-range binning
   bool isAutorange() const;
 
+  /// Return the fill expansion
+  std::size_t getFillExpansion() const;
+
   /// Dump into a string
   /// @return the string representation
   std::string toString() const;
@@ -97,6 +123,9 @@ class ProtoAxis {
 
   /// Indicate if this is a place holder auto-range binning
   bool m_autorange = false;
+
+  /// The Fill expansion parameter
+  std::size_t m_fillExpansion = 0;
 };
 
 /// @brief Helper method to create a 1D grid from a single proto axis
@@ -153,4 +182,9 @@ std::unique_ptr<IGrid> makeGrid(const ProtoAxis& a, const ProtoAxis& b) {
   });
 }
 
+// friend output stream operator
+std::ostream& operator<<(std::ostream& os, const ProtoAxis& a);
+
+std::ostream& operator<<(std::ostream& os, const std::vector<ProtoAxis>& a);
+
 }  // namespace Acts
diff --git a/Core/src/Detector/CylindricalContainerBuilder.cpp b/Core/src/Detector/CylindricalContainerBuilder.cpp
index 86dcdb08a16..c078a55d724 100644
--- a/Core/src/Detector/CylindricalContainerBuilder.cpp
+++ b/Core/src/Detector/CylindricalContainerBuilder.cpp
@@ -264,7 +264,7 @@ Acts::Experimental::CylindricalContainerBuilder::construct(
       auto bd = detail::ProtoMaterialHelper::attachProtoMaterial(
           gctx, portalContainer[ip]->surface(), bDescription);
       ACTS_VERBOSE("-> Assigning proto material to portal " << ip << " with "
-                                                            << bd.toString());
+                                                            << bd);
     }
   }
 
diff --git a/Core/src/Detector/DetectorVolumeBuilder.cpp b/Core/src/Detector/DetectorVolumeBuilder.cpp
index d52162e5f07..c0788936a00 100644
--- a/Core/src/Detector/DetectorVolumeBuilder.cpp
+++ b/Core/src/Detector/DetectorVolumeBuilder.cpp
@@ -97,7 +97,7 @@ Acts::Experimental::DetectorVolumeBuilder::construct(
       auto bd = detail::ProtoMaterialHelper::attachProtoMaterial(
           gctx, portalContainer[ip]->surface(), bDescription);
       ACTS_VERBOSE("-> Assigning proto material to portal " << ip << " with "
-                                                            << bd.toString());
+                                                            << bd);
     }
   }
 
diff --git a/Core/src/Detector/LayerStructureBuilder.cpp b/Core/src/Detector/LayerStructureBuilder.cpp
index 5b63b40ba39..46921e5ed5f 100644
--- a/Core/src/Detector/LayerStructureBuilder.cpp
+++ b/Core/src/Detector/LayerStructureBuilder.cpp
@@ -9,7 +9,6 @@
 #include "Acts/Detector/LayerStructureBuilder.hpp"
 
 #include "Acts/Definitions/Algebra.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Detector/detail/IndexedSurfacesGenerator.hpp"
 #include "Acts/Detector/detail/ReferenceGenerators.hpp"
 #include "Acts/Detector/detail/SupportSurfacesHelper.hpp"
@@ -22,8 +21,8 @@
 #include "Acts/Utilities/BinningData.hpp"
 #include "Acts/Utilities/Enumerate.hpp"
 #include "Acts/Utilities/Grid.hpp"
-#include "Acts/Utilities/GridAxisGenerators.hpp"
 #include "Acts/Utilities/Helpers.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <algorithm>
 #include <cmath>
@@ -44,139 +43,25 @@ namespace {
 /// @param pBinning the proto binning
 /// @param extent the extent from which the range is taken
 ///
-void adaptBinningRange(std::vector<Acts::Experimental::ProtoBinning>& pBinning,
+void adaptBinningRange(std::vector<Acts::ProtoAxis>& pBinning,
                        const Acts::Extent& extent) {
   for (auto& pb : pBinning) {
     // Starting values
-    double vmin = pb.edges.front();
-    double vmax = pb.edges.back();
-    // Get the number of bins
-    std::size_t nBins = pb.bins();
+    const auto& axis = pb.getAxis();
+    const auto& edges = axis.getBinEdges();
+    double vmin = edges.front();
+    double vmax = edges.back();
     // Check if extent overwrites that
-    if (extent.constrains(pb.axisDir)) {
-      const auto& range = extent.range(pb.axisDir);
+    if (extent.constrains(pb.getAxisDirection())) {
+      const auto& range = extent.range(pb.getAxisDirection());
       // Patch the edges values from the range
       vmin = range.min();
       vmax = range.max();
     }
-    // Possibly update the edges
-    if (pb.axisType == Acts::AxisType::Equidistant) {
-      double binWidth = (vmax - vmin) / nBins;
-      // Fill the edges
-      pb.edges = {vmin};
-      pb.edges.resize(nBins + 1);
-      for (std::size_t ib = 0; ib <= nBins; ++ib) {
-        pb.edges[ib] = vmin + ib * binWidth;
-      }
-    } else {
-      pb.edges.front() = vmin;
-      pb.edges.back() = vmax;
-    }
+    pb.setRange(vmin, vmax);
   }
 }
 
-/// Helper for 1-dimensional generators
-///
-/// @tparam aType is the axis boundary type: closed or bound
-///
-/// @param gctx the geometry context
-/// @param lSurfaces the surfaces of the layer
-/// @param assignToAll the indices assigned to all
-/// @param binning the binning struct
-///
-/// @return a configured surface candidate updators
-template <Acts::AxisBoundaryType aType>
-Acts::Experimental::InternalNavigationDelegate createUpdater(
-    const Acts::GeometryContext& gctx,
-    std::vector<std::shared_ptr<Acts::Surface>> lSurfaces,
-    std::vector<std::size_t> assignToAll,
-    const Acts::Experimental::ProtoBinning& binning) {
-  // The surface candidate updator & a generator for polyhedrons
-  Acts::Experimental::InternalNavigationDelegate sfCandidates;
-  Acts::Experimental::detail::PolyhedronReferenceGenerator rGenerator;
-  // Indexed Surface generator for this case
-  Acts::Experimental::detail::IndexedSurfacesGenerator<
-      decltype(lSurfaces), Acts::Experimental::IndexedSurfacesNavigation>
-      isg{std::move(lSurfaces),
-          std::move(assignToAll),
-          {binning.axisDir},
-          {binning.expansion}};
-  if (binning.axisType == Acts::AxisType::Equidistant) {
-    // Equidistant
-    Acts::GridAxisGenerators::Eq<aType> aGenerator{
-        {binning.edges.front(), binning.edges.back()}, binning.bins()};
-    sfCandidates = isg(gctx, aGenerator, rGenerator);
-  } else {
-    // Variable
-    Acts::GridAxisGenerators::Var<aType> aGenerator{binning.edges};
-    sfCandidates = isg(gctx, aGenerator, rGenerator);
-  }
-  return sfCandidates;
-}
-
-/// Helper for 2-dimensional generators
-///
-/// @tparam aType is the axis boundary type, axis a: closed or bound
-/// @tparam bType is the axis boundary type, axis b: closed or bound
-///
-/// @param gctx the geometry context
-/// @param lSurfaces the surfaces of the layer
-/// @param assignToAll the indices assigned to all
-/// @param aBinning the binning struct of axis a
-/// @param bBinning the binning struct of axis b
-///
-/// @return a configured surface candidate updators
-template <Acts::AxisBoundaryType aType, Acts::AxisBoundaryType bType>
-Acts::Experimental::InternalNavigationDelegate createUpdater(
-    const Acts::GeometryContext& gctx,
-    const std::vector<std::shared_ptr<Acts::Surface>>& lSurfaces,
-    const std::vector<std::size_t>& assignToAll,
-    const Acts::Experimental::ProtoBinning& aBinning,
-    const Acts::Experimental::ProtoBinning& bBinning) {
-  // The surface candidate updator & a generator for polyhedrons
-  Acts::Experimental::InternalNavigationDelegate sfCandidates;
-  Acts::Experimental::detail::PolyhedronReferenceGenerator rGenerator;
-  // Indexed Surface generator for this case
-  Acts::Experimental::detail::IndexedSurfacesGenerator<
-      decltype(lSurfaces), Acts::Experimental::IndexedSurfacesNavigation>
-      isg{lSurfaces,
-          assignToAll,
-          {aBinning.axisDir, bBinning.axisDir},
-          {aBinning.expansion, bBinning.expansion}};
-  // Run through the cases
-  if (aBinning.axisType == Acts::AxisType::Equidistant &&
-      bBinning.axisType == Acts::AxisType::Equidistant) {
-    // Equidistant-Equidistant
-    Acts::GridAxisGenerators::EqEq<aType, bType> aGenerator{
-        {aBinning.edges.front(), aBinning.edges.back()},
-        aBinning.bins(),
-        {bBinning.edges.front(), bBinning.edges.back()},
-        bBinning.bins()};
-    sfCandidates = isg(gctx, aGenerator, rGenerator);
-  } else if (bBinning.axisType == Acts::AxisType::Equidistant) {
-    // Variable-Equidistant
-    Acts::GridAxisGenerators::VarEq<aType, bType> aGenerator{
-        aBinning.edges,
-        {bBinning.edges.front(), bBinning.edges.back()},
-        bBinning.bins()};
-    sfCandidates = isg(gctx, aGenerator, rGenerator);
-  } else if (aBinning.axisType == Acts::AxisType::Equidistant) {
-    // Equidistant-Variable
-    Acts::GridAxisGenerators::EqVar<aType, bType> aGenerator{
-        {aBinning.edges.front(), aBinning.edges.back()},
-        aBinning.bins(),
-        bBinning.edges};
-    sfCandidates = isg(gctx, aGenerator, rGenerator);
-  } else {
-    // Variable-Variable
-    Acts::GridAxisGenerators::VarVar<aType, bType> aGenerator{aBinning.edges,
-                                                              bBinning.edges};
-    sfCandidates = isg(gctx, aGenerator, rGenerator);
-  }
-  // Return the candidates
-  return sfCandidates;
-}
-
 }  // namespace
 
 Acts::Experimental::LayerStructureBuilder::LayerStructureBuilder(
@@ -312,59 +197,38 @@ Acts::Experimental::LayerStructureBuilder::construct(
       ACTS_DEBUG(
           "No surface binning provided, navigation will be 'tryAll' "
           "(potentially slow).");
-    } else if (binnings.size() == 1u) {
+    } else {
+      // Sort the binning for conventions
+      std::ranges::sort(binnings, {},
+                        [](const auto& b) { return b.getAxisDirection(); });
       // Check if autorange for binning applies
       if (m_cfg.extent.has_value()) {
         ACTS_DEBUG("- adapting the proto binning range to the surface extent.");
         adaptBinningRange(binnings, m_cfg.extent.value());
       }
-      ACTS_DEBUG("- 1-dimensional surface binning detected.");
-      // Capture the binning
-      auto binning = binnings[0u];
-      if (binning.boundaryType == Acts::AxisBoundaryType::Closed) {
-        ACTS_VERBOSE("-- closed binning option.");
-        internalCandidatesUpdater =
-            createUpdater<Acts::AxisBoundaryType::Closed>(
-                gctx, internalSurfaces, assignToAll, binning);
-      } else {
-        ACTS_VERBOSE("-- bound binning option.");
-        internalCandidatesUpdater =
-            createUpdater<Acts::AxisBoundaryType::Bound>(gctx, internalSurfaces,
-                                                         assignToAll, binning);
-      }
-    } else if (binnings.size() == 2u) {
-      // Check if autorange for binning applies
-      if (m_cfg.extent.has_value()) {
-        ACTS_DEBUG(
-            "- adapting the proto binning range(s) to the surface extent.");
-        adaptBinningRange(binnings, m_cfg.extent.value());
-      }
-      // Sort the binning for conventions
-      std::ranges::sort(binnings, {}, [](const auto& b) { return b.axisDir; });
 
-      ACTS_DEBUG("- 2-dimensional surface binning detected.");
-      // Capture the binnings
-      const auto& binning0 = binnings[0u];
-      const auto& binning1 = binnings[1u];
+      // Provide a reference generator
+      Acts::Experimental::detail::PolyhedronReferenceGenerator rGenerator;
 
-      if (binning0.boundaryType == Acts::AxisBoundaryType::Closed) {
-        ACTS_VERBOSE("-- closed/bound binning option.");
+      // 1D surface binning
+      if (binnings.size() == 1) {
+        ACTS_DEBUG("- creating a 1D internal binning and portal navigation");
         internalCandidatesUpdater =
-            createUpdater<Acts::AxisBoundaryType::Closed,
-                          Acts::AxisBoundaryType::Bound>(
-                gctx, internalSurfaces, assignToAll, binning0, binning1);
-      } else if (binning1.boundaryType == Acts::AxisBoundaryType::Closed) {
-        ACTS_VERBOSE("-- bound/closed binning option.");
+            Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+                Experimental::IndexedSurfacesNavigation>(
+                gctx, internalSurfaces, rGenerator, binnings.at(0),
+                assignToAll);
+      } else if (binnings.size() == 2u) {
+        ACTS_DEBUG("- creating a 2D internal binning and portal navigation");
         internalCandidatesUpdater =
-            createUpdater<Acts::AxisBoundaryType::Bound,
-                          Acts::AxisBoundaryType::Closed>(
-                gctx, internalSurfaces, assignToAll, binning0, binning1);
+            Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+                Experimental::IndexedSurfacesNavigation>(
+                gctx, internalSurfaces, rGenerator, binnings.at(0),
+                binnings.at(1), assignToAll);
       } else {
-        ACTS_VERBOSE("-- bound/bound binning option.");
-        internalCandidatesUpdater =
-            createUpdater<Acts::AxisBoundaryType::Bound,
-                          Acts::AxisBoundaryType::Bound>(
-                gctx, internalSurfaces, assignToAll, binning0, binning1);
+        throw std::runtime_error(
+            "LayerStructureBuilder: only 1D or 2D surface binning "
+            "supported.");
       }
     }
   } else {
diff --git a/Core/src/Detector/MultiWireStructureBuilder.cpp b/Core/src/Detector/MultiWireStructureBuilder.cpp
index 6ff673f958a..c3b38037293 100644
--- a/Core/src/Detector/MultiWireStructureBuilder.cpp
+++ b/Core/src/Detector/MultiWireStructureBuilder.cpp
@@ -10,8 +10,6 @@
 
 #include "Acts/Detector/DetectorComponents.hpp"
 #include "Acts/Detector/DetectorVolumeBuilder.hpp"
-#include "Acts/Detector/LayerStructureBuilder.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Detector/VolumeStructureBuilder.hpp"
 #include "Acts/Detector/detail/IndexedSurfacesGenerator.hpp"
 #include "Acts/Detector/detail/ReferenceGenerators.hpp"
@@ -21,7 +19,8 @@
 #include "Acts/Geometry/VolumeBounds.hpp"
 #include "Acts/Navigation/DetectorVolumeFinders.hpp"
 #include "Acts/Navigation/InternalNavigation.hpp"
-#include "Acts/Utilities/GridAxisGenerators.hpp"
+#include "Acts/Utilities/Axis.hpp"
+#include "Acts/Utilities/Grid.hpp"
 #include "Acts/Utilities/Logger.hpp"
 
 #include <algorithm>
@@ -38,7 +37,7 @@ class MultiWireInternalStructureBuilder
     std::vector<std::shared_ptr<Acts::Surface>> iSurfaces;
 
     /// Definition of Binning
-    std::vector<Acts::Experimental::ProtoBinning> binning;
+    std::vector<Acts::ProtoAxis> binning;
 
     /// Extra information, mainly for screen output
     std::string auxiliary = "";
@@ -65,26 +64,64 @@ class MultiWireInternalStructureBuilder
 
     Acts::Experimental::ExternalNavigationDelegate internalVolumeUpdater =
         Acts::Experimental::tryNoVolumes();
-    // Create the indexed surfaces
-    auto internalSurfaces = m_cfg.iSurfaces;
-    Acts::Experimental::detail::IndexedSurfacesGenerator<
-        decltype(internalSurfaces),
-        Acts::Experimental::MultiLayerSurfacesNavigation>
-        isg{internalSurfaces,
-            {},
-            {m_cfg.binning[0u].axisDir, m_cfg.binning[1u].axisDir},
-            {m_cfg.binning[0u].expansion, m_cfg.binning[1u].expansion},
-            m_cfg.transform};
+
+    if (m_cfg.binning.size() < 2) {
+      throw std::runtime_error(
+          "MultiWireStructureBuilder: At least 2 binning axes required");
+    }
+
+    const auto& iaxisA = m_cfg.binning[0].getAxis();
+    const auto& iaxisB = m_cfg.binning[1].getAxis();
+    // Binning needs to be equidistant
+    if (iaxisA.getType() != Acts::AxisType::Equidistant ||
+        iaxisB.getType() != Acts::AxisType::Equidistant) {
+      throw std::runtime_error(
+          "MultiWireStructureBuilder: Binning axes need to be equidistant");
+    }
+
+    Acts::Axis<Acts::AxisType::Equidistant, Acts::AxisBoundaryType::Bound>
+        axisA(iaxisA.getBinEdges().front(), iaxisA.getBinEdges().back(),
+              iaxisA.getNBins());
+
+    Acts::Axis<Acts::AxisType::Equidistant, Acts::AxisBoundaryType::Bound>
+        axisB(iaxisB.getBinEdges().front(), iaxisB.getBinEdges().back(),
+              iaxisB.getNBins());
+
+    Acts::Grid<std::vector<std::size_t>, decltype(axisA), decltype(axisB)> grid(
+        axisA, axisB);
+
+    // Prepare the indexed updator
+    std::array<Acts::AxisDirection, 2u> axisDirs = {
+        m_cfg.binning[0].getAxisDirection(),
+        m_cfg.binning[1].getAxisDirection()};
+    Acts::Experimental::MultiLayerSurfacesNavigation<decltype(grid)>
+        indexedSurfaces(std::move(grid), axisDirs, m_cfg.transform);
+
+    std::vector<std::size_t> fillExpansion = {
+        m_cfg.binning[0].getFillExpansion(),
+        m_cfg.binning[1].getFillExpansion()};
+
     Acts::Experimental::detail::CenterReferenceGenerator rGenerator;
-    Acts::GridAxisGenerators::EqBoundEqBound aGenerator{
-        {m_cfg.binning[0u].edges.front(), m_cfg.binning[0u].edges.back()},
-        m_cfg.binning[0u].edges.size() - 1,
-        {m_cfg.binning[1u].edges.front(), m_cfg.binning[1u].edges.back()},
-        m_cfg.binning[1u].edges.size() - 1};
+    Acts::Experimental::detail::IndexedGridFiller filler{fillExpansion};
+    filler.fill(gctx, indexedSurfaces, m_cfg.iSurfaces, rGenerator, {});
+
+    Acts::Experimental::InternalNavigationDelegate sfCandidatesUpdater;
+
+    // The portal delegate
+    Acts::Experimental::AllPortalsNavigation allPortals;
+
+    // The chained delegate: indexed surfaces and all portals
+    using DelegateType =
+        Acts::Experimental::IndexedSurfacesAllPortalsNavigation<
+            decltype(grid), Acts::Experimental::MultiLayerSurfacesNavigation>;
+    auto indexedSurfacesAllPortals = std::make_unique<const DelegateType>(
+        std::tie(allPortals, indexedSurfaces));
 
-    auto sfCandidatesUpdater = isg(gctx, aGenerator, rGenerator);
+    // Create the delegate and connect it
+    sfCandidatesUpdater.connect<&DelegateType::update>(
+        std::move(indexedSurfacesAllPortals));
 
-    return {internalSurfaces,
+    return {m_cfg.iSurfaces,
             {},
             std::move(sfCandidatesUpdater),
             std::move(internalVolumeUpdater)};
diff --git a/Core/src/Detector/detail/ProtoMaterialHelper.cpp b/Core/src/Detector/detail/ProtoMaterialHelper.cpp
index 5cb3ad59c6f..b1f3131e73f 100644
--- a/Core/src/Detector/detail/ProtoMaterialHelper.cpp
+++ b/Core/src/Detector/detail/ProtoMaterialHelper.cpp
@@ -8,28 +8,26 @@
 
 #include "Acts/Detector/detail/ProtoMaterialHelper.hpp"
 
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Material/ProtoSurfaceMaterial.hpp"
 #include "Acts/Surfaces/Surface.hpp"
 
-Acts::Experimental::BinningDescription
+std::vector<Acts::ProtoAxis>
 Acts::Experimental::detail::ProtoMaterialHelper::attachProtoMaterial(
     const GeometryContext& gctx, Surface& surface,
-    const BinningDescription& bDescription) {
+    const std::vector<ProtoAxis>& bDescription) {
   // The binning description, with eventually fixed range
-  BinningDescription fbDescription;
+  std::vector<ProtoAxis> fbDescription;
   // Measure the surface
   Extent sExtent = surface.polyhedronRepresentation(gctx, 1).extent();
-  for (const auto& b : bDescription.binning) {
-    ProtoBinning fBinning = b;
+  for (const auto& b : bDescription) {
+    ProtoAxis fBinning(b);
     // Check if the binning needs to be fixed
-    if (fBinning.autorange) {
-      auto range = sExtent.range(b.axisDir);
-      fBinning = ProtoBinning(b.axisDir, b.boundaryType, range.min(),
-                              range.max(), b.bins(), b.expansion);
+    if (fBinning.isAutorange()) {
+      auto range = sExtent.range(b.getAxisDirection());
+      fBinning.setRange(range.min(), range.max());
     }
-    fbDescription.binning.push_back(fBinning);
+    fbDescription.emplace_back(fBinning);
   }
   // Create the new proto material description and assign it
   auto protoMaterial =
diff --git a/Core/src/Geometry/MaterialDesignatorBlueprintNode.cpp b/Core/src/Geometry/MaterialDesignatorBlueprintNode.cpp
index 4bf4c3f8445..cb764be767a 100644
--- a/Core/src/Geometry/MaterialDesignatorBlueprintNode.cpp
+++ b/Core/src/Geometry/MaterialDesignatorBlueprintNode.cpp
@@ -8,13 +8,13 @@
 
 #include "Acts/Geometry/MaterialDesignatorBlueprintNode.hpp"
 
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Geometry/CylinderVolumeBounds.hpp"
 #include "Acts/Geometry/Portal.hpp"
 #include "Acts/Material/ProtoSurfaceMaterial.hpp"
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/GraphViz.hpp"
 #include "Acts/Utilities/Helpers.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 namespace Acts {
 
@@ -46,41 +46,41 @@ Volume& MaterialDesignatorBlueprintNode::build(const BlueprintOptions& options,
 }
 
 void MaterialDesignatorBlueprintNode::handleCylinderBinning(
+
     CylinderPortalShell& cylShell,
     const std::vector<
-        std::tuple<CylinderPortalShell::Face, Experimental::ProtoBinning,
-                   Experimental::ProtoBinning>>& binning,
+        std::tuple<CylinderPortalShell::Face, ProtoAxis, ProtoAxis>>& binning,
     const Logger& logger) {
   ACTS_DEBUG(prefix() << "Binning is set to compatible type");
   using enum CylinderVolumeBounds::Face;
 
   for (auto& [face, loc0, loc1] : binning) {
     if (face == OuterCylinder || face == InnerCylinder) {
-      if (loc0.axisDir != AxisDirection::AxisRPhi) {
+      if (loc0.getAxisDirection() != AxisDirection::AxisRPhi) {
         ACTS_ERROR(prefix() << "Binning is not in RPhi");
         throw std::runtime_error("Binning is not in RPhi");
       }
 
-      if (loc1.axisDir != AxisDirection::AxisZ) {
+      if (loc1.getAxisDirection() != AxisDirection::AxisZ) {
         ACTS_ERROR(prefix() << "Binning is not in Z");
         throw std::runtime_error("Binning is not in Z");
       }
     }
 
     if (face == PositiveDisc || face == NegativeDisc) {
-      if (loc0.axisDir != AxisDirection::AxisR) {
+      if (loc0.getAxisDirection() != AxisDirection::AxisR) {
         ACTS_ERROR(prefix() << "Binning is not in R");
         throw std::runtime_error("Binning is not in R");
       }
-      if (loc1.axisDir != AxisDirection::AxisPhi) {
+      if (loc1.getAxisDirection() != AxisDirection::AxisPhi) {
         ACTS_ERROR(prefix() << "Binning is not in Phi");
         throw std::runtime_error("Binning is not in Phi");
       }
     }
 
-    Experimental::BinningDescription desc{.binning = {loc0, loc1}};
-    ACTS_DEBUG(prefix() << "~> Assigning proto binning " << desc.toString()
-                        << " to face " << face);
+    std::vector<ProtoAxis> desc{loc0, loc1};
+    ACTS_DEBUG(prefix() << "~> Assigning proto binning " << desc << " to face "
+                        << face);
 
     auto material = std::make_shared<ProtoGridSurfaceMaterial>(std::move(desc));
 
@@ -118,8 +118,8 @@ PortalShellBase& MaterialDesignatorBlueprintNode::connect(
     ACTS_DEBUG(prefix() << "Connecting cylinder shell");
 
     if (const auto* binning = std::get_if<std::vector<
-            std::tuple<CylinderPortalShell::Face, Experimental::ProtoBinning,
-                       Experimental::ProtoBinning>>>(&m_binning.value());
+            std::tuple<CylinderPortalShell::Face, ProtoAxis, ProtoAxis>>>(
+            &m_binning.value());
         binning != nullptr) {
       handleCylinderBinning(*cylShell, *binning, logger);
     } else {
@@ -159,13 +159,14 @@ void MaterialDesignatorBlueprintNode::addToGraphviz(std::ostream& os) const {
 
   std::visit(
       overloaded{
-          [&](const std::vector<
-              std::tuple<CylinderPortalShell::Face, Experimental::ProtoBinning,
-                         Experimental::ProtoBinning>>& binning) {
+          [&](const std::vector<std::tuple<CylinderPortalShell::Face, ProtoAxis,
+                                           ProtoAxis>>& binning) {
             for (const auto& [face, loc0, loc1] : binning) {
               ss << "<br/>" << face;
-              ss << ": " << loc0.axisDir << "=" << loc0.bins();
-              ss << ", " << loc1.axisDir << "=" << loc1.bins();
+              ss << ": " << loc0.getAxisDirection() << "="
+                 << loc0.getAxis().getNBins();
+              ss << ", " << loc1.getAxisDirection() << "="
+                 << loc1.getAxis().getNBins();
             }
           },
           [](const auto& /*binning*/) {
diff --git a/Core/src/Material/BinnedSurfaceMaterialAccumulater.cpp b/Core/src/Material/BinnedSurfaceMaterialAccumulater.cpp
index a4d2366b743..5a2a794a37b 100644
--- a/Core/src/Material/BinnedSurfaceMaterialAccumulater.cpp
+++ b/Core/src/Material/BinnedSurfaceMaterialAccumulater.cpp
@@ -53,7 +53,7 @@ Acts::BinnedSurfaceMaterialAccumulater::createState() const {
     // Second attempt from ProtoGridSurfaceMaterial
     auto psgm = dynamic_cast<const ProtoGridSurfaceMaterial*>(surfaceMaterial);
     if (psgm != nullptr) {
-      auto binUtility = psgm->binning().toBinUtility();
+      BinUtility binUtility(psgm->binning());
       // Screen output for Binned Surface material
       ACTS_DEBUG("       - (proto) binning from ProtoGridSurfaceMaterial is "
                  << binUtility);
diff --git a/Core/src/Utilities/ProtoAxis.cpp b/Core/src/Utilities/ProtoAxis.cpp
index ab6661ce3ad..313ea340e70 100644
--- a/Core/src/Utilities/ProtoAxis.cpp
+++ b/Core/src/Utilities/ProtoAxis.cpp
@@ -26,26 +26,73 @@ void checkConsistency(Acts::AxisDirection aDir, Acts::AxisBoundaryType abType) {
 }  // namespace
 
 Acts::ProtoAxis::ProtoAxis(AxisDirection aDir, Acts::AxisBoundaryType abType,
-                           const std::vector<double>& edges)
-    : m_axisDir(aDir), m_axis(IAxis::createVariable(abType, edges)) {
+                           const std::vector<double>& edges,
+                           std::size_t fillExpansion)
+    : m_axisDir(aDir),
+      m_axis(IAxis::createVariable(abType, edges)),
+      m_fillExpansion(fillExpansion) {
   checkConsistency(aDir, abType);
 }
 
 Acts::ProtoAxis::ProtoAxis(AxisDirection aDir, AxisBoundaryType abType,
-                           double minE, double maxE, std::size_t nbins)
+                           double minE, double maxE, std::size_t nbins,
+                           std::size_t fillExpansion)
     : m_axisDir(aDir),
-      m_axis(IAxis::createEquidistant(abType, minE, maxE, nbins)) {
+      m_axis(IAxis::createEquidistant(abType, minE, maxE, nbins)),
+      m_fillExpansion(fillExpansion) {
   checkConsistency(aDir, abType);
 }
 
 Acts::ProtoAxis::ProtoAxis(AxisDirection aDir, AxisBoundaryType abType,
-                           std::size_t nbins)
+                           std::size_t nbins, std::size_t fillExpansion)
     : m_axisDir(aDir),
       m_axis(IAxis::createEquidistant(abType, 0., 1., nbins)),
-      m_autorange(true) {
+      m_autorange(true),
+      m_fillExpansion(fillExpansion) {
   checkConsistency(aDir, abType);
 }
 
+Acts::ProtoAxis::ProtoAxis(const ProtoAxis& other)
+    : m_axisDir(other.m_axisDir),
+      m_autorange(other.m_autorange),
+      m_fillExpansion(other.m_fillExpansion) {
+  const auto& axis = other.getAxis();
+  if (!m_autorange) {
+    const auto& edges = axis.getBinEdges();
+    if (axis.getType() == AxisType::Variable) {
+      m_axis = IAxis::createVariable(axis.getBoundaryType(), edges);
+    } else {
+      m_axis = IAxis::createEquidistant(axis.getBoundaryType(), edges.front(),
+                                        edges.back(), axis.getNBins());
+    }
+  } else {
+    m_axis = IAxis::createEquidistant(axis.getBoundaryType(), 0., 1.,
+                                      axis.getNBins());
+  }
+}
+
+Acts::ProtoAxis& Acts::ProtoAxis::operator=(const ProtoAxis& other) {
+  if (this != &other) {
+    m_axisDir = other.m_axisDir;
+    m_autorange = other.m_autorange;
+    m_fillExpansion = other.m_fillExpansion;
+    const auto& axis = other.getAxis();
+    if (!m_autorange) {
+      const auto& edges = axis.getBinEdges();
+      if (axis.getType() == AxisType::Variable) {
+        m_axis = IAxis::createVariable(axis.getBoundaryType(), edges);
+      } else {
+        m_axis = IAxis::createEquidistant(axis.getBoundaryType(), edges.front(),
+                                          edges.back(), axis.getNBins());
+      }
+    } else {
+      m_axis = IAxis::createEquidistant(axis.getBoundaryType(), 0., 1.,
+                                        axis.getNBins());
+    }
+  }
+  return *this;
+}
+
 Acts::AxisDirection Acts::ProtoAxis::getAxisDirection() const {
   return m_axisDir;
 }
@@ -55,15 +102,30 @@ const Acts::IAxis& Acts::ProtoAxis::getAxis() const {
 }
 
 void Acts::ProtoAxis::setRange(double minE, double maxE) {
-  if (!m_autorange) {
-    throw std::invalid_argument("ProtoAxis::setRange: Range is already set.");
-  }
-  if (m_axis->getType() != AxisType::Equidistant) {
+  if (minE > maxE) {
     throw std::invalid_argument(
-        "ProtoAxis::setRange: Range can only be set for equidistant binning.");
+        "ProtoAxis::setRange: minE > maxE is not allowed.");
   }
-  m_axis = IAxis::createEquidistant(m_axis->getBoundaryType(), minE, maxE,
-                                    m_axis->getNBins());
+
+  if (m_axis->getType() == AxisType::Equidistant) {
+    m_axis = IAxis::createEquidistant(m_axis->getBoundaryType(), minE, maxE,
+                                      m_axis->getNBins());
+  } else {
+    std::vector<double> edges = m_axis->getBinEdges();
+    // Clip it to min/max
+    edges.erase(std::remove_if(edges.begin(), edges.end(),
+                               [minE, maxE](double e) -> bool {
+                                 return (e < minE || e > maxE);
+                               }),
+                edges.end());
+    // Add the min and max
+    edges.emplace_back(minE);
+    edges.emplace_back(maxE);
+    std::ranges::sort(edges);
+    m_axis = IAxis::createVariable(m_axis->getBoundaryType(), edges);
+  }
+
+  // Force autorange to be false
   m_autorange = false;
 }
 
@@ -71,6 +133,10 @@ bool Acts::ProtoAxis::isAutorange() const {
   return m_autorange;
 }
 
+std::size_t Acts::ProtoAxis::getFillExpansion() const {
+  return m_fillExpansion;
+}
+
 void Acts::ProtoAxis::toStream(std::ostream& os) const {
   os << toString();
 }
@@ -90,3 +156,18 @@ std::string Acts::ProtoAxis::toString() const {
   }
   return ss.str();
 }
+
+// ostream operator implementation
+std::ostream& Acts::operator<<(std::ostream& os, const ProtoAxis& a) {
+  os << a.toString();
+  return os;
+}
+
+// ostream operator implementation
+std::ostream& Acts::operator<<(std::ostream& os,
+                               const std::vector<ProtoAxis>& as) {
+  for (const auto& a : as) {
+    os << a.toString() << '\n';
+  }
+  return os;
+}
diff --git a/Examples/Python/python/acts/examples/detector.py b/Examples/Python/python/acts/examples/detector.py
index d52c6795d5d..d323067d02b 100644
--- a/Examples/Python/python/acts/examples/detector.py
+++ b/Examples/Python/python/acts/examples/detector.py
@@ -6,7 +6,7 @@
     logging,
     Binning,
     Extent,
-    ProtoBinning,
+    ProtoAxis,
     LayerStructureBuilder,
     VolumeBoundsType,
     VolumeStructureBuilder,
@@ -24,9 +24,7 @@ def phiBinning(phiBins, extraBins=1):
     :param extraBins: number of phi bins
 
     """
-    return ProtoBinning(
-        Binning.phi, Binning.closed, -math.pi, math.pi, phiBins, extraBins
-    )
+    return ProtoAxis(Binning.phi, Binning.closed, -math.pi, math.pi, phiBins, extraBins)
 
 
 class CylindricalDetectorVolume:
diff --git a/Examples/Python/python/acts/examples/odd_light.py b/Examples/Python/python/acts/examples/odd_light.py
index c12118ba970..133b712e721 100644
--- a/Examples/Python/python/acts/examples/odd_light.py
+++ b/Examples/Python/python/acts/examples/odd_light.py
@@ -13,7 +13,7 @@
     KdtSurfaces2D,
     KdtSurfacesProvider2D,
     IndexedRootVolumeFinderBuilder,
-    ProtoBinning,
+    ProtoAxis,
 )
 
 
@@ -180,7 +180,7 @@ def get_detector(geoContext, ssurfaces, psurfaces, llevel=acts.logging.DEBUG):
     bpRrange = [detRrange[0], 25.0]
     bpExtent = Extent([[Binning.r, bpRrange], [Binning.z, detZrange]])
     bpProvider = KdtSurfacesProvider2D(passivesKdt, bpExtent)
-    bpBinning = [ProtoBinning(Binning.r, Binning.bound, 0, 25, 1, 0)]
+    bpBinning = [ProtoAxis(Binning.r, Binning.bound, 0, 25, 1, 0)]
     bp = detector.CylindricalDetectorVolume(
         "ODD_beampipe", bpExtent, bpProvider, bpBinning, [], llevel
     )
@@ -191,12 +191,12 @@ def get_detector(geoContext, ssurfaces, psurfaces, llevel=acts.logging.DEBUG):
     pixNecPositionsZ = [-1520, -1320, -1120, -980, -840, -720, -620]
     pixNecHalfThickness = 5
     pixNecBinning = [
-        ProtoBinning(Binning.r, Binning.bound, 40, 175, 2, 1),
+        ProtoAxis(Binning.r, Binning.bound, 40, 175, 2, 1),
         detector.phiBinning(56, 1),
     ]
     pixBarrelPositionsR = [34, 70, 116, 172]
     pixBarrelHalfThickness = 5
-    pixBarrelZbinning = ProtoBinning(Binning.z, Binning.bound, -500, 500, 14, 1)
+    pixBarrelZbinning = ProtoAxis(Binning.z, Binning.bound, -500, 500, 14, 1)
     pixBarrelPhiBinnings = [[16, 1], [32, 1], [52, 1], [78, 1]]
     pixBarrelBinning = [
         [pixBarrelZbinning, detector.phiBinning(phiBinning[0], phiBinning[1])]
@@ -222,7 +222,7 @@ def get_detector(geoContext, ssurfaces, psurfaces, llevel=acts.logging.DEBUG):
     pstRrange = [pixRrange[1], 220]
     pstExtent = Extent([[Binning.r, pstRrange], [Binning.z, detZrange]])
     pstProvider = KdtSurfacesProvider2D(passivesKdt, pstExtent)
-    pstBinning = [ProtoBinning(Binning.r, Binning.bound, pixRrange[1], 220, 1, 0)]
+    pstBinning = [ProtoAxis(Binning.r, Binning.bound, pixRrange[1], 220, 1, 0)]
     pst = detector.CylindricalDetectorVolume(
         "ODD_pst", pstExtent, pstProvider, pstBinning, [], llevel
     )
@@ -234,12 +234,12 @@ def get_detector(geoContext, ssurfaces, psurfaces, llevel=acts.logging.DEBUG):
     sstripNecPositionsZ = [-2950, -2550, -2200, -1850, -1550, -1300]
     sstripNecHalfThickness = 15
     sstripNecBinning = [
-        ProtoBinning(Binning.r, Binning.bound, 230, 710, 3, 1),
+        ProtoAxis(Binning.r, Binning.bound, 230, 710, 3, 1),
         detector.phiBinning(40, 1),
     ]
     sstripBarrelPositionsR = [260, 360, 500, 660]
     sstripBarrelHalfThickness = 25
-    sstripBarrelZbinning = ProtoBinning(Binning.z, Binning.bound, -1100, 1100, 21, 1)
+    sstripBarrelZbinning = ProtoAxis(Binning.z, Binning.bound, -1100, 1100, 21, 1)
     sstripBarrelPhiBinnings = [[40, 1], [56, 1], [78, 1], [102, 1]]
     sstripBarrelBinning = [
         [sstripBarrelZbinning, detector.phiBinning(phiBinning[0], phiBinning[1])]
@@ -269,12 +269,12 @@ def get_detector(geoContext, ssurfaces, psurfaces, llevel=acts.logging.DEBUG):
     lstripNecPositionsZ = [-3000, -2600, -2250, -1900, -1600, -1300]
     lstripNecHalfThickness = 15
     lstripNecBinning = [
-        ProtoBinning(Binning.r, Binning.bound, 720, 1020, 2, 1),
+        ProtoAxis(Binning.r, Binning.bound, 720, 1020, 2, 1),
         detector.phiBinning(40, 1),
     ]
     lstripBarrelPositionsR = [830, 1030]
     lstripBarrelHalfThickness = 35
-    lstripBarrelZbinning = ProtoBinning(Binning.z, Binning.bound, -1100, 1100, 21, 1)
+    lstripBarrelZbinning = ProtoAxis(Binning.z, Binning.bound, -1100, 1100, 21, 1)
     lstripBarrelPhiBinnings = [[40, 1], [56, 1]]
     lstripBarrelBinning = [
         [lstripBarrelZbinning, detector.phiBinning(phiBinning[0], phiBinning[1])]
diff --git a/Examples/Python/src/Geometry.cpp b/Examples/Python/src/Geometry.cpp
index 0b7834e78db..d7a45cb4580 100644
--- a/Examples/Python/src/Geometry.cpp
+++ b/Examples/Python/src/Geometry.cpp
@@ -389,7 +389,7 @@ void addExperimentalGeometry(Context& ctx) {
 
   {
     // Be able to construct a proto binning
-    py::class_<ProtoBinning>(m, "ProtoBinning")
+    py::class_<ProtoAxis>(m, "ProtoAxis")
         .def(py::init<Acts::AxisDirection, Acts::AxisBoundaryType,
                       const std::vector<double>&, std::size_t>(),
              "bValue"_a, "bType"_a, "e"_a, "exp"_a = 0u)
diff --git a/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp b/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp
index b22a97f49e3..4e738ace0b3 100644
--- a/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp
+++ b/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp
@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include "Acts/Detector/detail/IndexedSurfacesGenerator.hpp"
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/Geometry/GeometryHierarchyMap.hpp"
diff --git a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepBinningHelpers.hpp b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepBinningHelpers.hpp
index 6ea2372780e..bb550ff5831 100644
--- a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepBinningHelpers.hpp
+++ b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepBinningHelpers.hpp
@@ -9,11 +9,11 @@
 #pragma once
 
 #include "Acts/Definitions/Units.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Plugins/DD4hep/DD4hepConversionHelpers.hpp"
 #include "Acts/Utilities/AxisDefinitions.hpp"
 #include "Acts/Utilities/BinningData.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <optional>
 #include <sstream>
@@ -78,13 +78,13 @@ inline std::vector<AxisDirection> stringToAxisDirections(
 
 namespace DD4hepBinningHelpers {
 
-/// @brief This method converts the DD4hep binning into the Acts ProtoBinning
+/// @brief This method converts the DD4hep binning into the Acts ProtoAxis
 ///
 /// @param dd4hepElement the element which has a binning description attached
 /// @param bname the binning base name, e.g. surface_binning, material_binning
 ///
 /// @return a vector of proto binning descriptions
-std::vector<Acts::Experimental::ProtoBinning> convertBinning(
+std::vector<Acts::ProtoAxis> convertBinning(
     const dd4hep::DetElement &dd4hepElement, const std::string &bname);
 
 }  // namespace DD4hepBinningHelpers
diff --git a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepDetectorSurfaceFactory.hpp b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepDetectorSurfaceFactory.hpp
index 8cff5250363..6c4b4039d3f 100644
--- a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepDetectorSurfaceFactory.hpp
+++ b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepDetectorSurfaceFactory.hpp
@@ -14,10 +14,10 @@
 #include "Acts/Definitions/Common.hpp"
 #include "Acts/Definitions/Units.hpp"
 #include "Acts/Detector/LayerStructureBuilder.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/BinningData.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <tuple>
 #include <vector>
@@ -62,7 +62,7 @@ class DD4hepDetectorSurfaceFactory {
     /// matching and conversion statistics: materials
     std::size_t convertedMaterials = 0;
     /// The collected binnings
-    std::vector<Experimental::ProtoBinning> binnings = {};
+    std::vector<ProtoAxis> binnings = {};
     /// The collected supports
     std::vector<Experimental::ProtoSupport> supports = {};
     /// Optionally provide an Extent object to measure the sensitives
diff --git a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepLayerStructure.hpp b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepLayerStructure.hpp
index 9cb5a61a005..31c0d6889c4 100644
--- a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepLayerStructure.hpp
+++ b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepLayerStructure.hpp
@@ -10,12 +10,12 @@
 
 #include "Acts/Definitions/Units.hpp"
 #include "Acts/Detector/LayerStructureBuilder.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Plugins/DD4hep/DD4hepDetectorElement.hpp"
 #include "Acts/Plugins/DD4hep/DD4hepDetectorSurfaceFactory.hpp"
 #include "Acts/Utilities/BinningData.hpp"
 #include "Acts/Utilities/Logger.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <memory>
 #include <optional>
diff --git a/Plugins/DD4hep/src/DD4hepBinningHelpers.cpp b/Plugins/DD4hep/src/DD4hepBinningHelpers.cpp
index ea1c33e6bd9..d264cd8d75d 100644
--- a/Plugins/DD4hep/src/DD4hepBinningHelpers.cpp
+++ b/Plugins/DD4hep/src/DD4hepBinningHelpers.cpp
@@ -10,11 +10,10 @@
 
 #include <numbers>
 
-std::vector<Acts::Experimental::ProtoBinning>
-Acts::DD4hepBinningHelpers::convertBinning(
+std::vector<Acts::ProtoAxis> Acts::DD4hepBinningHelpers::convertBinning(
     const dd4hep::DetElement &dd4hepElement, const std::string &bname) {
   // Return proto binning vector
-  std::vector<Experimental::ProtoBinning> protoBinnings;
+  std::vector<ProtoAxis> protoBinnings;
 
   for (const auto &[ab, bVal] : allowedBinnings) {
     auto type =
@@ -34,8 +33,7 @@ Acts::DD4hepBinningHelpers::convertBinning(
       // Equidistant binning
       if (aType == AxisType::Equidistant) {
         if (autoRange) {
-          protoBinnings.push_back(
-              Experimental::ProtoBinning(bVal, bType, nBins, nExpansion));
+          protoBinnings.emplace_back(ProtoAxis(bVal, bType, nBins, nExpansion));
         } else {
           // Equidistant binning
           double minDefault =
@@ -51,8 +49,8 @@ Acts::DD4hepBinningHelpers::convertBinning(
               (max - min) > 1.9 * std::numbers::pi) {
             bType = Acts::AxisBoundaryType::Closed;
           }
-          protoBinnings.push_back(Experimental::ProtoBinning(
-              bVal, bType, min, max, nBins, nExpansion));
+          protoBinnings.emplace_back(
+              ProtoAxis(bVal, bType, min, max, nBins, nExpansion));
         }
       } else {
         // Variable binning
@@ -66,8 +64,7 @@ Acts::DD4hepBinningHelpers::convertBinning(
             (edges.back() - edges.front()) > 1.9 * std::numbers::pi) {
           bType = Acts::AxisBoundaryType::Closed;
         }
-        protoBinnings.push_back(
-            Experimental::ProtoBinning(bVal, bType, edges, nExpansion));
+        protoBinnings.emplace_back(ProtoAxis(bVal, bType, edges, nExpansion));
       }
     }
   }
diff --git a/Plugins/DD4hep/src/DD4hepBlueprintFactory.cpp b/Plugins/DD4hep/src/DD4hepBlueprintFactory.cpp
index 28431f61043..9ff5e42f0bf 100644
--- a/Plugins/DD4hep/src/DD4hepBlueprintFactory.cpp
+++ b/Plugins/DD4hep/src/DD4hepBlueprintFactory.cpp
@@ -119,12 +119,12 @@ void Acts::Experimental::DD4hepBlueprintFactory::recursiveParse(
         if (protoMaterial) {
           ACTS_VERBOSE(ofs << " - proto material binning for portal " << p
                            << " found");
-          auto pmProtoBinnings = DD4hepBinningHelpers::convertBinning(
+          auto pmProtoAxiss = DD4hepBinningHelpers::convertBinning(
               dd4hepElement, pmName + "_binning");
           current->portalMaterialBinning[p] =
-              BinningDescription{pmProtoBinnings};
+              std::vector<ProtoAxis>{pmProtoAxiss};
           ACTS_VERBOSE(ofs << " - binning description is "
-                           << current->portalMaterialBinning[p].toString());
+                           << current->portalMaterialBinning[p]);
         }
       }
 
diff --git a/Plugins/DD4hep/src/DD4hepDetectorSurfaceFactory.cpp b/Plugins/DD4hep/src/DD4hepDetectorSurfaceFactory.cpp
index 7f0275ed1a8..a27278411a7 100644
--- a/Plugins/DD4hep/src/DD4hepDetectorSurfaceFactory.cpp
+++ b/Plugins/DD4hep/src/DD4hepDetectorSurfaceFactory.cpp
@@ -155,10 +155,9 @@ void Acts::DD4hepDetectorSurfaceFactory::attachSurfaceMaterial(
       getParamOr<bool>(prefix + "_proto_material", dd4hepElement, false);
   if (protoMaterial) {
     ACTS_VERBOSE(" - proto material binning for passive surface found.");
-    Experimental::BinningDescription pmBinning{
-        DD4hepBinningHelpers::convertBinning(
-            dd4hepElement, prefix + "_proto_material_binning")};
-    ACTS_VERBOSE(" - converted binning is " << pmBinning.toString());
+    std::vector<ProtoAxis> pmBinning{DD4hepBinningHelpers::convertBinning(
+        dd4hepElement, prefix + "_proto_material_binning")};
+    ACTS_VERBOSE(" - converted binning is " << pmBinning);
     Experimental::detail::ProtoMaterialHelper::attachProtoMaterial(
         gctx, surface, pmBinning);
 
diff --git a/Plugins/DD4hep/src/DD4hepLayerStructure.cpp b/Plugins/DD4hep/src/DD4hepLayerStructure.cpp
index 5546df6d8c0..cc985dc46b0 100644
--- a/Plugins/DD4hep/src/DD4hepLayerStructure.cpp
+++ b/Plugins/DD4hep/src/DD4hepLayerStructure.cpp
@@ -68,15 +68,15 @@ Acts::Experimental::DD4hepLayerStructure::builder(
     // Check if the binning
     ACTS_VERBOSE("Checking if surface binning ranges can be patched.");
     for (auto& b : fCache.binnings) {
-      if (extent.constrains(b.axisDir)) {
-        ACTS_VERBOSE("Binning '" << axisDirectionName(b.axisDir)
+      if (extent.constrains(b.getAxisDirection())) {
+        ACTS_VERBOSE("Binning '" << axisDirectionName(b.getAxisDirection())
                                  << "' is patched.");
-        ACTS_VERBOSE(" <- from : [" << b.edges.front() << ", " << b.edges.back()
-                                    << "]");
-        b.edges.front() = extent.min(b.axisDir);
-        b.edges.back() = extent.max(b.axisDir);
-        ACTS_VERBOSE(" -> to   : [" << b.edges.front() << ", " << b.edges.back()
-                                    << "]");
+        ACTS_VERBOSE(" <- from : [" << b.getAxis().getBinEdges().front() << ", "
+                                    << b.getAxis().getBinEdges().back() << "]");
+        b.setRange(extent.min(b.getAxisDirection()),
+                   extent.max(b.getAxisDirection()));
+        ACTS_VERBOSE(" -> to   : [" << b.getAxis().getBinEdges().front() << ", "
+                                    << b.getAxis().getBinEdges().back() << "]");
       }
     }
   }
diff --git a/Plugins/GeoModel/include/Acts/Plugins/GeoModel/detail/GeoModelBinningHelper.hpp b/Plugins/GeoModel/include/Acts/Plugins/GeoModel/detail/GeoModelBinningHelper.hpp
index 5a50754673e..54967cf0b13 100644
--- a/Plugins/GeoModel/include/Acts/Plugins/GeoModel/detail/GeoModelBinningHelper.hpp
+++ b/Plugins/GeoModel/include/Acts/Plugins/GeoModel/detail/GeoModelBinningHelper.hpp
@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Utilities/BinningType.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <exception>
 #include <optional>
@@ -44,9 +44,8 @@ inline AxisDirection toAxisDirection(const std::string& binning) {
 /// @param binning the binning string
 /// @param extent the extent of the binning
 ///
-/// @return a ProtoBinning object
-Acts::Experimental::ProtoBinning toProtoBinning(
-    const std::string& binning,
-    const std::optional<Extent>& extent = std::nullopt);
+/// @return a ProtoAxis object
+Acts::ProtoAxis toProtoAxis(const std::string& binning,
+                            const std::optional<Extent>& extent = std::nullopt);
 
 }  // namespace Acts::detail::GeoModelBinningHelper
diff --git a/Plugins/GeoModel/src/GeoModelBlueprintCreater.cpp b/Plugins/GeoModel/src/GeoModelBlueprintCreater.cpp
index 293757b51be..82f0c134941 100644
--- a/Plugins/GeoModel/src/GeoModelBlueprintCreater.cpp
+++ b/Plugins/GeoModel/src/GeoModelBlueprintCreater.cpp
@@ -195,8 +195,7 @@ Acts::GeoModelBlueprintCreater::createNode(
   std::string entryType = entryTypeSplit[0u];
 
   // Check if material has to be attached
-  std::map<unsigned int, Experimental::BinningDescription>
-      portalMaterialBinning;
+  std::map<unsigned int, std::vector<ProtoAxis>> portalMaterialBinning;
   if (!entry.materials.empty()) {
     for (const auto& material : entry.materials) {
       std::vector<std::string> materialTokens;
@@ -212,14 +211,14 @@ Acts::GeoModelBlueprintCreater::createNode(
         std::vector<std::string> binningTokens;
         boost::split(binningTokens, materialTokens[1u], boost::is_any_of(";"));
 
-        std::vector<Experimental::ProtoBinning> protoBinnings;
+        std::vector<ProtoAxis> protoBinnings;
         for (const auto& bToken : binningTokens) {
           ACTS_VERBOSE("   - Binning: " << bToken);
           protoBinnings.push_back(
-              detail::GeoModelBinningHelper::toProtoBinning(bToken));
+              detail::GeoModelBinningHelper::toProtoAxis(bToken));
         }
         portalMaterialBinning[portalNumber] =
-            Experimental::BinningDescription{protoBinnings};
+            std::vector<ProtoAxis>{protoBinnings};
       }
     }
     ACTS_VERBOSE("Node " << entry.name << " has "
@@ -385,8 +384,8 @@ Acts::GeoModelBlueprintCreater::createInternalStructureBuilder(
           if (!binning.empty()) {
             ACTS_VERBOSE("- Adding binning: " << binning);
             lsbCfg.binnings.push_back(
-                detail::GeoModelBinningHelper::toProtoBinning(binning,
-                                                              internalExtent));
+                detail::GeoModelBinningHelper::toProtoAxis(binning,
+                                                           internalExtent));
           }
         }
       } else {
diff --git a/Plugins/GeoModel/src/detail/GeoModelBinningHelper.cpp b/Plugins/GeoModel/src/detail/GeoModelBinningHelper.cpp
index d6c7551a174..7259dbcaf3c 100644
--- a/Plugins/GeoModel/src/detail/GeoModelBinningHelper.cpp
+++ b/Plugins/GeoModel/src/detail/GeoModelBinningHelper.cpp
@@ -12,8 +12,7 @@
 
 #include <boost/algorithm/string.hpp>
 
-Acts::Experimental::ProtoBinning
-Acts::detail::GeoModelBinningHelper::toProtoBinning(
+Acts::ProtoAxis Acts::detail::GeoModelBinningHelper::toProtoAxis(
     const std::string& binning, const std::optional<Extent>& extent) {
   std::vector<std::string> binningTokens;
   boost::split(binningTokens, binning, boost::is_any_of(","));
@@ -75,8 +74,7 @@ Acts::detail::GeoModelBinningHelper::toProtoBinning(
     }
   }
 
-  return autoRange ? Experimental::ProtoBinning(bValue, boundaryType, nBins,
-                                                nExpansion)
-                   : Experimental::ProtoBinning(bValue, boundaryType, rangeMin,
-                                                rangeMax, nBins, nExpansion);
+  return autoRange ? ProtoAxis(bValue, boundaryType, nBins, nExpansion)
+                   : ProtoAxis(bValue, boundaryType, rangeMin, rangeMax, nBins,
+                               nExpansion);
 }
diff --git a/Plugins/Json/include/Acts/Plugins/Json/IndexedSurfacesJsonConverter.hpp b/Plugins/Json/include/Acts/Plugins/Json/IndexedSurfacesJsonConverter.hpp
index 2511218af3f..f7861b2dd46 100644
--- a/Plugins/Json/include/Acts/Plugins/Json/IndexedSurfacesJsonConverter.hpp
+++ b/Plugins/Json/include/Acts/Plugins/Json/IndexedSurfacesJsonConverter.hpp
@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include "Acts/Detector/detail/IndexedSurfacesGenerator.hpp"
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/Navigation/InternalNavigation.hpp"
diff --git a/Tests/UnitTests/Core/Detector/CMakeLists.txt b/Tests/UnitTests/Core/Detector/CMakeLists.txt
index 0c51456d7e4..05a45e9a15f 100644
--- a/Tests/UnitTests/Core/Detector/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Detector/CMakeLists.txt
@@ -20,7 +20,6 @@ add_unittest(LayerStructureBuilder LayerStructureBuilderTests.cpp)
 add_unittest(ReferenceGenerators ReferenceGeneratorsTests.cpp)
 add_unittest(SupportSurfacesHelper SupportSurfacesHelperTests.cpp)
 add_unittest(ProtoDetector ProtoDetectorTests.cpp)
-add_unittest(ProtoBinning ProtoBinningTests.cpp)
 add_unittest(DetectorPortal PortalTests.cpp)
 add_unittest(PortalGenerators PortalGeneratorsTests.cpp)
 add_unittest(VolumeStructureBuilder VolumeStructureBuilderTests.cpp)
diff --git a/Tests/UnitTests/Core/Detector/CuboidalContainerBuilderTests.cpp b/Tests/UnitTests/Core/Detector/CuboidalContainerBuilderTests.cpp
index bc803685b2c..f5e81e8eb4a 100644
--- a/Tests/UnitTests/Core/Detector/CuboidalContainerBuilderTests.cpp
+++ b/Tests/UnitTests/Core/Detector/CuboidalContainerBuilderTests.cpp
@@ -13,7 +13,6 @@
 #include "Acts/Detector/DetectorComponents.hpp"
 #include "Acts/Detector/DetectorVolume.hpp"
 #include "Acts/Detector/PortalGenerators.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Detector/interface/IDetectorComponentBuilder.hpp"
 #include "Acts/Detector/interface/IGeometryIdGenerator.hpp"
 #include "Acts/Geometry/CuboidVolumeBounds.hpp"
@@ -27,6 +26,7 @@
 #include "Acts/Utilities/BinningType.hpp"
 #include "Acts/Utilities/Enumerate.hpp"
 #include "Acts/Utilities/Logger.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <array>
 #include <memory>
diff --git a/Tests/UnitTests/Core/Detector/CylindricalContainerBuilderTests.cpp b/Tests/UnitTests/Core/Detector/CylindricalContainerBuilderTests.cpp
index 52a93cfc0ea..8c046dc112c 100644
--- a/Tests/UnitTests/Core/Detector/CylindricalContainerBuilderTests.cpp
+++ b/Tests/UnitTests/Core/Detector/CylindricalContainerBuilderTests.cpp
@@ -13,7 +13,6 @@
 #include "Acts/Detector/DetectorComponents.hpp"
 #include "Acts/Detector/DetectorVolume.hpp"
 #include "Acts/Detector/PortalGenerators.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Detector/interface/IDetectorComponentBuilder.hpp"
 #include "Acts/Detector/interface/IGeometryIdGenerator.hpp"
 #include "Acts/Geometry/CylinderVolumeBounds.hpp"
@@ -30,6 +29,7 @@
 #include "Acts/Utilities/BinningType.hpp"
 #include "Acts/Utilities/Enumerate.hpp"
 #include "Acts/Utilities/Logger.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <any>
 #include <cmath>
@@ -130,10 +130,10 @@ BOOST_AUTO_TEST_CASE(CylindricaContainerBuildingZ) {
   tripleZCfg.binning = {AxisDirection::AxisZ};
   tripleZCfg.geoIdGenerator = std::make_shared<VolumeGeoIdGenerator>();
   // Create a materialBinning
-  tripleZCfg.portalMaterialBinning[2u] = BinningDescription{
-      {ProtoBinning(AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound, 50),
-       ProtoBinning(AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
-                    -std::numbers::pi, std::numbers::pi, 12)}};
+  tripleZCfg.portalMaterialBinning[2u] = std::vector<ProtoAxis>{
+      {ProtoAxis(AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound, 50),
+       ProtoAxis(AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
+                 -std::numbers::pi, std::numbers::pi, 12)}};
 
   // Let's test the reverse generation
   tripleZCfg.geoIdReverseGen = true;
diff --git a/Tests/UnitTests/Core/Detector/DetectorVolumeBuilderTests.cpp b/Tests/UnitTests/Core/Detector/DetectorVolumeBuilderTests.cpp
index c23abf8339e..b3d91afba1a 100644
--- a/Tests/UnitTests/Core/Detector/DetectorVolumeBuilderTests.cpp
+++ b/Tests/UnitTests/Core/Detector/DetectorVolumeBuilderTests.cpp
@@ -160,10 +160,10 @@ BOOST_AUTO_TEST_CASE(DetectorVolumeBuilder_EmptyVolume) {
   dvCfg.internalsBuilder = nullptr;
 
   // Assign proto material to
-  dvCfg.portalMaterialBinning[2u] = BinningDescription{
-      {ProtoBinning(AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound, 50),
-       ProtoBinning(AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
-                    -std::numbers::pi, std::numbers::pi, 12)}};
+  dvCfg.portalMaterialBinning[2u] = std::vector<ProtoAxis>{
+      {ProtoAxis(AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound, 50),
+       ProtoAxis(AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
+                 -std::numbers::pi, std::numbers::pi, 12)}};
 
   auto dvBuilder = std::make_shared<DetectorVolumeBuilder>(
       dvCfg, getDefaultLogger("DetectorVolumeBuilder", Logging::VERBOSE));
diff --git a/Tests/UnitTests/Core/Detector/IndexedSurfacesGeneratorTests.cpp b/Tests/UnitTests/Core/Detector/IndexedSurfacesGeneratorTests.cpp
index 4d0bbe9634e..0751afea6eb 100644
--- a/Tests/UnitTests/Core/Detector/IndexedSurfacesGeneratorTests.cpp
+++ b/Tests/UnitTests/Core/Detector/IndexedSurfacesGeneratorTests.cpp
@@ -25,7 +25,7 @@
 #include "Acts/Utilities/Delegate.hpp"
 #include "Acts/Utilities/Enumerate.hpp"
 #include "Acts/Utilities/Grid.hpp"
-#include "Acts/Utilities/GridAxisGenerators.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <array>
 #include <cmath>
@@ -52,17 +52,20 @@ BOOST_AUTO_TEST_CASE(RingDisc1D) {
   CylindricalTrackingGeometry::DetectorStore dStore;
   auto rSurfaces = cGeometry.surfacesRing(dStore, 6.4, 12.4, 36., 0.125, 0.,
                                           55., 0., 2., 22u);
-
-  IndexedSurfacesGenerator<decltype(rSurfaces), IndexedSurfacesNavigation>
-      irSurfaces{rSurfaces, {}, {AxisDirection::AxisPhi}};
-
-  GridAxisGenerators::EqClosed aGenerator{{-std::numbers::pi, std::numbers::pi},
-                                          44u};
+  // Polyhedron reference generator
   PolyhedronReferenceGenerator<1u, true> rGenerator;
-
-  auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
-
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
+  // A single proto axis clused in phi with 44 bins
+  ProtoAxis pAxis(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                  -std::numbers::pi, std::numbers::pi, 44u);
+
+  auto indexedRing =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          IndexedSurfacesNavigation, decltype(rSurfaces), decltype(rGenerator)>(
+          tContext, rSurfaces, rGenerator, pAxis);
+
+  using GridType =
+      Grid<std::vector<std::size_t>,
+           Axis<Acts::AxisType::Equidistant, Acts::AxisBoundaryType::Closed>>;
   using DelegateType =
       IndexedSurfacesAllPortalsNavigation<GridType, IndexedSurfacesNavigation>;
 
@@ -94,21 +97,24 @@ BOOST_AUTO_TEST_CASE(RingDisc1DWithSupport) {
   auto rSurfaces = cGeometry.surfacesRing(dStore, 6.4, 12.4, 36., 0.125, 0.,
                                           55., 0., 2., 22u);
 
-  auto rBounds = std::make_shared<RadialBounds>(20., 20.);
+  auto rBounds = std::make_shared<RadialBounds>(10., 20.);
   auto dSurface = Surface::makeShared<DiscSurface>(Transform3::Identity(),
                                                    std::move(rBounds));
   rSurfaces.push_back(dSurface.get());
 
-  IndexedSurfacesGenerator<decltype(rSurfaces), IndexedSurfacesNavigation>
-      irSurfaces{rSurfaces, {rSurfaces.size() - 1u}, {AxisDirection::AxisPhi}};
-
-  GridAxisGenerators::EqClosed aGenerator{{-std::numbers::pi, std::numbers::pi},
-                                          44u};
+  // Polyhedron reference generator
   PolyhedronReferenceGenerator<1u, true> rGenerator;
-
-  auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
-
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
+  // A single proto axis clused in phi with 44 bins
+  ProtoAxis pAxis(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                  -std::numbers::pi, std::numbers::pi, 44u);
+  auto indexedRing =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          Experimental::IndexedSurfacesNavigation>(
+          tContext, rSurfaces, rGenerator, pAxis, {rSurfaces.size() - 1u});
+
+  using GridType =
+      Grid<std::vector<std::size_t>,
+           Axis<Acts::AxisType::Equidistant, Acts::AxisBoundaryType::Closed>>;
 
   using DelegateType =
       IndexedSurfacesAllPortalsNavigation<GridType, IndexedSurfacesNavigation>;
@@ -147,16 +153,22 @@ BOOST_AUTO_TEST_CASE(RingDisc2D) {
   decltype(rSurfacesR0) rSurfaces = rSurfacesR0;
   rSurfaces.insert(rSurfaces.end(), rSurfacesR1.begin(), rSurfacesR1.end());
 
-  IndexedSurfacesGenerator<decltype(rSurfaces), IndexedSurfacesNavigation>
-      irSurfaces{rSurfaces, {}, {AxisDirection::AxisR, AxisDirection::AxisPhi}};
+  ProtoAxis pAxisR(AxisDirection::AxisR, AxisBoundaryType::Bound,
+                   {24., 74., 110});
+  ProtoAxis pAxisPhi(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                     -std::numbers::pi, std::numbers::pi, 44u);
 
-  GridAxisGenerators::VarBoundEqClosed aGenerator{
-      {24., 74., 110.}, {-std::numbers::pi, std::numbers::pi}, 44u};
   PolyhedronReferenceGenerator<1u, true> rGenerator;
 
-  auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
+  auto indexedRing =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          Experimental::IndexedSurfacesNavigation>(
+          tContext, rSurfaces, rGenerator, pAxisR, pAxisPhi);
 
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
+  using GridType =
+      Grid<std::vector<std::size_t>,
+           Axis<Acts::AxisType::Variable, Acts::AxisBoundaryType::Bound>,
+           Axis<Acts::AxisType::Equidistant, Acts::AxisBoundaryType::Closed>>;
 
   using DelegateType =
       IndexedSurfacesAllPortalsNavigation<GridType, IndexedSurfacesNavigation>;
@@ -193,17 +205,21 @@ BOOST_AUTO_TEST_CASE(RingDisc2DFine) {
   rSurfaces.insert(rSurfaces.end(), rSurfacesR1.begin(), rSurfacesR1.end());
   rSurfaces.insert(rSurfaces.end(), rSurfacesR2.begin(), rSurfacesR2.end());
 
-  IndexedSurfacesGenerator<decltype(rSurfaces), IndexedSurfacesNavigation>
-      irSurfaces{rSurfaces, {}, {AxisDirection::AxisR, AxisDirection::AxisPhi}};
-
-  GridAxisGenerators::EqBoundEqClosed aGenerator{
-      {24., 152}, 8u, {-std::numbers::pi, std::numbers::pi}, 88u};
+  ProtoAxis pAxisR(AxisDirection::AxisR, AxisBoundaryType::Bound, 24., 152, 8u);
+  ProtoAxis pAxisPhi(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                     -std::numbers::pi, std::numbers::pi, 88u);
 
   PolyhedronReferenceGenerator<1u, true> rGenerator;
 
-  auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
+  auto indexedRing =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          Experimental::IndexedSurfacesNavigation>(
+          tContext, rSurfaces, rGenerator, pAxisR, pAxisPhi);
 
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
+  using GridType =
+      Grid<std::vector<std::size_t>,
+           Axis<Acts::AxisType::Equidistant, Acts::AxisBoundaryType::Bound>,
+           Axis<Acts::AxisType::Equidistant, Acts::AxisBoundaryType::Closed>>;
 
   using DelegateType =
       IndexedSurfacesAllPortalsNavigation<GridType, IndexedSurfacesNavigation>;
@@ -240,19 +256,23 @@ BOOST_AUTO_TEST_CASE(RingDisc2DFineExpanded) {
   rSurfaces.insert(rSurfaces.end(), rSurfacesR1.begin(), rSurfacesR1.end());
   rSurfaces.insert(rSurfaces.end(), rSurfacesR2.begin(), rSurfacesR2.end());
 
-  IndexedSurfacesGenerator<decltype(rSurfaces), IndexedSurfacesNavigation>
-      irSurfaces{rSurfaces,
-                 {},
-                 {AxisDirection::AxisR, AxisDirection::AxisPhi},
-                 {2u, 4u}};
-
-  GridAxisGenerators::EqBoundEqClosed aGenerator{
-      {24., 152}, 8u, {-std::numbers::pi, std::numbers::pi}, 88u};
   PolyhedronReferenceGenerator<1u, true> rGenerator;
 
-  auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
+  ProtoAxis pAxisR(AxisDirection::AxisR, AxisBoundaryType::Bound, 24., 152, 8u,
+                   2u);
+  ProtoAxis pAxisPhi(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                     -std::numbers::pi, std::numbers::pi, 88u, 4u);
+
+  auto indexedRing =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          Experimental::IndexedSurfacesNavigation>(
+          tContext, rSurfaces, rGenerator, pAxisR, pAxisPhi);
+
+  using GridType =
+      Grid<std::vector<std::size_t>,
+           Axis<Acts::AxisType::Equidistant, Acts::AxisBoundaryType::Bound>,
+           Axis<Acts::AxisType::Equidistant, Acts::AxisBoundaryType::Closed>>;
 
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
   using DelegateType =
       IndexedSurfacesAllPortalsNavigation<GridType, IndexedSurfacesNavigation>;
 
@@ -277,19 +297,22 @@ BOOST_AUTO_TEST_CASE(Cylinder2D) {
   auto surfaces = cGeometry.surfacesCylinder(dStore, 8.4, 36., 0.15, 0.145,
                                              116., 3., 2., {52, 14});
 
-  IndexedSurfacesGenerator<decltype(surfaces), IndexedSurfacesNavigation>
-      icSurfaces{surfaces,
-                 {},
-                 {AxisDirection::AxisZ, AxisDirection::AxisPhi},
-                 {1u, 1u}};
-
-  GridAxisGenerators::EqBoundEqClosed aGenerator{
-      {-500., 500}, 28, {-std::numbers::pi, std::numbers::pi}, 52u};
+  ProtoAxis pAxisZ(AxisDirection::AxisZ, AxisBoundaryType::Bound, -500., 500.,
+                   28u, 1u);
+  ProtoAxis pAxisPhi(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                     -std::numbers::pi, std::numbers::pi, 52u, 1u);
   PolyhedronReferenceGenerator<1u, true> rGenerator;
 
-  auto indexedCylinder = icSurfaces(tContext, aGenerator, rGenerator);
+  auto indexedCylinder =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          Experimental::IndexedSurfacesNavigation>(
+          tContext, surfaces, rGenerator, pAxisZ, pAxisPhi);
+
+  using GridType =
+      Grid<std::vector<std::size_t>,
+           Axis<Acts::AxisType::Equidistant, Acts::AxisBoundaryType::Bound>,
+           Axis<Acts::AxisType::Equidistant, Acts::AxisBoundaryType::Closed>>;
 
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
   using DelegateType =
       IndexedSurfacesAllPortalsNavigation<GridType, IndexedSurfacesNavigation>;
 
diff --git a/Tests/UnitTests/Core/Detector/LayerStructureBuilderTests.cpp b/Tests/UnitTests/Core/Detector/LayerStructureBuilderTests.cpp
index cb36e6cf99f..ba12cd90cbd 100644
--- a/Tests/UnitTests/Core/Detector/LayerStructureBuilderTests.cpp
+++ b/Tests/UnitTests/Core/Detector/LayerStructureBuilderTests.cpp
@@ -67,9 +67,9 @@ BOOST_AUTO_TEST_CASE(LayerStructureBuilder_creationRing) {
   Acts::Experimental::LayerStructureBuilder::Config lsConfig;
   lsConfig.auxiliary = "*** Endcap with 22 surfaces ***";
   lsConfig.surfacesProvider = endcapSurfaces;
-  lsConfig.binnings = {
-      ProtoBinning(Acts::AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
-                   -std::numbers::pi, std::numbers::pi, 22u, 1u)};
+  lsConfig.binnings = {ProtoAxis(Acts::AxisDirection::AxisPhi,
+                                 Acts::AxisBoundaryType::Closed,
+                                 -std::numbers::pi, std::numbers::pi, 22u, 1u)};
 
   auto endcapBuilder = Acts::Experimental::LayerStructureBuilder(
       lsConfig, Acts::getDefaultLogger("EndcapBuilder", Logging::VERBOSE));
@@ -187,12 +187,11 @@ BOOST_AUTO_TEST_CASE(LayerStructureBuilder_creationCylinder) {
   lsConfig.auxiliary = "*** Barrel with 448 surfaces ***";
   lsConfig.surfacesProvider = barrelSurfaces;
   lsConfig.binnings = {
-      Acts::Experimental::ProtoBinning{Acts::AxisDirection::AxisZ,
-                                       Acts::AxisBoundaryType::Bound, -480.,
-                                       480., 14u, 1u},
-      Acts::Experimental::ProtoBinning(
-          Acts::AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
-          -std::numbers::pi, std::numbers::pi, 32u, 1u)};
+      Acts::ProtoAxis{Acts::AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound,
+                      -480., 480., 14u, 1u},
+      Acts::ProtoAxis(Acts::AxisDirection::AxisPhi,
+                      Acts::AxisBoundaryType::Closed, -std::numbers::pi,
+                      std::numbers::pi, 32u, 1u)};
 
   auto barrelBuilder = Acts::Experimental::LayerStructureBuilder(
       lsConfig, Acts::getDefaultLogger("BarrelBuilder", Logging::VERBOSE));
diff --git a/Tests/UnitTests/Core/Detector/MultiWireStructureBuilderTests.cpp b/Tests/UnitTests/Core/Detector/MultiWireStructureBuilderTests.cpp
index 3939908064b..b16445c2149 100644
--- a/Tests/UnitTests/Core/Detector/MultiWireStructureBuilderTests.cpp
+++ b/Tests/UnitTests/Core/Detector/MultiWireStructureBuilderTests.cpp
@@ -72,10 +72,10 @@ BOOST_AUTO_TEST_CASE(Multi_Wire_Structure_Builder_StrawSurfacesCreation) {
   mlCfg.mlSurfaces = strawSurfaces;
   mlCfg.mlBounds = vBounds;
   mlCfg.mlBinning = {
-      ProtoBinning(Acts::AxisDirection::AxisX, Acts::AxisBoundaryType::Bound,
-                   -vBounds[0], vBounds[0], nSurfacesX, 1u),
-      ProtoBinning(Acts::AxisDirection::AxisY, Acts::AxisBoundaryType::Bound,
-                   -vBounds[1], vBounds[1], nSurfacesY, 0u)};
+      ProtoAxis(Acts::AxisDirection::AxisX, Acts::AxisBoundaryType::Bound,
+                -vBounds[0], vBounds[0], nSurfacesX, 1u),
+      ProtoAxis(Acts::AxisDirection::AxisY, Acts::AxisBoundaryType::Bound,
+                -vBounds[1], vBounds[1], nSurfacesY, 0u)};
 
   MultiWireStructureBuilder mlBuilder(mlCfg);
   auto [volumes, portals, roots] = mlBuilder.construct(tContext);
diff --git a/Tests/UnitTests/Core/Detector/ProtoBinningTests.cpp b/Tests/UnitTests/Core/Detector/ProtoBinningTests.cpp
deleted file mode 100644
index 269292acd2d..00000000000
--- a/Tests/UnitTests/Core/Detector/ProtoBinningTests.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-// This file is part of the ACTS project.
-//
-// Copyright (C) 2016 CERN for the benefit of the ACTS project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-#include <boost/test/unit_test.hpp>
-
-#include "Acts/Detector/ProtoBinning.hpp"
-#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
-#include "Acts/Utilities/BinUtility.hpp"
-
-#include <numbers>
-
-using namespace Acts::Experimental;
-
-BOOST_AUTO_TEST_SUITE(Detector)
-
-BOOST_AUTO_TEST_CASE(ProtoBinningPlaceHolderEquidistant) {
-  // A valid placeholder binning
-  auto peq = ProtoBinning(Acts::AxisDirection::AxisX,
-                          Acts::AxisBoundaryType::Bound, 5u);
-  BOOST_CHECK_EQUAL(peq.bins(), 5u);
-}
-
-BOOST_AUTO_TEST_CASE(ProtoBinningEquidistant) {
-  // An invalid binning, 0 bins given
-  BOOST_CHECK_THROW(ProtoBinning(Acts::AxisDirection::AxisX,
-                                 Acts::AxisBoundaryType::Bound, 15., 20., 0),
-                    std::invalid_argument);
-
-  // Another invalid binning, min/max swapped
-  BOOST_CHECK_THROW(ProtoBinning(Acts::AxisDirection::AxisX,
-                                 Acts::AxisBoundaryType::Bound, 150., 20., 10),
-                    std::invalid_argument);
-
-  // A valid binning
-  auto eq = ProtoBinning(Acts::AxisDirection::AxisX,
-                         Acts::AxisBoundaryType::Bound, 0., 10., 5u);
-
-  std::vector<double> reference = {0., 2., 4., 6., 8., 10.};
-  BOOST_CHECK_EQUAL(eq.bins(), 5u);
-  BOOST_CHECK_EQUAL(eq.axisDir, Acts::AxisDirection::AxisX);
-  BOOST_CHECK(eq.axisType == Acts::AxisType::Equidistant);
-  BOOST_CHECK(eq.boundaryType == Acts::AxisBoundaryType::Bound);
-  BOOST_CHECK_EQUAL_COLLECTIONS(eq.edges.begin(), eq.edges.end(),
-                                reference.begin(), reference.end());
-}
-
-BOOST_AUTO_TEST_CASE(ProtoBinningVariable) {
-  // An invalid binning, edge size < 2u
-  std::vector<double> iedges = {12.};
-  BOOST_CHECK_THROW(ProtoBinning(Acts::AxisDirection::AxisX,
-                                 Acts::AxisBoundaryType::Bound, iedges),
-                    std::invalid_argument);
-
-  // A valid binning
-  std::vector<double> varEdges = {0., 12., 13., 15., 20.};
-  auto var = ProtoBinning(Acts::AxisDirection::AxisX,
-                          Acts::AxisBoundaryType::Bound, varEdges);
-
-  BOOST_CHECK_EQUAL(var.bins(), 4u);
-  BOOST_CHECK_EQUAL(var.axisDir, Acts::AxisDirection::AxisX);
-  BOOST_CHECK(var.axisType == Acts::AxisType::Variable);
-  BOOST_CHECK(var.boundaryType == Acts::AxisBoundaryType::Bound);
-  BOOST_CHECK_EQUAL_COLLECTIONS(var.edges.begin(), var.edges.end(),
-                                varEdges.begin(), varEdges.end());
-}
-
-BOOST_AUTO_TEST_CASE(BinningDescriptionFromAndToBinUtility) {
-  // A valid binning
-  Acts::BinUtility bUtility(5u, 0., 10., Acts::open,
-                            Acts::AxisDirection::AxisR);
-  std::vector<float> edges = {-std::numbers::pi, 0.1, std::numbers::pi};
-  bUtility +=
-      Acts::BinUtility(edges, Acts::closed, Acts::AxisDirection::AxisPhi);
-
-  auto bDescription = BinningDescription::fromBinUtility(bUtility);
-
-  BOOST_CHECK_EQUAL(bDescription.binning.size(), 2u);
-
-  // Test the first entry
-  BOOST_CHECK_EQUAL(bDescription.binning[0].bins(), 5u);
-  BOOST_CHECK_EQUAL(bDescription.binning[0].axisDir,
-                    Acts::AxisDirection::AxisR);
-  BOOST_CHECK(bDescription.binning[0].axisType == Acts::AxisType::Equidistant);
-  BOOST_CHECK(bDescription.binning[0].boundaryType ==
-              Acts::AxisBoundaryType::Bound);
-  BOOST_CHECK_EQUAL(bDescription.binning[0].edges.size(), 6u);
-
-  // Check the second entry
-  BOOST_CHECK_EQUAL(bDescription.binning[1].bins(), 2u);
-  BOOST_CHECK_EQUAL(bDescription.binning[1].axisDir,
-                    Acts::AxisDirection::AxisPhi);
-  BOOST_CHECK(bDescription.binning[1].axisType == Acts::AxisType::Variable);
-  BOOST_CHECK(bDescription.binning[1].boundaryType ==
-              Acts::AxisBoundaryType::Closed);
-  BOOST_CHECK_EQUAL(bDescription.binning[1].edges.size(), 3u);
-
-  // Round-trip
-  auto binUtility = bDescription.toBinUtility();
-  BOOST_CHECK_EQUAL(binUtility.binningData().size(), 2u);
-  BOOST_CHECK_EQUAL(binUtility.binningData()[0].bins(), 5u);
-  BOOST_CHECK_EQUAL(binUtility.binningData()[1].bins(), 2u);
-  BOOST_CHECK_EQUAL(binUtility.binningData()[1].boundaries().size(), 3u);
-  CHECK_CLOSE_ABS(binUtility.binningData()[1].boundaries()[0],
-                  -std::numbers::pi, 1e-5);
-  CHECK_CLOSE_ABS(binUtility.binningData()[1].boundaries()[1], 0.1, 1e-4);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/Tests/UnitTests/Core/Geometry/BlueprintApiTests.cpp b/Tests/UnitTests/Core/Geometry/BlueprintApiTests.cpp
index e3f748a07e8..962a0278048 100644
--- a/Tests/UnitTests/Core/Geometry/BlueprintApiTests.cpp
+++ b/Tests/UnitTests/Core/Geometry/BlueprintApiTests.cpp
@@ -13,7 +13,6 @@
 
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Definitions/Units.hpp"
-#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Geometry/Blueprint.hpp"
 #include "Acts/Geometry/CylinderContainerBlueprintNode.hpp"
 #include "Acts/Geometry/CylinderVolumeBounds.hpp"
@@ -30,6 +29,7 @@
 #include "Acts/Surfaces/RectangleBounds.hpp"
 #include "Acts/Tests/CommonHelpers/DetectorElementStub.hpp"
 #include "Acts/Utilities/Logger.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 #include "Acts/Visualization/GeometryView3D.hpp"
 #include "Acts/Visualization/ObjVisualization3D.hpp"
 
@@ -262,11 +262,9 @@ BOOST_AUTO_TEST_CASE(NodeApiTestContainers) {
 
   root->addMaterial("GlobalMaterial", [&](MaterialDesignatorBlueprintNode&
                                               mat) {
-    Experimental::ProtoBinning zBinning{AxisDirection::AxisZ,
-                                        AxisBoundaryType::Bound, 20};
+    ProtoAxis zBinning{AxisDirection::AxisZ, AxisBoundaryType::Bound, 20};
 
-    Experimental::ProtoBinning rPhiBinning{AxisDirection::AxisRPhi,
-                                           AxisBoundaryType::Bound, 20};
+    ProtoAxis rPhiBinning{AxisDirection::AxisRPhi, AxisBoundaryType::Bound, 20};
 
     mat.setBinning(std::vector{std::tuple{
         CylinderVolumeBounds::Face::OuterCylinder, rPhiBinning, zBinning}});
diff --git a/Tests/UnitTests/Core/Geometry/BlueprintTests.cpp b/Tests/UnitTests/Core/Geometry/BlueprintTests.cpp
index 15a6263b8c7..c82d479cc6f 100644
--- a/Tests/UnitTests/Core/Geometry/BlueprintTests.cpp
+++ b/Tests/UnitTests/Core/Geometry/BlueprintTests.cpp
@@ -29,6 +29,7 @@
 #include "Acts/Tests/CommonHelpers/DetectorElementStub.hpp"
 #include "Acts/Utilities/BinningType.hpp"
 #include "Acts/Utilities/Logger.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <fstream>
 #include <stdexcept>
@@ -489,10 +490,10 @@ BOOST_AUTO_TEST_CASE(Material) {
   root.addMaterial("Material", [&](auto& mat) {
     // @TODO: This API is not great
     mat.setBinning(std::vector{
-        std::tuple{NegativeDisc, Experimental::ProtoBinning{AxisR, Bound, 5},
-                   Experimental::ProtoBinning{AxisPhi, Bound, 10}},
-        std::tuple{PositiveDisc, Experimental::ProtoBinning{AxisR, Bound, 15},
-                   Experimental::ProtoBinning{AxisPhi, Bound, 20}},
+        std::tuple{NegativeDisc, ProtoAxis{AxisR, Bound, 5},
+                   ProtoAxis{AxisPhi, Bound, 10}},
+        std::tuple{PositiveDisc, ProtoAxis{AxisR, Bound, 15},
+                   ProtoAxis{AxisPhi, Bound, 20}},
     });
 
     mat.addStaticVolume(std::move(cyl));
@@ -514,10 +515,10 @@ BOOST_AUTO_TEST_CASE(Material) {
   const auto& posDiscMat =
       dynamic_cast<const ProtoGridSurfaceMaterial&>(*posDisc);
 
-  BOOST_CHECK_EQUAL(negDiscMat.binning().binning.at(0).bins(), 5);
-  BOOST_CHECK_EQUAL(negDiscMat.binning().binning.at(1).bins(), 10);
-  BOOST_CHECK_EQUAL(posDiscMat.binning().binning.at(0).bins(), 15);
-  BOOST_CHECK_EQUAL(posDiscMat.binning().binning.at(1).bins(), 20);
+  BOOST_CHECK_EQUAL(negDiscMat.binning().at(0).getAxis().getNBins(), 5);
+  BOOST_CHECK_EQUAL(negDiscMat.binning().at(1).getAxis().getNBins(), 10);
+  BOOST_CHECK_EQUAL(posDiscMat.binning().at(0).getAxis().getNBins(), 15);
+  BOOST_CHECK_EQUAL(posDiscMat.binning().at(1).getAxis().getNBins(), 20);
 
   for (std::size_t i = 2; i < child.portals().size(); i++) {
     BOOST_CHECK_EQUAL(child.portals().at(i).surface().surfaceMaterial(),
diff --git a/Tests/UnitTests/Core/Navigation/MultiWireNavigationTests.cpp b/Tests/UnitTests/Core/Navigation/MultiWireNavigationTests.cpp
index ccce81a5b62..3629ac720ae 100644
--- a/Tests/UnitTests/Core/Navigation/MultiWireNavigationTests.cpp
+++ b/Tests/UnitTests/Core/Navigation/MultiWireNavigationTests.cpp
@@ -76,10 +76,10 @@ BOOST_AUTO_TEST_CASE(Navigation_in_Indexed_Surfaces) {
   mlCfg.mlSurfaces = strawSurfaces;
 
   mlCfg.mlBinning = {
-      ProtoBinning(Acts::AxisDirection::AxisX, Acts::AxisBoundaryType::Bound,
-                   -vBounds[0], vBounds[0], nSurfacesX, 1u),
-      ProtoBinning(Acts::AxisDirection::AxisY, Acts::AxisBoundaryType::Bound,
-                   -vBounds[1], vBounds[1], nSurfacesY, 0u)};
+      ProtoAxis(Acts::AxisDirection::AxisX, Acts::AxisBoundaryType::Bound,
+                -vBounds[0], vBounds[0], nSurfacesX, 1u),
+      ProtoAxis(Acts::AxisDirection::AxisY, Acts::AxisBoundaryType::Bound,
+                -vBounds[1], vBounds[1], nSurfacesY, 0u)};
   mlCfg.mlBounds = vBounds;
 
   MultiWireStructureBuilder mlBuilder(mlCfg);
diff --git a/Tests/UnitTests/Core/Utilities/BinUtilityTests.cpp b/Tests/UnitTests/Core/Utilities/BinUtilityTests.cpp
index ab38d7bd78a..bdb8c6ff8b4 100644
--- a/Tests/UnitTests/Core/Utilities/BinUtilityTests.cpp
+++ b/Tests/UnitTests/Core/Utilities/BinUtilityTests.cpp
@@ -9,8 +9,10 @@
 #include <boost/test/unit_test.hpp>
 
 #include "Acts/Definitions/Algebra.hpp"
+#include "Acts/Utilities/AxisDefinitions.hpp"
 #include "Acts/Utilities/BinUtility.hpp"
 #include "Acts/Utilities/BinningType.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <array>
 #include <cmath>
@@ -130,4 +132,19 @@ BOOST_AUTO_TEST_CASE(BinUtility_transform) {
   }
 }
 
+BOOST_AUTO_TEST_CASE(BinUtility_from_ProtoAxis) {
+  using enum AxisDirection;
+  using enum AxisBoundaryType;
+
+  ProtoAxis epabX(AxisX, Bound, 0.0, 1.0, 10);
+  BinUtility buX(epabX);
+  BOOST_CHECK_EQUAL(buX.bins(), std::size_t{10});
+  BOOST_CHECK_EQUAL(buX.dimensions(), std::size_t{1});
+
+  ProtoAxis epabY(AxisY, Bound, 0.0, 1.0, 10);
+  BinUtility buXY({epabX, epabY});
+  BOOST_CHECK_EQUAL(buXY.bins(), std::size_t{100});
+  BOOST_CHECK_EQUAL(buXY.dimensions(), std::size_t{2});
+}
+
 }  // namespace Acts::Test
diff --git a/Tests/UnitTests/Core/Utilities/BinningDataTests.cpp b/Tests/UnitTests/Core/Utilities/BinningDataTests.cpp
index ff99a53f709..29c9599e701 100644
--- a/Tests/UnitTests/Core/Utilities/BinningDataTests.cpp
+++ b/Tests/UnitTests/Core/Utilities/BinningDataTests.cpp
@@ -10,8 +10,10 @@
 
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
+#include "Acts/Utilities/AxisDefinitions.hpp"
 #include "Acts/Utilities/BinningData.hpp"
 #include "Acts/Utilities/BinningType.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <cmath>
 #include <cstddef>
@@ -422,4 +424,37 @@ BOOST_AUTO_TEST_CASE(BinningData_phi_modules) {
   BOOST_CHECK_EQUAL(phiData_mod.searchGlobal(underscaledPos), std::size_t{4});
 }
 
+// special test for phi binning
+BOOST_AUTO_TEST_CASE(BinningData_from_ProtoAxis) {
+  using enum AxisDirection;
+  using enum AxisBoundaryType;
+
+  // Bound, equidistant axis
+  ProtoAxis epab(AxisX, Bound, 0.0, 1.0, 10);
+  BinningData bEpab(epab);
+
+  BOOST_CHECK_EQUAL(bEpab.bins(), std::size_t{10});
+  BOOST_CHECK_EQUAL(bEpab.min, 0.);
+  BOOST_CHECK_EQUAL(bEpab.max, 1.);
+  BOOST_CHECK(bEpab.binvalue == AxisX);
+  BOOST_CHECK(bEpab.option == open);
+  BOOST_CHECK(bEpab.type == equidistant);
+
+  // Bound, equidistant axis, autorange
+  ProtoAxis epa(AxisY, Bound, 10);
+  BinningData bEpa(epa);
+  BOOST_CHECK(bEpa.binvalue == AxisY);
+  BOOST_CHECK_EQUAL(bEpa.bins(), std::size_t{10});
+  BOOST_CHECK(bEpa.option == open);
+  BOOST_CHECK(bEpa.type == equidistant);
+
+  // Bound, equidistant axis
+  ProtoAxis vpab(AxisZ, Bound, {0.0, 1.0, 10});
+  BinningData bVpab(vpab);
+  BOOST_CHECK(bVpab.binvalue == AxisZ);
+  BOOST_CHECK_EQUAL(bVpab.bins(), std::size_t{2});
+  BOOST_CHECK(bVpab.option == open);
+  BOOST_CHECK(bVpab.type == arbitrary);
+}
+
 }  // namespace Acts::Test
diff --git a/Tests/UnitTests/Core/Utilities/ProtoAxisTests.cpp b/Tests/UnitTests/Core/Utilities/ProtoAxisTests.cpp
index 1460131a7e9..db6e797a1ff 100644
--- a/Tests/UnitTests/Core/Utilities/ProtoAxisTests.cpp
+++ b/Tests/UnitTests/Core/Utilities/ProtoAxisTests.cpp
@@ -51,6 +51,19 @@ BOOST_AUTO_TEST_CASE(EquidistantProtoAxis) {
   std::string oString = epab.toString();
   BOOST_CHECK_EQUAL(rString, oString);
 
+  // Test copy constructor
+  Acts::ProtoAxis epabCopy(epab);
+  BOOST_CHECK_EQUAL(epabCopy.getAxisDirection(), epab.getAxisDirection());
+  BOOST_CHECK_EQUAL(epabCopy.isAutorange(), epab.isAutorange());
+  BOOST_CHECK(epabCopy.getAxis() == epab.getAxis());
+
+  // Test Assignment operator
+  Acts::ProtoAxis epabAssign(AxisX, Bound, 0.0, 50.0, 20);
+  epabAssign = epab;
+  BOOST_CHECK_EQUAL(epabAssign.getAxisDirection(), epab.getAxisDirection());
+  BOOST_CHECK_EQUAL(epabAssign.isAutorange(), epab.isAutorange());
+  BOOST_CHECK(epabAssign.getAxis() == epab.getAxis());
+
   // Create a grid from a single proto axis
   auto grid1D = Acts::makeGrid<double>(epab);
   BOOST_CHECK(grid1D != nullptr);
@@ -127,6 +140,19 @@ BOOST_AUTO_TEST_CASE(AutorangeProtoAxis) {
   std::string oString = epa.toString();
   BOOST_CHECK_EQUAL(rString, oString);
 
+  // Test copy constructor
+  Acts::ProtoAxis epaCopy(epa);
+  BOOST_CHECK_EQUAL(epaCopy.getAxisDirection(), epa.getAxisDirection());
+  BOOST_CHECK_EQUAL(epaCopy.isAutorange(), epa.isAutorange());
+  BOOST_CHECK(epaCopy.getAxis() == epa.getAxis());
+
+  // Test Assignment operator
+  Acts::ProtoAxis epaAssign(AxisX, Bound, 0.0, 50.0, 20);
+  epaAssign = epa;
+  BOOST_CHECK_EQUAL(epaAssign.getAxisDirection(), epa.getAxisDirection());
+  BOOST_CHECK_EQUAL(epaAssign.isAutorange(), epa.isAutorange());
+  BOOST_CHECK(epaAssign.getAxis() == epa.getAxis());
+
   // Invalid 1D grid construction with autorange axis
   BOOST_CHECK_THROW(Acts::makeGrid<double>(epa), std::invalid_argument);
 
@@ -147,6 +173,9 @@ BOOST_AUTO_TEST_CASE(AutorangeProtoAxis) {
 
   // Invalid constructor, closed with something else than phi or rphi
   BOOST_CHECK_THROW(Acts::ProtoAxis(AxisZ, Closed, 10), std::invalid_argument);
+
+  // Invalid setRange, min > max
+  BOOST_CHECK_THROW(epa.setRange(20.0, 0.0), std::invalid_argument);
 }
 
 BOOST_AUTO_TEST_CASE(VariableProtoAxis) {
@@ -184,6 +213,26 @@ BOOST_AUTO_TEST_CASE(VariableProtoAxis) {
   std::string oString = vpab.toString();
   BOOST_CHECK_EQUAL(rString, oString);
 
+  // Test copy constructor
+  Acts::ProtoAxis vpabCopy(vpab);
+  BOOST_CHECK_EQUAL(vpabCopy.getAxisDirection(), vpab.getAxisDirection());
+  BOOST_CHECK_EQUAL(vpabCopy.isAutorange(), vpab.isAutorange());
+  BOOST_CHECK(vpabCopy.getAxis() == vpab.getAxis());
+
+  // Test Assignment operator
+  Acts::ProtoAxis vpabAssign(AxisX, Bound, 0.0, 50.0, 20);
+  vpabAssign = vpab;
+  BOOST_CHECK_EQUAL(vpabAssign.getAxisDirection(), vpab.getAxisDirection());
+  BOOST_CHECK_EQUAL(vpabAssign.isAutorange(), vpab.isAutorange());
+  BOOST_CHECK(vpabAssign.getAxis() == vpab.getAxis());
+
+  // Set Range for variable
+  vpab.setRange(0.5, 9.5);
+  // Bins stay the same. min/max update
+  BOOST_CHECK_EQUAL(vpab.getAxis().getNBins(), 2);
+  CHECK_CLOSE_ABS(vpab.getAxis().getMin(), 0.5, 1e-15);
+  CHECK_CLOSE_ABS(vpab.getAxis().getMax(), 9.5, 1e-15);
+
   // Invalid constructor, min > max
   BOOST_CHECK_THROW(Acts::ProtoAxis(AxisZ, Bound, std::vector<double>{2.}),
                     std::invalid_argument);
diff --git a/Tests/UnitTests/Plugins/ActSVG/DetectorVolumeSvgConverterTests.cpp b/Tests/UnitTests/Plugins/ActSVG/DetectorVolumeSvgConverterTests.cpp
index b3ba0f4f5fc..fca6f89cd6f 100644
--- a/Tests/UnitTests/Plugins/ActSVG/DetectorVolumeSvgConverterTests.cpp
+++ b/Tests/UnitTests/Plugins/ActSVG/DetectorVolumeSvgConverterTests.cpp
@@ -149,7 +149,7 @@ BOOST_AUTO_TEST_CASE(EndcapVolumeWithSurfaces) {
   Acts::Experimental::LayerStructureBuilder::Config lsConfig;
   lsConfig.auxiliary = "*** Endcap with 22 surfaces ***";
   lsConfig.surfacesProvider = endcapSurfaces;
-  lsConfig.binnings = {Acts::Experimental::ProtoBinning(
+  lsConfig.binnings = {Acts::ProtoAxis(
       Acts::AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
       -std::numbers::pi, std::numbers::pi, 22u, 1u)};
 
@@ -220,12 +220,11 @@ BOOST_AUTO_TEST_CASE(BarrelVolumeWithSurfaces) {
   lsConfig.auxiliary = "*** Barrel with 448 surfaces ***";
   lsConfig.surfacesProvider = barrelSurfaces;
   lsConfig.binnings = {
-      Acts::Experimental::ProtoBinning{Acts::AxisDirection::AxisZ,
-                                       Acts::AxisBoundaryType::Bound, -480.,
-                                       480., 14u, 1u},
-      Acts::Experimental::ProtoBinning(
-          Acts::AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
-          -std::numbers::pi, std::numbers::pi, 32u, 1u)};
+      Acts::ProtoAxis{Acts::AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound,
+                      -480., 480., 14u, 1u},
+      Acts::ProtoAxis(Acts::AxisDirection::AxisPhi,
+                      Acts::AxisBoundaryType::Closed, -std::numbers::pi,
+                      std::numbers::pi, 32u, 1u)};
 
   auto barrelBuilder =
       std::make_shared<Acts::Experimental::LayerStructureBuilder>(
diff --git a/Tests/UnitTests/Plugins/ActSVG/IndexedSurfacesSvgConverterTests.cpp b/Tests/UnitTests/Plugins/ActSVG/IndexedSurfacesSvgConverterTests.cpp
index 21066266404..4d1bd500dbe 100644
--- a/Tests/UnitTests/Plugins/ActSVG/IndexedSurfacesSvgConverterTests.cpp
+++ b/Tests/UnitTests/Plugins/ActSVG/IndexedSurfacesSvgConverterTests.cpp
@@ -74,15 +74,15 @@ BOOST_AUTO_TEST_CASE(RingDisc1D) {
   CylindricalTrackingGeometry::DetectorStore dStore;
   auto rSurfaces = cGeometry.surfacesRing(dStore, 6.4, 12.4, 36., 0.125, 0.,
                                           55., 0., 2., 22u);
-
-  IndexedSurfacesGenerator<decltype(rSurfaces), IndexedSurfacesNavigation>
-      irSurfaces{rSurfaces, {}, {AxisDirection::AxisPhi}};
-
-  GridAxisGenerators::EqClosed aGenerator{{-std::numbers::pi, std::numbers::pi},
-                                          44u};
+  // Polyhedron reference generator
   PolyhedronReferenceGenerator<1u, true> rGenerator;
-
-  auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
+  // A single proto axis clused in phi with 44 bins
+  ProtoAxis pAxis(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                  -std::numbers::pi, std::numbers::pi, 44u);
+  auto indexedRing =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          Experimental::IndexedSurfacesNavigation>(tContext, rSurfaces,
+                                                   rGenerator, pAxis);
   // The displaying
   auto pIndexedRing = IndexedSurfacesConverter::convert(
       tContext, rSurfaces, indexedRing, drawOptions);
@@ -96,19 +96,20 @@ BOOST_AUTO_TEST_CASE(RingDisc1DWithSupport) {
   auto rSurfaces = cGeometry.surfacesRing(dStore, 6.4, 12.4, 36., 0.125, 0.,
                                           55., 0., 2., 22u);
 
-  auto rBounds = std::make_shared<RadialBounds>(20., 20.);
+  auto rBounds = std::make_shared<RadialBounds>(10., 20.);
   auto dSurface = Surface::makeShared<DiscSurface>(Transform3::Identity(),
                                                    std::move(rBounds));
   rSurfaces.push_back(dSurface.get());
 
-  IndexedSurfacesGenerator<decltype(rSurfaces), IndexedSurfacesNavigation>
-      irSurfaces{rSurfaces, {rSurfaces.size() - 1u}, {AxisDirection::AxisPhi}};
-
-  GridAxisGenerators::EqClosed aGenerator{{-std::numbers::pi, std::numbers::pi},
-                                          44u};
+  // Polyhedron reference generator
   PolyhedronReferenceGenerator<1u, true> rGenerator;
-
-  auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
+  // A single proto axis clused in phi with 44 bins
+  ProtoAxis pAxis(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                  -std::numbers::pi, std::numbers::pi, 44u);
+  auto indexedRing =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          Experimental::IndexedSurfacesNavigation>(
+          tContext, rSurfaces, rGenerator, pAxis, {rSurfaces.size() - 1u});
   // The displaying
   auto pIndexedRing = IndexedSurfacesConverter::convert(
       tContext, rSurfaces, indexedRing, drawOptions);
@@ -128,14 +129,18 @@ BOOST_AUTO_TEST_CASE(RingDisc2D) {
   decltype(rSurfacesR0) rSurfaces = rSurfacesR0;
   rSurfaces.insert(rSurfaces.end(), rSurfacesR1.begin(), rSurfacesR1.end());
 
-  IndexedSurfacesGenerator<decltype(rSurfaces), IndexedSurfacesNavigation>
-      irSurfaces{rSurfaces, {}, {AxisDirection::AxisR, AxisDirection::AxisPhi}};
+  ProtoAxis pAxisR(AxisDirection::AxisR, AxisBoundaryType::Bound,
+                   {24., 74., 110});
+  ProtoAxis pAxisPhi(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                     -std::numbers::pi, std::numbers::pi, 44u);
 
-  GridAxisGenerators::VarBoundEqClosed aGenerator{
-      {24., 74., 110.}, {-std::numbers::pi, std::numbers::pi}, 44u};
   PolyhedronReferenceGenerator<1u, true> rGenerator;
 
-  auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
+  auto indexedRing =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          Experimental::IndexedSurfacesNavigation>(
+          tContext, rSurfaces, rGenerator, pAxisR, pAxisPhi);
+
   // The displaying
   auto pIndexedRing = IndexedSurfacesConverter::convert(
       tContext, rSurfaces, indexedRing, drawOptions);
@@ -160,14 +165,17 @@ BOOST_AUTO_TEST_CASE(RingDisc2DFine) {
   rSurfaces.insert(rSurfaces.end(), rSurfacesR1.begin(), rSurfacesR1.end());
   rSurfaces.insert(rSurfaces.end(), rSurfacesR2.begin(), rSurfacesR2.end());
 
-  IndexedSurfacesGenerator<decltype(rSurfaces), IndexedSurfacesNavigation>
-      irSurfaces{rSurfaces, {}, {AxisDirection::AxisR, AxisDirection::AxisPhi}};
-
-  GridAxisGenerators::EqBoundEqClosed aGenerator{
-      {24., 152}, 8u, {-std::numbers::pi, std::numbers::pi}, 88u};
+  ProtoAxis pAxisR(AxisDirection::AxisR, AxisBoundaryType::Bound, 24., 152, 8u);
+  ProtoAxis pAxisPhi(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                     -std::numbers::pi, std::numbers::pi, 88u);
 
   PolyhedronReferenceGenerator<1u, true> rGenerator;
-  auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
+
+  auto indexedRing =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          Experimental::IndexedSurfacesNavigation>(
+          tContext, rSurfaces, rGenerator, pAxisR, pAxisPhi);
+
   // The displaying
   auto pIndexedRing = IndexedSurfacesConverter::convert(
       tContext, rSurfaces, indexedRing, drawOptions);
@@ -192,17 +200,18 @@ BOOST_AUTO_TEST_CASE(RingDisc2DFineExpanded) {
   rSurfaces.insert(rSurfaces.end(), rSurfacesR1.begin(), rSurfacesR1.end());
   rSurfaces.insert(rSurfaces.end(), rSurfacesR2.begin(), rSurfacesR2.end());
 
-  IndexedSurfacesGenerator<decltype(rSurfaces), IndexedSurfacesNavigation>
-      irSurfaces{rSurfaces,
-                 {},
-                 {AxisDirection::AxisR, AxisDirection::AxisPhi},
-                 {2u, 4u}};
-
-  GridAxisGenerators::EqBoundEqClosed aGenerator{
-      {24., 152}, 8u, {-std::numbers::pi, std::numbers::pi}, 88u};
   PolyhedronReferenceGenerator<1u, true> rGenerator;
 
-  auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
+  ProtoAxis pAxisR(AxisDirection::AxisR, AxisBoundaryType::Bound, 24., 152, 8u,
+                   2u);
+  ProtoAxis pAxisPhi(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                     -std::numbers::pi, std::numbers::pi, 88u, 4u);
+
+  auto indexedRing =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          Experimental::IndexedSurfacesNavigation>(
+          tContext, rSurfaces, rGenerator, pAxisR, pAxisPhi);
+
   // The displaying
   auto pIndexedRing = IndexedSurfacesConverter::convert(
       tContext, rSurfaces, indexedRing, drawOptions);
@@ -216,17 +225,17 @@ BOOST_AUTO_TEST_CASE(Cylinder2D) {
   auto surfaces = cGeometry.surfacesCylinder(dStore, 8.4, 36., 0.15, 0.145,
                                              116., 3., 2., {52, 14});
 
-  IndexedSurfacesGenerator<decltype(surfaces), IndexedSurfacesNavigation>
-      icSurfaces{surfaces,
-                 {},
-                 {AxisDirection::AxisZ, AxisDirection::AxisPhi},
-                 {1u, 1u}};
-
-  GridAxisGenerators::EqBoundEqClosed aGenerator{
-      {-500., 500}, 28, {-std::numbers::pi, std::numbers::pi}, 52u};
+  ProtoAxis pAxisZ(AxisDirection::AxisZ, AxisBoundaryType::Bound, -500., 500.,
+                   28u, 1u);
+  ProtoAxis pAxisPhi(AxisDirection::AxisPhi, AxisBoundaryType::Closed,
+                     -std::numbers::pi, std::numbers::pi, 52u, 1u);
   PolyhedronReferenceGenerator<1u, true> rGenerator;
 
-  auto indexedCylinder = icSurfaces(tContext, aGenerator, rGenerator);
+  auto indexedCylinder =
+      Acts::detail::IndexedSurfacesGenerator::createInternalNavigation<
+          Experimental::IndexedSurfacesNavigation>(
+          tContext, surfaces, rGenerator, pAxisZ, pAxisPhi);
+
   // The displaying
   auto pIndexeCylinder = IndexedSurfacesConverter::convert(
       tContext, surfaces, indexedCylinder, drawOptions);
diff --git a/Tests/UnitTests/Plugins/Json/DetectorJsonConverterTests.cpp b/Tests/UnitTests/Plugins/Json/DetectorJsonConverterTests.cpp
index 9a9cbcccb67..469f9f7cf9a 100644
--- a/Tests/UnitTests/Plugins/Json/DetectorJsonConverterTests.cpp
+++ b/Tests/UnitTests/Plugins/Json/DetectorJsonConverterTests.cpp
@@ -168,7 +168,7 @@ BOOST_AUTO_TEST_CASE(BeamPipeEndcapBarrelDetector) {
     Acts::Experimental::LayerStructureBuilder::Config lsConfig;
     lsConfig.auxiliary = "*** Endcap with 22 surfaces ***";
     lsConfig.surfacesProvider = endcapSurfaces;
-    lsConfig.binnings = {Acts::Experimental::ProtoBinning(
+    lsConfig.binnings = {Acts::ProtoAxis(
         Acts::AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
         -std::numbers::pi, std::numbers::pi, 22u, 1u)};
 
@@ -231,12 +231,11 @@ BOOST_AUTO_TEST_CASE(BeamPipeEndcapBarrelDetector) {
   lsConfig.auxiliary = "*** Barrel with 448 surfaces ***";
   lsConfig.surfacesProvider = barrelSurfaces;
   lsConfig.binnings = {
-      Acts::Experimental::ProtoBinning{Acts::AxisDirection::AxisZ,
-                                       Acts::AxisBoundaryType::Bound, -480.,
-                                       480., 14u, 1u},
-      Acts::Experimental::ProtoBinning(
-          Acts::AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
-          -std::numbers::pi, std::numbers::pi, 32u, 1u)};
+      Acts::ProtoAxis{Acts::AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound,
+                      -480., 480., 14u, 1u},
+      Acts::ProtoAxis(Acts::AxisDirection::AxisPhi,
+                      Acts::AxisBoundaryType::Closed, -std::numbers::pi,
+                      std::numbers::pi, 32u, 1u)};
 
   auto barrelBuilder =
       std::make_shared<Acts::Experimental::LayerStructureBuilder>(
diff --git a/Tests/UnitTests/Plugins/Json/DetectorVolumeJsonConverterTests.cpp b/Tests/UnitTests/Plugins/Json/DetectorVolumeJsonConverterTests.cpp
index 3713cc46f90..64ee6839081 100644
--- a/Tests/UnitTests/Plugins/Json/DetectorVolumeJsonConverterTests.cpp
+++ b/Tests/UnitTests/Plugins/Json/DetectorVolumeJsonConverterTests.cpp
@@ -148,7 +148,7 @@ BOOST_AUTO_TEST_CASE(EndcapVolumeWithSurfaces) {
   Acts::Experimental::LayerStructureBuilder::Config lsConfig;
   lsConfig.auxiliary = "*** Endcap with 22 surfaces ***";
   lsConfig.surfacesProvider = endcapSurfaces;
-  lsConfig.binnings = {Acts::Experimental::ProtoBinning(
+  lsConfig.binnings = {Acts::ProtoAxis(
       Acts::AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
       -std::numbers::pi, std::numbers::pi, 22u, 1u)};
 
@@ -228,12 +228,11 @@ BOOST_AUTO_TEST_CASE(BarrelVolumeWithSurfaces) {
   lsConfig.auxiliary = "*** Barrel with 448 surfaces ***";
   lsConfig.surfacesProvider = barrelSurfaces;
   lsConfig.binnings = {
-      Acts::Experimental::ProtoBinning{Acts::AxisDirection::AxisZ,
-                                       Acts::AxisBoundaryType::Bound, -480.,
-                                       480., 14u, 1u},
-      Acts::Experimental::ProtoBinning(
-          Acts::AxisDirection::AxisPhi, Acts::AxisBoundaryType::Closed,
-          -std::numbers::pi, std::numbers::pi, 32u, 1u)};
+      Acts::ProtoAxis{Acts::AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound,
+                      -480., 480., 14u, 1u},
+      Acts::ProtoAxis(Acts::AxisDirection::AxisPhi,
+                      Acts::AxisBoundaryType::Closed, -std::numbers::pi,
+                      std::numbers::pi, 32u, 1u)};
 
   auto barrelBuilder =
       std::make_shared<Acts::Experimental::LayerStructureBuilder>(