diff --git a/CI/physmon/workflows/physmon_simulation.py b/CI/physmon/workflows/physmon_simulation.py
index c88d4a081e8..746c68c39aa 100755
--- a/CI/physmon/workflows/physmon_simulation.py
+++ b/CI/physmon/workflows/physmon_simulation.py
@@ -87,7 +87,7 @@
         rnd,
         preSelectParticles=None,
         postSelectParticles=ParticleSelectorConfig(removeSecondaries=True),
-        killVolume=setup.trackingGeometry.worldVolume,
+        killVolume=setup.trackingGeometry.highestTrackingVolume,
         killAfterTime=25 * u.ns,
         killSecondaries=True,
         inputParticles="particles_input",
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f13ea348110..75bb59c4336 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -168,6 +168,10 @@ set_option_if(
   ACTS_BUILD_PLUGIN_JSON
   ACTS_BUILD_PLUGIN_TRACCC
 )
+set_option_if(
+  ACTS_BUILD_PLUGIN_ACTSVG
+  ACTS_BUILD_PLUGIN_TRACCC
+)
 set_option_if(
   ACTS_BUILD_PLUGIN_HASHING
   ACTS_BUILD_EXAMPLES_HASHING
@@ -221,8 +225,7 @@ endif()
 # minimal dependency versions. they are defined here in a single place so
 # they can be easily upgraded, although they might not be used if the
 # dependency is included via `add_subdirectory(...)`.
-set(_acts_actsvg_version 0.4.40)
-set(_acts_autodiff_version 0.6)
+set(_acts_actsvg_version 0.4.47)
 set(_acts_boost_version 1.71.0)
 set(_acts_dd4hep_version 1.21)
 set(_acts_edm4hep_version 0.7)
@@ -232,13 +235,14 @@ set(_acts_podio_version 1.0.1) # will try this first
 set(_acts_podio_fallback_version 0.16) # if not found, will try this one
 set(_acts_doxygen_version 1.9.4)
 set(_acts_hepmc3_version 3.2.1)
-set(_acts_nlohmanjson_version 3.2.0)
+set(_acts_nlohmanjson_version 3.10.5)
 set(_acts_onnxruntime_version 1.12.0)
 set(_acts_root_version 6.20)
 set(_acts_tbb_version 2020.1)
 set(_acts_pythia8_version 8.309)
-set(_acts_detray_version 0.72.0)
-set(_acts_traccc_version 0.13.0)
+set(_acts_pybind11_version 2.13.1)
+set(_acts_detray_version 0.75.2)
+set(_acts_traccc_version 0.16.0)
 set(_acts_covfie_version 0.10.0)
 set(_acts_vecmem_version 1.4.0)
 set(_acts_algebraplugins_version 0.22.0)
diff --git a/CMakePresets.json b/CMakePresets.json
index 35b461e3c93..bee5ab514df 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -96,7 +96,6 @@
             "displayName": "GitLab-CI",
             "inherits": "ci-common",
             "cacheVariables": {
-                "ACTS_BUILD_PLUGIN_ACTSVG": "OFF",
                 "ACTS_BUILD_ODD": "OFF",
                 "ACTS_BUILD_EXAMPLES_PYTHON_BINDINGS": "OFF",
                 "ACTS_RUN_CLANG_TIDY": "ON"
diff --git a/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.ipp b/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.ipp
index 8041188b5cf..3dcf1a20a01 100644
--- a/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.ipp
+++ b/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.ipp
@@ -46,7 +46,7 @@ ScoreBasedAmbiguityResolution::computeInitialState(
 
     for (const auto& ts : track.trackStatesReversed()) {
       if (!ts.hasReferenceSurface()) {
-        ACTS_ERROR("Track state has no reference surface");
+        ACTS_DEBUG("Track state has no reference surface");
         continue;
       }
       auto iVolume = ts.referenceSurface().geometryId().volume();
diff --git a/Core/include/Acts/Clusterization/Clusterization.ipp b/Core/include/Acts/Clusterization/Clusterization.ipp
index 44f8abd1267..16047295912 100644
--- a/Core/include/Acts/Clusterization/Clusterization.ipp
+++ b/Core/include/Acts/Clusterization/Clusterization.ipp
@@ -1,11 +1,12 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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 http://mozilla.org/MPL/2.0/.
 
+#include <algorithm>
 #include <array>
 #include <vector>
 
@@ -273,7 +274,7 @@ void labelClusters(CellCollection& cells, Connect connect) {
   internal::DisjointSets ds{};
 
   // Sort cells by position to enable in-order scan
-  std::sort(cells.begin(), cells.end(), internal::Compare<Cell, GridDim>());
+  std::ranges::sort(cells, internal::Compare<Cell, GridDim>());
 
   // First pass: Allocate labels and record equivalences
   for (auto it = cells.begin(); it != cells.end(); ++it) {
@@ -308,9 +309,7 @@ ClusterCollection mergeClusters(CellCollection& cells) {
   if constexpr (GridDim > 1) {
     // Sort the cells by their cluster label, only needed if more than
     // one spatial dimension
-    std::sort(cells.begin(), cells.end(), [](Cell& lhs, Cell& rhs) {
-      return getCellLabel(lhs) < getCellLabel(rhs);
-    });
+    std::ranges::sort(cells, {}, [](Cell& c) { return getCellLabel(c); });
   }
 
   return internal::mergeClustersImpl<CellCollection, ClusterCollection>(cells);
diff --git a/Core/include/Acts/Detector/detail/IndexedGridFiller.hpp b/Core/include/Acts/Detector/detail/IndexedGridFiller.hpp
index b79cafa93ad..c8f7d416f31 100644
--- a/Core/include/Acts/Detector/detail/IndexedGridFiller.hpp
+++ b/Core/include/Acts/Detector/detail/IndexedGridFiller.hpp
@@ -17,6 +17,7 @@
 #include "Acts/Utilities/Delegate.hpp"
 #include "Acts/Utilities/Enumerate.hpp"
 #include "Acts/Utilities/GridAccessHelpers.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Utilities/IAxis.hpp"
 #include "Acts/Utilities/Logger.hpp"
 
@@ -193,7 +194,7 @@ struct IndexedGridFiller {
     // Loop over the surfaces to be filled
     for (auto [io, o] : enumerate(iObjects)) {
       // Exclude indices that should be handled differently
-      if (std::find(aToAll.begin(), aToAll.end(), io) != aToAll.end()) {
+      if (rangeContainsValue(aToAll, io)) {
         continue;
       }
       // Get the reference positions
@@ -216,7 +217,7 @@ struct IndexedGridFiller {
       // Now fill the surface indices
       for (const auto& li : lIndices) {
         auto& bContent = iGrid.grid.atLocalBins(li);
-        if (std::find(bContent.begin(), bContent.end(), io) == bContent.end()) {
+        if (!rangeContainsValue(bContent, io)) {
           bContent.push_back(io);
         }
       }
@@ -238,7 +239,7 @@ struct IndexedGridFiller {
     for (std::size_t gi = 0; gi < iGrid.grid.size(true); ++gi) {
       auto& bContent = iGrid.grid.at(gi);
       for (const auto& io : idcs) {
-        if (std::find(bContent.begin(), bContent.end(), io) == bContent.end()) {
+        if (!rangeContainsValue(bContent, io)) {
           bContent.push_back(io);
         }
       }
diff --git a/Core/include/Acts/EventData/MultiTrajectory.hpp b/Core/include/Acts/EventData/MultiTrajectory.hpp
index 4b1add782b1..0499f66bc6a 100644
--- a/Core/include/Acts/EventData/MultiTrajectory.hpp
+++ b/Core/include/Acts/EventData/MultiTrajectory.hpp
@@ -87,6 +87,12 @@ class TrackStateRange {
       }
     }
 
+    Iterator operator++(int) {
+      Iterator tmp(*this);
+      operator++();
+      return tmp;
+    }
+
     bool operator==(const Iterator& other) const {
       if (!proxy && !other.proxy) {
         return true;
@@ -109,6 +115,9 @@ class TrackStateRange {
   Iterator begin() { return m_begin; }
   Iterator end() { return Iterator{std::nullopt}; }
 
+  Iterator cbegin() const { return m_begin; }
+  Iterator cend() const { return Iterator{std::nullopt}; }
+
  private:
   Iterator m_begin;
 };
@@ -689,13 +698,10 @@ class MultiTrajectory {
     self().allocateCalibrated_impl(istate, measdim);
   }
 
-  // This function will move to an rvalue reference in the next major version
-  template <typename source_link_t>
-  void setUncalibratedSourceLink(IndexType istate, source_link_t&& sourceLink)
+  void setUncalibratedSourceLink(IndexType istate, SourceLink&& sourceLink)
     requires(!ReadOnly)
   {
-    self().setUncalibratedSourceLink_impl(
-        istate, std::forward<source_link_t>(sourceLink));
+    self().setUncalibratedSourceLink_impl(istate, std::move(sourceLink));
   }
 
   SourceLink getUncalibratedSourceLink(IndexType istate) const {
diff --git a/Core/include/Acts/EventData/MultiTrajectoryHelpers.hpp b/Core/include/Acts/EventData/MultiTrajectoryHelpers.hpp
index 84d4c763a7b..2a5fac9b2d6 100644
--- a/Core/include/Acts/EventData/MultiTrajectoryHelpers.hpp
+++ b/Core/include/Acts/EventData/MultiTrajectoryHelpers.hpp
@@ -14,6 +14,7 @@
 #include "Acts/Geometry/Layer.hpp"
 #include "Acts/Geometry/TrackingVolume.hpp"
 #include "Acts/Surfaces/Surface.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 
 #include <functional>
 #include <unordered_map>
@@ -102,8 +103,7 @@ VolumeTrajectoryStateContainer trajectoryState(
     const auto& volume = geoID.volume();
     const auto& layer = geoID.layer();
     // Check if the track info for this sub-detector is requested
-    auto it = std::find(volumeIds.begin(), volumeIds.end(), volume);
-    if (it == volumeIds.end()) {
+    if (!rangeContainsValue(volumeIds, volume)) {
       return true;
     }
     // The trajectory state for this volume
diff --git a/Core/include/Acts/EventData/TrackStateProxy.hpp b/Core/include/Acts/EventData/TrackStateProxy.hpp
index 8e62d07f2eb..7b90e0a1ac9 100644
--- a/Core/include/Acts/EventData/TrackStateProxy.hpp
+++ b/Core/include/Acts/EventData/TrackStateProxy.hpp
@@ -767,25 +767,12 @@ class TrackStateProxy {
   /// @return The uncalibrated measurement source link
   SourceLink getUncalibratedSourceLink() const;
 
-  // This function will move to an rvalue reference in the next major version
   /// Set an uncalibrated source link
   /// @param sourceLink The uncalibrated source link to set
-  template <typename source_link_t>
-  void setUncalibratedSourceLink(source_link_t&& sourceLink)
+  void setUncalibratedSourceLink(SourceLink&& sourceLink)
     requires(!ReadOnly)
   {
-    m_traj->setUncalibratedSourceLink(m_istate,
-                                      std::forward<source_link_t>(sourceLink));
-  }
-
-  /// Set an uncalibrated source link
-  /// @param sourceLink The uncalibrated source link to set
-  /// @note Use the overload with an rvalue reference, this
-  ///       overload will be removed ith the next major version
-  void setUncalibratedSourceLink(const SourceLink& sourceLink)
-    requires(!ReadOnly)
-  {
-    m_traj->setUncalibratedSourceLink(m_istate, SourceLink{sourceLink});
+    m_traj->setUncalibratedSourceLink(m_istate, std::move(sourceLink));
   }
 
   /// Check if the point has an associated uncalibrated measurement.
diff --git a/Core/include/Acts/Geometry/GeometryHierarchyMap.hpp b/Core/include/Acts/Geometry/GeometryHierarchyMap.hpp
index 1106761d372..b2b10b9e52f 100644
--- a/Core/include/Acts/Geometry/GeometryHierarchyMap.hpp
+++ b/Core/include/Acts/Geometry/GeometryHierarchyMap.hpp
@@ -64,13 +64,13 @@ class GeometryHierarchyMap {
   /// Combined geometry identifier and value element. Only used for input.
   using InputElement = typename std::pair<GeometryIdentifier, value_t>;
   using Iterator = typename std::vector<value_t>::const_iterator;
-  using Size = typename std::vector<value_t>::size_type;
   using Value = value_t;
 
   /// Construct the container from the given elements.
   ///
   /// @param elements input elements (must be unique with respect to identifier)
   GeometryHierarchyMap(std::vector<InputElement> elements);
+
   /// Construct the container from an initializer list.
   ///
   /// @param elements input initializer list
@@ -86,21 +86,25 @@ class GeometryHierarchyMap {
 
   /// Return an iterator pointing to the beginning of the stored values.
   Iterator begin() const { return m_values.begin(); }
+
   /// Return an iterator pointing to the end of the stored values.
   Iterator end() const { return m_values.end(); }
+
   /// Check if any elements are stored.
   bool empty() const { return m_values.empty(); }
+
   /// Return the number of stored elements.
-  Size size() const { return m_values.size(); }
+  std::size_t size() const { return m_values.size(); }
 
   /// Access the geometry identifier for the i-th element with bounds check.
   ///
   /// @throws std::out_of_range for invalid indices
-  GeometryIdentifier idAt(Size index) const { return m_ids.at(index); }
+  GeometryIdentifier idAt(std::size_t index) const { return m_ids.at(index); }
+
   /// Access the value of the i-th element in the container with bounds check.
   ///
   /// @throws std::out_of_range for invalid indices
-  const Value& valueAt(Size index) const { return m_values.at(index); }
+  const Value& valueAt(std::size_t index) const { return m_values.at(index); }
 
   /// Find the most specific value for a given geometry identifier.
   ///
@@ -111,7 +115,7 @@ class GeometryHierarchyMap {
   /// @param id geometry identifier for which information is requested
   /// @retval iterator to an existing value
   /// @retval `.end()` iterator if no matching element exists
-  Iterator find(GeometryIdentifier id) const;
+  Iterator find(const GeometryIdentifier& id) const;
 
  private:
   // NOTE this class assumes that it knows the ordering of the levels within
@@ -171,25 +175,26 @@ class GeometryHierarchyMap {
     // no valid levels; all bits are zero.
     return Identifier{0u};
   }
+
   /// Construct a mask where only the highest level is set.
   static constexpr Identifier makeHighestLevelMask() {
     return makeLeadingLevelsMask(GeometryIdentifier(0u).setVolume(1u));
   }
+
   /// Compare the two identifiers only within the masked bits.
   static constexpr bool equalWithinMask(Identifier lhs, Identifier rhs,
                                         Identifier mask) {
     return (lhs & mask) == (rhs & mask);
   }
+
   /// Ensure identifier ordering and uniqueness.
-  template <typename iterator_t>
-  static void sortAndCheckDuplicates(iterator_t beg, iterator_t end);
+  static void sortAndCheckDuplicates(std::vector<InputElement>& elements);
 
   /// Fill the container from the input elements.
   ///
   /// This assumes that the elements are ordered and unique with respect to
   /// their identifiers.
-  template <typename iterator_t>
-  void fill(iterator_t beg, iterator_t end);
+  void fill(const std::vector<InputElement>& elements);
 };
 
 // implementations
@@ -197,8 +202,8 @@ class GeometryHierarchyMap {
 template <typename value_t>
 inline GeometryHierarchyMap<value_t>::GeometryHierarchyMap(
     std::vector<InputElement> elements) {
-  sortAndCheckDuplicates(elements.begin(), elements.end());
-  fill(elements.begin(), elements.end());
+  sortAndCheckDuplicates(elements);
+  fill(elements);
 }
 
 template <typename value_t>
@@ -208,43 +213,44 @@ inline GeometryHierarchyMap<value_t>::GeometryHierarchyMap(
           std::vector<InputElement>(elements.begin(), elements.end())) {}
 
 template <typename value_t>
-template <typename iterator_t>
 inline void GeometryHierarchyMap<value_t>::sortAndCheckDuplicates(
-    iterator_t beg, iterator_t end) {
+    std::vector<InputElement>& elements) {
   // ensure elements are sorted by identifier
-  std::sort(beg, end, [=](const auto& lhs, const auto& rhs) {
+  std::ranges::sort(elements, [=](const auto& lhs, const auto& rhs) {
     return lhs.first < rhs.first;
   });
-  // check that all elements have unique identifier
-  auto dup = std::adjacent_find(beg, end, [](const auto& lhs, const auto& rhs) {
-    return lhs.first == rhs.first;
-  });
-  if (dup != end) {
+
+  // Check that all elements have unique identifier
+  auto dup = std::ranges::adjacent_find(
+      elements,
+      [](const auto& lhs, const auto& rhs) { return lhs.first == rhs.first; });
+
+  if (dup != elements.end()) {
     throw std::invalid_argument("Input elements contain duplicates");
   }
 }
 
 template <typename value_t>
-template <typename iterator_t>
-inline void GeometryHierarchyMap<value_t>::fill(iterator_t beg,
-                                                iterator_t end) {
-  const auto n = std::distance(beg, end);
+inline void GeometryHierarchyMap<value_t>::fill(
+    const std::vector<InputElement>& elements) {
   m_ids.clear();
-  m_ids.reserve(n);
   m_masks.clear();
-  m_masks.reserve(n);
   m_values.clear();
-  m_values.reserve(n);
-  for (; beg != end; ++beg) {
-    m_ids.push_back(beg->first.value());
-    m_masks.push_back(makeLeadingLevelsMask(beg->first.value()));
-    m_values.push_back(std::move(beg->second));
+
+  m_ids.reserve(elements.size());
+  m_masks.reserve(elements.size());
+  m_values.reserve(elements.size());
+
+  for (const auto& element : elements) {
+    m_ids.push_back(element.first.value());
+    m_masks.push_back(makeLeadingLevelsMask(element.first.value()));
+    m_values.push_back(std::move(element.second));
   }
 }
 
 template <typename value_t>
-inline auto GeometryHierarchyMap<value_t>::find(GeometryIdentifier id) const
-    -> Iterator {
+inline auto GeometryHierarchyMap<value_t>::find(
+    const GeometryIdentifier& id) const -> Iterator {
   assert((m_ids.size() == m_values.size()) &&
          "Inconsistent container state: #ids != # values");
   assert((m_masks.size() == m_values.size()) &&
diff --git a/Core/include/Acts/Geometry/Polyhedron.hpp b/Core/include/Acts/Geometry/Polyhedron.hpp
index 69ae109c52d..e8a55d17d93 100644
--- a/Core/include/Acts/Geometry/Polyhedron.hpp
+++ b/Core/include/Acts/Geometry/Polyhedron.hpp
@@ -10,12 +10,15 @@
 
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Geometry/Extent.hpp"
+#include "Acts/Visualization/ViewConfig.hpp"
 
 #include <cstddef>
 #include <vector>
 
 namespace Acts {
 
+class IVisualization3D;
+
 /// @class Polyhedron
 ///
 /// Struct which contains a cartesian approximation for any surface type.
@@ -79,5 +82,8 @@ struct Polyhedron {
   ///
   /// @return ranges that describe the space taken by this surface
   Extent extent(const Transform3& transform = Transform3::Identity()) const;
+
+  void visualize(IVisualization3D& helper,
+                 const ViewConfig& viewConfig = {}) const;
 };
 }  // namespace Acts
diff --git a/Core/include/Acts/Geometry/TrackingGeometry.hpp b/Core/include/Acts/Geometry/TrackingGeometry.hpp
index d9a7081239a..ea3d8b7efe6 100644
--- a/Core/include/Acts/Geometry/TrackingGeometry.hpp
+++ b/Core/include/Acts/Geometry/TrackingGeometry.hpp
@@ -17,7 +17,6 @@
 #include "Acts/Utilities/Logger.hpp"
 
 #include <memory>
-#include <string>
 #include <unordered_map>
 #include <utility>
 
@@ -29,9 +28,6 @@ class PerigeeSurface;
 class IMaterialDecorator;
 class TrackingVolume;
 
-using TrackingVolumePtr = std::shared_ptr<const TrackingVolume>;
-using MutableTrackingVolumePtr = std::shared_ptr<TrackingVolume>;
-
 ///  @class TrackingGeometry
 ///
 ///  The TrackingGeometry class is the owner of the constructed TrackingVolumes.
@@ -52,7 +48,7 @@ class TrackingGeometry {
   ///        surface or volume based material to the TrackingVolume
   /// @param hook Identifier hook to be applied to surfaces
   /// @param logger instance of a logger (defaulting to the "silent" one)
-  TrackingGeometry(const MutableTrackingVolumePtr& highestVolume,
+  TrackingGeometry(const std::shared_ptr<TrackingVolume>& highestVolume,
                    const IMaterialDecorator* materialDecorator = nullptr,
                    const GeometryIdentifierHook& hook = {},
                    const Logger& logger = getDummyLogger());
@@ -66,8 +62,7 @@ class TrackingGeometry {
 
   /// Access to the world volume
   /// @return shared pointer to the world volume
-  const std::shared_ptr<const TrackingVolume>& highestTrackingVolumeShared()
-      const;
+  std::shared_ptr<const TrackingVolume> highestTrackingVolumePtr() const;
 
   /// return the lowest tracking Volume
   ///
@@ -87,19 +82,6 @@ class TrackingGeometry {
   const Layer* associatedLayer(const GeometryContext& gctx,
                                const Vector3& gp) const;
 
-  /// Register the beam tube
-  ///
-  /// @param beam is the beam line surface
-  void registerBeamTube(std::shared_ptr<const PerigeeSurface> beam);
-
-  /// @brief surface representing the beam pipe
-  ///
-  /// @note The ownership is not passed, e.g. do not delete the pointer
-  ///
-  /// @return raw pointer to surface representing the beam pipe
-  ///         (could be a null pointer)
-  const Surface* getBeamline() const;
-
   /// @brief Visit all reachable surfaces
   ///
   /// @tparam visitor_t Type of the callable visitor
@@ -108,7 +90,7 @@ class TrackingGeometry {
   /// that is found, a selection of the surfaces can be done in the visitor
   /// @param restrictToSensitives If true, only sensitive surfaces are visited
   ///
-  /// @note If a context is needed for the visit, the vistitor has to provide
+  /// @note If a context is needed for the visit, the visitor has to provide
   /// this, e.g. as a private member
   template <SurfaceVisitor visitor_t>
   void visitSurfaces(visitor_t&& visitor, bool restrictToSensitives) const {
@@ -123,7 +105,7 @@ class TrackingGeometry {
   /// @param visitor The callable. Will be called for each sensitive surface
   /// that is found, a selection of the surfaces can be done in the visitor
   ///
-  /// @note If a context is needed for the visit, the vistitor has to provide
+  /// @note If a context is needed for the visit, the visitor has to provide
   /// this, e.g. as a private member
   template <SurfaceVisitor visitor_t>
   void visitSurfaces(visitor_t&& visitor) const {
@@ -137,7 +119,7 @@ class TrackingGeometry {
   /// @param visitor The callable. Will be called for each reachable volume
   /// that is found, a selection of the volumes can be done in the visitor
   ///
-  /// @note If a context is needed for the visit, the vistitor has to provide
+  /// @note If a context is needed for the visit, the visitor has to provide
   /// this, e.g. as a private member
   template <TrackingVolumeVisitor visitor_t>
   void visitVolumes(visitor_t&& visitor) const {
@@ -165,9 +147,7 @@ class TrackingGeometry {
 
  private:
   // the known world
-  TrackingVolumePtr m_world;
-  // beam line
-  std::shared_ptr<const PerigeeSurface> m_beam;
+  std::shared_ptr<TrackingVolume> m_world;
   // lookup containers
   std::unordered_map<GeometryIdentifier, const TrackingVolume*> m_volumesById;
   std::unordered_map<GeometryIdentifier, const Surface*> m_surfacesById;
diff --git a/Core/include/Acts/Geometry/TrackingVolume.hpp b/Core/include/Acts/Geometry/TrackingVolume.hpp
index a343f40bf2d..c5590e1168d 100644
--- a/Core/include/Acts/Geometry/TrackingVolume.hpp
+++ b/Core/include/Acts/Geometry/TrackingVolume.hpp
@@ -264,7 +264,7 @@ class TrackingVolume : public Volume {
   const IVolumeMaterial* volumeMaterial() const;
 
   /// Return the material of the volume as shared pointer
-  const std::shared_ptr<const IVolumeMaterial>& volumeMaterialSharedPtr() const;
+  const std::shared_ptr<const IVolumeMaterial>& volumeMaterialPtr() const;
 
   /// Set the volume material description
   ///
diff --git a/Core/include/Acts/Geometry/Volume.hpp b/Core/include/Acts/Geometry/Volume.hpp
index 65e3e8b9219..3a6a592ffb0 100644
--- a/Core/include/Acts/Geometry/Volume.hpp
+++ b/Core/include/Acts/Geometry/Volume.hpp
@@ -118,6 +118,13 @@ class Volume : public GeometryObject {
   bool operator==(const Volume& other) const;
   bool operator!=(const Volume& other) const;
 
+  /// Produces a 3D visualization of this volume
+  /// @param helper The visualization helper describing the output format
+  /// @param gctx The geometry context
+  /// @param viewConfig The view configuration
+  void visualize(IVisualization3D& helper, const GeometryContext& gctx,
+                 const ViewConfig& viewConfig = {}) const;
+
  protected:
   Transform3 m_transform;
   Transform3 m_itransform;
diff --git a/Core/include/Acts/Geometry/VolumeBounds.hpp b/Core/include/Acts/Geometry/VolumeBounds.hpp
index f2f4407cde5..c065440383b 100644
--- a/Core/include/Acts/Geometry/VolumeBounds.hpp
+++ b/Core/include/Acts/Geometry/VolumeBounds.hpp
@@ -57,16 +57,19 @@ class VolumeBounds {
   // @enum BoundsType
   /// This is nested to the VolumeBounds, as also SurfaceBounds will have
   /// Bounds Type.
-  enum BoundsType : int {
-    eCone = 0,
-    eCuboid = 1,
-    eCutoutCylinder = 2,
-    eCylinder = 3,
-    eGenericCuboid = 4,
-    eTrapezoid = 5,
-    eOther = 6
+  enum class BoundsType {
+    eCone,
+    eCuboid,
+    eCutoutCylinder,
+    eCylinder,
+    eGenericCuboid,
+    eTrapezoid,
+    eOther,
+
   };
 
+  using enum BoundsType;
+
   /// Static member to get the name of the BoundsType
   static const std::vector<std::string> s_boundsTypeNames;
 
@@ -168,4 +171,6 @@ inline bool operator==(const VolumeBounds& lhs, const VolumeBounds& rhs) {
   return (lhs.type() == rhs.type()) && (lhs.values() == rhs.values());
 }
 
+std::ostream& operator<<(std::ostream& sl, const VolumeBounds::BoundsType& bt);
+
 }  // namespace Acts
diff --git a/Core/include/Acts/Material/MaterialComposition.hpp b/Core/include/Acts/Material/MaterialComposition.hpp
index 1b11901e032..00073a2b1f0 100644
--- a/Core/include/Acts/Material/MaterialComposition.hpp
+++ b/Core/include/Acts/Material/MaterialComposition.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2018-2024 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
@@ -100,10 +100,10 @@ class MaterialComposition {
   /// Rescales the fractions so they all add up to unity within the accuracy.
   MaterialComposition(std::vector<ElementFraction> elements)
       : m_elements(std::move(elements)) {
-    std::sort(m_elements.begin(), m_elements.end());
+    std::ranges::sort(m_elements, std::less<ElementFraction>{});
     // compute the total weight first
     unsigned total = 0u;
-    for (auto element : m_elements) {
+    for (const auto& element : m_elements) {
       total += element.m_fraction;
     }
     // compute scale factor into the [0, 256) range
diff --git a/Core/include/Acts/Navigation/DetectorNavigator.hpp b/Core/include/Acts/Navigation/DetectorNavigator.hpp
index 02522888f14..eb18295ecef 100644
--- a/Core/include/Acts/Navigation/DetectorNavigator.hpp
+++ b/Core/include/Acts/Navigation/DetectorNavigator.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -22,6 +22,7 @@
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/Logger.hpp"
 
+#include <algorithm>
 #include <iomanip>
 #include <iterator>
 #include <sstream>
@@ -405,13 +406,9 @@ class DetectorNavigator {
 
     // Sort properly the surface candidates
     auto& nCandidates = nState.surfaceCandidates;
-    std::sort(nCandidates.begin(), nCandidates.end(),
-              [&](const auto& a, const auto& b) {
-                // The two path lengths
-                ActsScalar pathToA = a.objectIntersection.pathLength();
-                ActsScalar pathToB = b.objectIntersection.pathLength();
-                return pathToA < pathToB;
-              });
+    std::ranges::sort(nCandidates, {}, [](const auto& c) {
+      return c.objectIntersection.pathLength();
+    });
     // Set the surface candidate
     nState.surfaceCandidateIndex = 0;
   }
diff --git a/Core/include/Acts/Navigation/MultiLayerNavigation.hpp b/Core/include/Acts/Navigation/MultiLayerNavigation.hpp
index 15042881147..12d48e5dcaa 100644
--- a/Core/include/Acts/Navigation/MultiLayerNavigation.hpp
+++ b/Core/include/Acts/Navigation/MultiLayerNavigation.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -14,8 +14,10 @@
 #include "Acts/Navigation/NavigationStateUpdaters.hpp"
 #include "Acts/Utilities/VectorHelpers.hpp"
 
+#include <algorithm>
 #include <array>
 #include <memory>
+#include <tuple>
 
 namespace Acts::Experimental {
 
@@ -105,16 +107,11 @@ class MultiLayerNavigation : public IInternalNavigation {
   void resolveDuplicates(const GeometryContext& gctx,
                          std::vector<const Acts::Surface*>& surfaces) const {
     // sorting the surfaces according to their radial distance
-    std::sort(surfaces.begin(), surfaces.end(),
-              [&gctx](const auto& surf1, const auto& surf2) {
-                if (surf1->center(gctx).x() != surf2->center(gctx).x()) {
-                  return surf1->center(gctx).x() < surf2->center(gctx).x();
-                }
-                if (surf1->center(gctx).y() != surf2->center(gctx).y()) {
-                  return surf1->center(gctx).y() < surf2->center(gctx).y();
-                }
-                return surf1->center(gctx).z() < surf2->center(gctx).z();
-              });
+    std::ranges::sort(surfaces, {}, [&gctx](const auto& s) {
+      assert(s != nullptr && "Uninitialized surface");
+      const auto& center = s->center(gctx);
+      return std::make_tuple(center.x(), center.y(), center.z());
+    });
 
     // Remove the duplicates
     surfaces.erase(std::unique(surfaces.begin(), surfaces.end()),
diff --git a/Core/include/Acts/Navigation/NavigationStateUpdaters.hpp b/Core/include/Acts/Navigation/NavigationStateUpdaters.hpp
index 3903d1e123c..b5e4d90f53b 100644
--- a/Core/include/Acts/Navigation/NavigationStateUpdaters.hpp
+++ b/Core/include/Acts/Navigation/NavigationStateUpdaters.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -20,6 +20,7 @@
 #include "Acts/Utilities/IAxis.hpp"
 #include "Acts/Utilities/VectorHelpers.hpp"
 
+#include <algorithm>
 #include <array>
 #include <memory>
 
@@ -65,11 +66,9 @@ inline void intitializeCandidates(const GeometryContext& gctx,
     }
   }
 
-  std::sort(confirmedCandidates.begin(), confirmedCandidates.end(),
-            [&](const auto& a, const auto& b) {
-              return a.objectIntersection.pathLength() <
-                     b.objectIntersection.pathLength();
-            });
+  std::ranges::sort(confirmedCandidates, {}, [](const auto& c) {
+    return c.objectIntersection.pathLength();
+  });
 
   nState.surfaceCandidates = std::move(confirmedCandidates);
   nState.surfaceCandidateIndex = 0;
diff --git a/Core/include/Acts/Propagator/EigenStepperDenseEnvironmentExtension.hpp b/Core/include/Acts/Propagator/EigenStepperDenseExtension.hpp
similarity index 99%
rename from Core/include/Acts/Propagator/EigenStepperDenseEnvironmentExtension.hpp
rename to Core/include/Acts/Propagator/EigenStepperDenseExtension.hpp
index befab8f96ce..155bc1637bc 100644
--- a/Core/include/Acts/Propagator/EigenStepperDenseEnvironmentExtension.hpp
+++ b/Core/include/Acts/Propagator/EigenStepperDenseExtension.hpp
@@ -25,7 +25,7 @@ namespace Acts {
 /// ioninisation, bremsstrahlung, pair production and photonuclear interaction
 /// in the propagation and the jacobian. These effects will only occur if the
 /// propagation is in a TrackingVolume with attached material.
-struct EigenStepperDenseEnvironmentExtension {
+struct EigenStepperDenseExtension {
   using Scalar = ActsScalar;
   /// @brief Vector3 replacement for the custom scalar type
   using ThisVector3 = Eigen::Matrix<Scalar, 3, 1>;
diff --git a/Core/include/Acts/Propagator/Navigator.hpp b/Core/include/Acts/Propagator/Navigator.hpp
index 73e928b762e..dba15d46ac9 100644
--- a/Core/include/Acts/Propagator/Navigator.hpp
+++ b/Core/include/Acts/Propagator/Navigator.hpp
@@ -20,6 +20,7 @@
 #include "Acts/Utilities/Logger.hpp"
 #include "Acts/Utilities/StringHelpers.hpp"
 
+#include <algorithm>
 #include <sstream>
 #include <string>
 
@@ -889,11 +890,10 @@ class Navigator {
               state.geoContext, stepper.position(state.stepping),
               state.options.direction * stepper.direction(state.stepping),
               navOpts, logger());
-      std::sort(state.navigation.navBoundaries.begin(),
-                state.navigation.navBoundaries.end(),
-                [](const auto& a, const auto& b) {
-                  return SurfaceIntersection::pathLengthOrder(a.first, b.first);
-                });
+      std::ranges::sort(
+          state.navigation.navBoundaries, [](const auto& a, const auto& b) {
+            return SurfaceIntersection::pathLengthOrder(a.first, b.first);
+          });
 
       // Print boundary information
       if (logger().doPrint(Logging::VERBOSE)) {
@@ -1011,9 +1011,8 @@ class Navigator {
     state.navigation.navSurfaces = currentLayer->compatibleSurfaces(
         state.geoContext, stepper.position(state.stepping),
         state.options.direction * stepper.direction(state.stepping), navOpts);
-    std::sort(state.navigation.navSurfaces.begin(),
-              state.navigation.navSurfaces.end(),
-              SurfaceIntersection::pathLengthOrder);
+    std::ranges::sort(state.navigation.navSurfaces,
+                      SurfaceIntersection::pathLengthOrder);
 
     // Print surface information
     if (logger().doPrint(Logging::VERBOSE)) {
@@ -1079,11 +1078,10 @@ class Navigator {
             state.geoContext, stepper.position(state.stepping),
             state.options.direction * stepper.direction(state.stepping),
             navOpts);
-    std::sort(state.navigation.navLayers.begin(),
-              state.navigation.navLayers.end(),
-              [](const auto& a, const auto& b) {
-                return SurfaceIntersection::pathLengthOrder(a.first, b.first);
-              });
+    std::ranges::sort(
+        state.navigation.navLayers, [](const auto& a, const auto& b) {
+          return SurfaceIntersection::pathLengthOrder(a.first, b.first);
+        });
 
     // Print layer information
     if (logger().doPrint(Logging::VERBOSE)) {
diff --git a/Core/include/Acts/Propagator/TryAllNavigator.hpp b/Core/include/Acts/Propagator/TryAllNavigator.hpp
index a516a3292d2..2ba9cc6a80e 100644
--- a/Core/include/Acts/Propagator/TryAllNavigator.hpp
+++ b/Core/include/Acts/Propagator/TryAllNavigator.hpp
@@ -354,8 +354,8 @@ class TryAllNavigator : public TryAllNavigatorBase {
       }
     }
 
-    std::sort(intersectionCandidates.begin(), intersectionCandidates.end(),
-              detail::IntersectionCandidate::forwardOrder);
+    std::ranges::sort(intersectionCandidates,
+                      detail::IntersectionCandidate::forwardOrder);
 
     ACTS_VERBOSE(volInfo(state) << "found " << intersectionCandidates.size()
                                 << " intersections");
@@ -766,9 +766,8 @@ class TryAllOverstepNavigator : public TryAllNavigatorBase {
         }
       }
 
-      std::sort(state.navigation.activeCandidates.begin(),
-                state.navigation.activeCandidates.end(),
-                detail::IntersectionCandidate::forwardOrder);
+      std::ranges::sort(state.navigation.activeCandidates,
+                        detail::IntersectionCandidate::forwardOrder);
 
       state.navigation.activeCandidateIndex = 0;
 
diff --git a/Core/include/Acts/Seeding/GbtsDataStorage.hpp b/Core/include/Acts/Seeding/GbtsDataStorage.hpp
index 11debd64d7f..5f088e4138e 100644
--- a/Core/include/Acts/Seeding/GbtsDataStorage.hpp
+++ b/Core/include/Acts/Seeding/GbtsDataStorage.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2021 CERN for the benefit of the Acts project
+// Copyright (C) 2021-2024 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
@@ -105,8 +105,8 @@ class GbtsEtaBin {
   }
 
   void sortByPhi() {
-    std::sort(m_vn.begin(), m_vn.end(),
-              typename Acts::GbtsNode<space_point_t>::CompareByPhi());
+    std::ranges::sort(m_vn,
+                      typename Acts::GbtsNode<space_point_t>::CompareByPhi());
   }
 
   bool empty() const { return m_vn.empty(); }
diff --git a/Core/include/Acts/Seeding/GbtsTrackingFilter.hpp b/Core/include/Acts/Seeding/GbtsTrackingFilter.hpp
index 7ce93170b9a..83a8aa2b362 100644
--- a/Core/include/Acts/Seeding/GbtsTrackingFilter.hpp
+++ b/Core/include/Acts/Seeding/GbtsTrackingFilter.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2021 CERN for the benefit of the Acts project
+// Copyright (C) 2021-2024 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
@@ -138,8 +138,8 @@ class GbtsTrackingFilter {
     if (m_stateVec.empty()) {
       return;
     }
-    std::sort(m_stateVec.begin(), m_stateVec.end(),
-              typename GbtsEdgeState<external_spacepoint_t>::Compare());
+    std::ranges::sort(m_stateVec,
+                      typename GbtsEdgeState<external_spacepoint_t>::Compare());
 
     GbtsEdgeState<external_spacepoint_t>* best = (*m_stateVec.begin());
 
diff --git a/Core/include/Acts/Seeding/HoughTransformUtils.ipp b/Core/include/Acts/Seeding/HoughTransformUtils.ipp
index d6777d1918d..37ebe3ec9d9 100644
--- a/Core/include/Acts/Seeding/HoughTransformUtils.ipp
+++ b/Core/include/Acts/Seeding/HoughTransformUtils.ipp
@@ -1,12 +1,13 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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 http://mozilla.org/MPL/2.0/.
 
 #include <algorithm>
+#include <tuple>
 
 template <class identifier_t>
 template <class PointType>
@@ -263,16 +264,9 @@ Acts::HoughTransformUtils::PeakFinders::IslandsAroundMax<
     }
   }
   // sort the candidate cells descending in content
-  std::sort(candidates.begin(), candidates.end(),
-            [&yieldMap](const std::size_t bin1, const std::size_t bin2) {
-              YieldType h1 = yieldMap[bin1];
-              YieldType h2 = yieldMap[bin2];
-
-              if (h1 != h2) {
-                return h1 > h2;
-              }
-              return bin1 > bin2;
-            });
+  std::ranges::sort(candidates, std::greater{}, [&yieldMap](std::size_t c) {
+    return std::make_tuple(yieldMap[c], c);
+  });
 
   // now we build islands from the candidate cells, starting with the most
   // populated one
diff --git a/Core/include/Acts/Seeding/SeedFilter.ipp b/Core/include/Acts/Seeding/SeedFilter.ipp
index 71d2a6250ce..284ab2932e3 100644
--- a/Core/include/Acts/Seeding/SeedFilter.ipp
+++ b/Core/include/Acts/Seeding/SeedFilter.ipp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -69,11 +69,10 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
 
   if (topSpVec.size() > 2) {
     // sort indexes based on comparing values in invHelixDiameterVec
-    std::sort(
-        topSPIndexVec.begin(), topSPIndexVec.end(),
-        [&invHelixDiameterVec](const std::size_t i1, const std::size_t i2) {
-          return invHelixDiameterVec[i1] < invHelixDiameterVec[i2];
-        });
+    std::ranges::sort(topSPIndexVec, {},
+                      [&invHelixDiameterVec](const std::size_t t) {
+                        return invHelixDiameterVec[t];
+                      });
   }
 
   // vector containing the radius of all compatible seeds
diff --git a/Core/include/Acts/Seeding/SeedFinder.ipp b/Core/include/Acts/Seeding/SeedFinder.ipp
index ba36b260909..f65a26e3f58 100644
--- a/Core/include/Acts/Seeding/SeedFinder.ipp
+++ b/Core/include/Acts/Seeding/SeedFinder.ipp
@@ -496,17 +496,13 @@ SeedFinder<external_spacepoint_t, grid_t, platform_t>::filterCandidates(
 
   if constexpr (detailedMeasurement ==
                 Acts::DetectorMeasurementInfo::eDefault) {
-    std::sort(sorted_bottoms.begin(), sorted_bottoms.end(),
-              [&state](const std::size_t a, const std::size_t b) -> bool {
-                return state.linCircleBottom[a].cotTheta <
-                       state.linCircleBottom[b].cotTheta;
-              });
-
-    std::sort(sorted_tops.begin(), sorted_tops.end(),
-              [&state](const std::size_t a, const std::size_t b) -> bool {
-                return state.linCircleTop[a].cotTheta <
-                       state.linCircleTop[b].cotTheta;
-              });
+    std::ranges::sort(sorted_bottoms, {}, [&state](const std::size_t s) {
+      return state.linCircleBottom[s].cotTheta;
+    });
+
+    std::ranges::sort(sorted_tops, {}, [&state](const std::size_t s) {
+      return state.linCircleTop[s].cotTheta;
+    });
   }
 
   // Reserve enough space, in case current capacity is too little
diff --git a/Core/include/Acts/Seeding/SeedFinderGbts.ipp b/Core/include/Acts/Seeding/SeedFinderGbts.ipp
index 92cc7cd1963..5872707754e 100644
--- a/Core/include/Acts/Seeding/SeedFinderGbts.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderGbts.ipp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2021 CERN for the benefit of the Acts project
+// Copyright (C) 2021-2024 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
@@ -17,6 +17,7 @@
 #include "Acts/Seeding/SeedFinderUtils.hpp"
 #include "Acts/Utilities/BinningType.hpp"
 
+#include <algorithm>
 #include <cmath>
 #include <fstream>
 #include <functional>
@@ -352,8 +353,8 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
       out_sort[outIdx].first = pS->m_p[0];
     }
 
-    std::sort(in_sort.begin(), in_sort.end());
-    std::sort(out_sort.begin(), out_sort.end());
+    std::ranges::sort(in_sort);
+    std::ranges::sort(out_sort);
 
     unsigned int last_out = 0;
 
@@ -495,8 +496,8 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
 
   m_triplets.clear();
 
-  std::sort(vSeeds.begin(), vSeeds.end(),
-            typename Acts::GbtsEdge<external_spacepoint_t>::CompareLevel());
+  std::ranges::sort(
+      vSeeds, typename Acts::GbtsEdge<external_spacepoint_t>::CompareLevel());
 
   if (vSeeds.empty()) {
     return;
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
index 31757e3e72a..7caad023cf4 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -13,6 +13,7 @@
 #include "Acts/Seeding/SeedFinderUtils.hpp"
 #include "Acts/Utilities/BinningType.hpp"
 
+#include <algorithm>
 #include <cmath>
 #include <functional>
 #include <numeric>
@@ -311,16 +312,14 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
     sorted_tops[i] = i;
   }
 
-  std::sort(
-      sorted_bottoms.begin(), sorted_bottoms.end(),
-      [&linCircleBottom](const std::size_t a, const std::size_t b) -> bool {
-        return linCircleBottom[a].cotTheta < linCircleBottom[b].cotTheta;
-      });
+  std::ranges::sort(sorted_bottoms, {},
+                    [&linCircleBottom](const std::size_t s) {
+                      return linCircleBottom[s].cotTheta;
+                    });
 
-  std::sort(sorted_tops.begin(), sorted_tops.end(),
-            [&linCircleTop](const std::size_t a, const std::size_t b) -> bool {
-              return linCircleTop[a].cotTheta < linCircleTop[b].cotTheta;
-            });
+  std::ranges::sort(sorted_tops, {}, [&linCircleTop](const std::size_t s) {
+    return linCircleTop[s].cotTheta;
+  });
 
   std::vector<float> tanMT;
   tanMT.reserve(top.size());
diff --git a/Core/include/Acts/Seeding/detail/CylindricalSpacePointGrid.ipp b/Core/include/Acts/Seeding/detail/CylindricalSpacePointGrid.ipp
index 5a88fc341ac..19d7beddbf7 100644
--- a/Core/include/Acts/Seeding/detail/CylindricalSpacePointGrid.ipp
+++ b/Core/include/Acts/Seeding/detail/CylindricalSpacePointGrid.ipp
@@ -236,9 +236,6 @@ void Acts::CylindricalSpacePointGridCreator::fillGrid(
   /// sort SPs in R for each filled bin
   for (std::size_t binIndex : rBinsIndex) {
     auto& rbin = grid.atPosition(binIndex);
-    std::sort(rbin.begin(), rbin.end(),
-              [](const auto& a, const auto& b) -> bool {
-                return a->radius() < b->radius();
-              });
+    std::ranges::sort(rbin, {}, [](const auto& rb) { return rb->radius(); });
   }
 }
diff --git a/Core/include/Acts/Surfaces/Surface.hpp b/Core/include/Acts/Surfaces/Surface.hpp
index 1ca13d48600..d2f62e0bf31 100644
--- a/Core/include/Acts/Surfaces/Surface.hpp
+++ b/Core/include/Acts/Surfaces/Surface.hpp
@@ -25,6 +25,7 @@
 #include "Acts/Utilities/BinningType.hpp"
 #include "Acts/Utilities/Intersection.hpp"
 #include "Acts/Utilities/Result.hpp"
+#include "Acts/Visualization/ViewConfig.hpp"
 
 #include <array>
 #include <cstddef>
@@ -484,6 +485,9 @@ class Surface : public virtual GeometryObject,
   virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(
       const GeometryContext& gctx, const Vector3& position) const = 0;
 
+  void visualize(IVisualization3D& helper, const GeometryContext& gctx,
+                 const ViewConfig& viewConfig = {}) const;
+
  protected:
   /// Output Method for std::ostream, to be overloaded by child classes
   ///
diff --git a/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp b/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
index ada401ba401..e94ab519902 100644
--- a/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
+++ b/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
@@ -16,6 +16,7 @@
 #include "Acts/Surfaces/BoundaryTolerance.hpp"
 #include "Acts/TrackFitting/GsfOptions.hpp"
 #include "Acts/TrackFitting/detail/GsfActor.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Utilities/Logger.hpp"
 #include "Acts/Utilities/TrackHelpers.hpp"
 
@@ -432,8 +433,8 @@ struct GaussianSumFitter {
 
     for (auto state : fwdGsfResult.fittedStates->reverseTrackStateRange(
              fwdGsfResult.currentTip)) {
-      const bool found = std::find(foundBwd.begin(), foundBwd.end(),
-                                   &state.referenceSurface()) != foundBwd.end();
+      const bool found =
+          rangeContainsValue(foundBwd, &state.referenceSurface());
       if (!found && state.typeFlags().test(MeasurementFlag)) {
         state.typeFlags().set(OutlierFlag);
         state.typeFlags().reset(MeasurementFlag);
diff --git a/Core/include/Acts/TrackFitting/MbfSmoother.hpp b/Core/include/Acts/TrackFitting/MbfSmoother.hpp
index 61f28e1d7b4..57cdd0dd483 100644
--- a/Core/include/Acts/TrackFitting/MbfSmoother.hpp
+++ b/Core/include/Acts/TrackFitting/MbfSmoother.hpp
@@ -51,21 +51,21 @@ class MbfSmoother {
 
     using TrackStateProxy = typename traj_t::TrackStateProxy;
 
-    TrackStateProxy start_ts = trajectory.getTrackState(entryIndex);
+    TrackStateProxy startTs = trajectory.getTrackState(entryIndex);
 
     // Notation consistent with the Wikipedia article
     // https://en.wikipedia.org/wiki/Kalman_filter
-    BoundMatrix big_lambda_hat = BoundMatrix::Zero();
-    BoundVector small_lambda_hat = BoundVector::Zero();
+    BoundMatrix bigLambdaHat = BoundMatrix::Zero();
+    BoundVector smallLambdaHat = BoundVector::Zero();
 
-    trajectory.applyBackwards(start_ts.index(), [&](TrackStateProxy ts) {
+    trajectory.applyBackwards(startTs.index(), [&](TrackStateProxy ts) {
       // ensure the track state has a smoothed component
       ts.addComponents(TrackStatePropMask::Smoothed);
 
       InternalTrackState internalTrackState(ts);
 
       // Smoothe the current state
-      calculateSmoothed(internalTrackState, big_lambda_hat, small_lambda_hat);
+      calculateSmoothed(internalTrackState, bigLambdaHat, smallLambdaHat);
 
       // We smoothed the last state - no need to update the lambdas
       if (!ts.hasPrevious()) {
@@ -74,10 +74,9 @@ class MbfSmoother {
 
       // Update the lambdas depending on the type of track state
       if (ts.typeFlags().test(TrackStateFlag::MeasurementFlag)) {
-        visitMeasurement(internalTrackState, big_lambda_hat, small_lambda_hat);
+        visitMeasurement(internalTrackState, bigLambdaHat, smallLambdaHat);
       } else {
-        visitNonMeasurement(internalTrackState, big_lambda_hat,
-                            small_lambda_hat);
+        visitNonMeasurement(internalTrackState, bigLambdaHat, smallLambdaHat);
       }
     });
 
@@ -143,18 +142,17 @@ class MbfSmoother {
 
   /// Calculate the smoothed parameters and covariance.
   void calculateSmoothed(InternalTrackState& ts,
-                         const BoundMatrix& big_lambda_hat,
-                         const BoundVector& small_lambda_hat) const;
+                         const BoundMatrix& bigLambdaHat,
+                         const BoundVector& smallLambdaHat) const;
 
   /// Visit a non-measurement track state and update the lambdas.
   void visitNonMeasurement(const InternalTrackState& ts,
-                           BoundMatrix& big_lambda_hat,
-                           BoundVector& small_lambda_hat) const;
+                           BoundMatrix& bigLambdaHat,
+                           BoundVector& smallLambdaHat) const;
 
   /// Visit a measurement track state and update the lambdas.
-  void visitMeasurement(const InternalTrackState& ts,
-                        BoundMatrix& big_lambda_hat,
-                        BoundVector& small_lambda_hat) const;
+  void visitMeasurement(const InternalTrackState& ts, BoundMatrix& bigLambdaHat,
+                        BoundVector& smallLambdaHat) const;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/TrackFitting/detail/GsfActor.hpp b/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
index 56d6cecd262..7db377d1ced 100644
--- a/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
+++ b/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
@@ -23,6 +23,7 @@
 #include "Acts/TrackFitting/detail/GsfComponentMerging.hpp"
 #include "Acts/TrackFitting/detail/GsfUtils.hpp"
 #include "Acts/TrackFitting/detail/KalmanUpdateHelpers.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Utilities/Zip.hpp"
 
 #include <ios>
@@ -195,9 +196,7 @@ struct GsfActor {
 
     // Early return if we already were on this surface TODO why is this
     // necessary
-    const bool visited =
-        std::find(result.visitedSurfaces.begin(), result.visitedSurfaces.end(),
-                  &surface) != result.visitedSurfaces.end();
+    const bool visited = rangeContainsValue(result.visitedSurfaces, &surface);
 
     if (visited) {
       ACTS_VERBOSE("Already visited surface, return");
diff --git a/Core/include/Acts/Utilities/BinnedArrayXD.hpp b/Core/include/Acts/Utilities/BinnedArrayXD.hpp
index 4b78b1026bc..281bd9d11b3 100644
--- a/Core/include/Acts/Utilities/BinnedArrayXD.hpp
+++ b/Core/include/Acts/Utilities/BinnedArrayXD.hpp
@@ -13,6 +13,7 @@
 #pragma once
 #include "Acts/Utilities/BinUtility.hpp"
 #include "Acts/Utilities/BinnedArray.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 
 #include <array>
 #include <iostream>
@@ -74,8 +75,7 @@ class BinnedArrayXD : public BinnedArray<T> {
         /// fill the data
         m_objectGrid[bins[2]][bins[1]][bins[0]] = tap.first;
         /// fill the unique m_arrayObjects
-        if (std::find(m_arrayObjects.begin(), m_arrayObjects.end(),
-                      tap.first) == m_arrayObjects.end()) {
+        if (!rangeContainsValue(m_arrayObjects, tap.first)) {
           m_arrayObjects.push_back(tap.first);
         }
       }
@@ -103,8 +103,7 @@ class BinnedArrayXD : public BinnedArray<T> {
         for (auto& o0 : o1) {
           if (o0) {
             /// fill the unique m_arrayObjects
-            if (std::find(m_arrayObjects.begin(), m_arrayObjects.end(), o0) ==
-                m_arrayObjects.end()) {
+            if (!rangeContainsValue(m_arrayObjects, o0)) {
               m_arrayObjects.push_back(o0);
             }
           }
diff --git a/Core/include/Acts/Utilities/BinningData.hpp b/Core/include/Acts/Utilities/BinningData.hpp
index ed8668a3aca..e4fcf700c9a 100644
--- a/Core/include/Acts/Utilities/BinningData.hpp
+++ b/Core/include/Acts/Utilities/BinningData.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
+// Copyright (C) 2016-2024 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
@@ -481,7 +481,7 @@ class BinningData {
         }
       }
       // sort the total boundary vector
-      std::sort(m_totalBoundaries.begin(), m_totalBoundaries.end());
+      std::ranges::sort(m_totalBoundaries);
     }
   }
 
diff --git a/Core/include/Acts/Utilities/BoundingBox.hpp b/Core/include/Acts/Utilities/BoundingBox.hpp
index 72c2b0d2572..aee5ec8d016 100644
--- a/Core/include/Acts/Utilities/BoundingBox.hpp
+++ b/Core/include/Acts/Utilities/BoundingBox.hpp
@@ -20,22 +20,16 @@
 
 namespace Acts {
 
-/**
- * Implementation of an Axis Aligned Bounding Box. This type is compatible
- * with 2D and 3D boxes
- */
+/// Implementation of an Axis Aligned Bounding Box. This type is compatible
+/// with 2D and 3D boxes
 template <typename entity_t, typename value_t, std::size_t DIM>
 class AxisAlignedBoundingBox {
  private:
-  /**
-   * Private self type to capture template parameters
-   */
+  /// Private self type to capture template parameters
   using self_t = AxisAlignedBoundingBox<entity_t, value_t, DIM>;
 
-  /**
-   * Strong type helper, not public
-   * This is only used to provide sensible tag-dispatch below.
-   */
+  /// Strong type helper, not public
+  /// This is only used to provide sensible tag-dispatch below.
   template <typename T, typename P>
   class NamedType {
    public:
@@ -48,265 +42,195 @@ class AxisAlignedBoundingBox {
     T m_value;
   };
 
-  /**
-   * SizeParameter Tag
-   */
+  /// SizeParameter Tag
   struct SizeParameter {};
 
  public:
-  /**
-   * The value type used by this class
-   */
-
+  /// The value type used by this class
   using value_type = value_t;
-  /**
-   * Re-export vertex type based on value type given
-   */
 
+  /// Re-export vertex type based on value type given
   using VertexType = Eigen::Matrix<value_t, DIM, 1>;
-  /**
-   * Associated array value to `VertexType`
-   */
 
+  /// Associated array value to `VertexType`
   using vertex_array_type = Eigen::Array<value_t, DIM, 1>;
 
-  /**
-   * Type of stored entity
-   */
+  /// Type of stored entity
   using entity_type = entity_t;
 
-  /**
-   * The transform type based on the `value_type`
-   */
+  /// The transform type based on the `value_type`
   using transform_type = Eigen::Transform<value_type, DIM, Eigen::Affine>;
 
-  /**
-   * Strong type to select the correct constructor
-   */
+  /// Strong type to select the correct constructor
   using Size = NamedType<VertexType, struct SizeParameter>;
 
-  /**
-   * Re-export dimension from template parameter
-   */
+  /// Re-export dimension from template parameter
   static const std::size_t dim = DIM;
 
-  /**
-   * Copy constructor from other bounding box.
-   * @param other The other AABB
-   */
+  /// Copy constructor from other bounding box.
   AxisAlignedBoundingBox(const self_t& other) = default;
 
-  /**
-   * Copy assignment operator from other bounding box.
-   * @param other The other AABB
-   */
+  /// Copy assignment operator from other bounding box.
+  /// @param other The other AABB
   AxisAlignedBoundingBox& operator=(const self_t& other) = default;
 
-  /**
-   * Constructor from an entity pointer, and the min and max vertices.
-   * @param entity The entity to store
-   * @param vmin The minimum vertex.
-   * @param vmax The maximum vertex.
-   */
+  /// Constructor from an entity pointer, and the min and max vertices.
+  /// @param entity The entity to store
+  /// @param vmin The minimum vertex.
+  /// @param vmax The maximum vertex.
   AxisAlignedBoundingBox(const entity_t* entity, const VertexType& vmin,
                          const VertexType& vmax);
 
-  /**
-   * Constructor from a center position, and a width and height.
-   * @param entity The entity to store
-   * @param center The center position
-   * @param size The size (width and height) of the box.
-   * @note The special type @c size is required to disambiguate this constructor
-   * from the other one above. It is a wrapper around a simple @c Vector3.
-   */
+  /// Constructor from a center position, and a width and height.
+  /// @param entity The entity to store
+  /// @param center The center position
+  /// @param size The size (width and height) of the box.
+  /// @note The special type @c size is required to disambiguate this constructor
+  /// from the other one above. It is a wrapper around a simple @c Vector3.
   AxisAlignedBoundingBox(const entity_t* entity, const VertexType& center,
                          const Size& size);
 
-  /**
-   * Constructor from a list of child boxes. This box will wrap around all boxes
-   * contained in @p boxes, and additional envelope can be given.
-   * @param boxes Vector of child boxes to store in this bounding box.
-   * @param envelope Envelope that will be added/subtracted to the dimension.
-   */
+  /// Constructor from a list of child boxes. This box will wrap around all
+  /// boxes
+  /// contained in @p boxes, and additional envelope can be given.
+  /// @param boxes Vector of child boxes to store in this bounding box.
+  /// @param envelope Envelope that will be added/subtracted to the dimension.
   AxisAlignedBoundingBox(
       const std::vector<self_t*>& boxes,
       vertex_array_type envelope = vertex_array_type::Zero());
 
-  /**
-   * Helper function to calculate the size of a bounding box enclosing @p boxes.
-   * @param boxes The boxes to wrap (const pointers)
-   * @param envelope Optional envelop to add/subtract to dimension.
-   * @return Pair of vertices: min and max.
-   */
+  /// Helper function to calculate the size of a bounding box enclosing @p boxes.
+  /// @param boxes The boxes to wrap (const pointers)
+  /// @param envelope Optional envelop to add/subtract to dimension.
+  /// @return Pair of vertices: min and max.
   static std::pair<VertexType, VertexType> wrap(
       const std::vector<const self_t*>& boxes,
       vertex_array_type envelope = vertex_array_type::Zero());
 
-  /**
-   * Helper function to calculate the size of a bounding box enclosing @p boxes.
-   * Overload which accepts non-const boxes in @p boxes.
-   * @param boxes The boxes to wrap (non-const pointers)
-   * @param envelope Optional envelop to add/subtract to dimension.
-   * @return Pair of vertices: min and max.
-   */
+  /// Helper function to calculate the size of a bounding box enclosing @p boxes.
+  /// Overload which accepts non-const boxes in @p boxes.
+  /// @param boxes The boxes to wrap (non-const pointers)
+  /// @param envelope Optional envelop to add/subtract to dimension.
+  /// @return Pair of vertices: min and max.
   static std::pair<VertexType, VertexType> wrap(
       const std::vector<self_t*>& boxes,
       vertex_array_type envelope = vertex_array_type::Zero());
 
-  /**
-   * Helper function to calculate the size of a bounding box enclosing @p boxes.
-   * Overload which accepts a vector in @p boxes which owns the instances
-   * @param boxes The boxes to wrap (by-value vector)
-   * @param envelope Optional envelop to add/subtract to dimension.
-   * @return Pair of vertices: min and max.
-   */
+  /// Helper function to calculate the size of a bounding box enclosing @p boxes.
+  /// Overload which accepts a vector in @p boxes which owns the instances
+  /// @param boxes The boxes to wrap (by-value vector)
+  /// @param envelope Optional envelop to add/subtract to dimension.
+  /// @return Pair of vertices: min and max.
   static std::pair<VertexType, VertexType> wrap(
       const std::vector<self_t>& boxes,
       vertex_array_type envelope = vertex_array_type::Zero());
 
-  /**
-   * Calculate whether a point is inside this box.
-   * @param point The point to test.
-   * @return Whether the point is inside or not.
-   */
+  /// Calculate whether a point is inside this box.
+  /// @param point The point to test.
+  /// @return Whether the point is inside or not.
   bool intersect(const VertexType& point) const;
 
-  /**
-   * @brief Implements the slab method for Ray/AABB intersections.
-   *
-   * See https://tavianator.com/fast-branchless-raybounding-box-intersections/,
-   * https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/,
-   * https://medium.com/@bromanz/another-view-on-the-classic-ray-aabb-intersection-algorithm-for-bvh-traversal-41125138b525
-   * The original algorithms is described in "Graphics Gems (1990)" [1]
-   * (https://doi.org/10.1016/B978-0-08-050753-8.50084-X)
-   *
-   * @note This implementation may treat parallel rays on any of the slabs
-   *       as **outside** due to how @c NaNs are handled by Eigen.
-   *       See https://eigen.tuxfamily.org/bz/show_bug.cgi?id=564
-   * @param ray The ray to intersect with
-   * @return Whether the ray intersects this AABB
-   */
+  /// @brief Implements the slab method for Ray/AABB intersections.
+  ///
+  /// See https://tavianator.com/fast-branchless-raybounding-box-intersections/,
+  /// https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/,
+  /// https://medium.com/@bromanz/another-view-on-the-classic-ray-aabb-intersection-algorithm-for-bvh-traversal-41125138b525
+  /// The original algorithms is described in "Graphics Gems (1990)" [1]
+  /// (https://doi.org/10.1016/B978-0-08-050753-8.50084-X)
+  ///
+  /// @note This implementation may treat parallel rays on any of the slabs
+  ///       as **outside** due to how @c NaNs are handled by Eigen.
+  ///       See https://eigen.tuxfamily.org/bz/show_bug.cgi?id=564
+  /// @param ray The ray to intersect with
+  /// @return Whether the ray intersects this AABB
   bool intersect(const Ray<value_type, DIM>& ray) const;
 
-  /**
-   * Check if a frustum intersects with this bounding box.
-   *
-   * This method implements an algorithm similar to the one described in
-   * "Optimized View Frustum Culling Algorithms for Bounding Boxes (2012)" [2]
-   * (https://doi.org/10.1080/10867651.2000.10487517), but drops some of the
-   * more sophisticated optimization.
-   *
-   * @param fr The frustum
-   * @return Whether the frustum intersects this AABB
-   */
+  /// Check if a frustum intersects with this bounding box.
+  ///
+  /// This method implements an algorithm similar to the one described in
+  /// "Optimized View Frustum Culling Algorithms for Bounding Boxes (2012)" [2]
+  /// (https://doi.org/10.1080/10867651.2000.10487517), but drops some of the
+  /// more sophisticated optimization.
+  ///
+  /// @param fr The frustum
+  /// @return Whether the frustum intersects this AABB
   template <std::size_t sides>
   bool intersect(const Frustum<value_type, DIM, sides>& fr) const;
 
-  /**
-   * Set the skip node (bounding box)
-   * @param skip The target skip node pointer
-   */
+  /// Set the skip node (bounding box)
+  /// @param skip The target skip node pointer
   void setSkip(self_t* skip);
 
-  /**
-   * Get the skip node for this box
-   * @return The skip node pointer
-   */
+  /// Get the skip node for this box
+  /// @return The skip node pointer
   const self_t* getSkip() const;
 
-  /**
-   * Get the left child (i.e. the first of the children that are inside this
-   * bounding box).
-   * @return The lest most child.
-   */
+  /// Get the left child (i.e. the first of the children that are inside this
+  /// bounding box).
+  /// @return The lest most child.
   const self_t* getLeftChild() const;
 
-  /**
-   * Check whether this node as an associated entity. If it does not have one,
-   * this is a purely abstract container box.
-   * @return Whether the box has an entity attached.
-   */
+  /// Check whether this node as an associated entity. If it does not have one,
+  /// this is a purely abstract container box.
+  /// @return Whether the box has an entity attached.
   bool hasEntity() const;
 
-  /**
-   * Return the entity associated with this box. This might be nullptr if there
-   * is no entity attached.
-   * @return The entity pointer, might be nullptr
-   */
+  /// Return the entity associated with this box. This might be nullptr if there
+  /// is no entity attached.
+  /// @return The entity pointer, might be nullptr
   const entity_t* entity() const;
 
-  /**
-   * Set the entity associated with with this box.
-   * @param entity The entity
-   */
+  /// Set the entity associated with with this box.
+  /// @param entity The entity
   void setEntity(const entity_t* entity);
 
-  /**
-   * Get the center position of this bounding box.
-   * @return The center position
-   */
+  /// Get the center position of this bounding box.
+  /// @return The center position
   const VertexType& center() const;
 
-  /**
-   * Get the minimum vertex
-   * @return The minimum vertex
-   */
+  /// Get the minimum vertex
+  /// @return The minimum vertex
   const VertexType& min() const;
 
-  /**
-   * Get the maximum vertex
-   * @return The maximum vertex
-   */
+  /// Get the maximum vertex
+  /// @return The maximum vertex
   const VertexType& max() const;
 
-  /**
-   * Write information about this bounding box to a stream.
-   * @param os The output stream.
-   * @return The stream given as an argument.
-   */
+  /// Write information about this bounding box to a stream.
+  /// @param os The output stream.
+  /// @return The stream given as an argument.
   std::ostream& toStream(std::ostream& os) const;
 
-  /**
-   * Transforms this bounding box using the given transform. This method
-   * modifies the box it is called on.
-   * @param trf The transform
-   */
+  /// Transforms this bounding box using the given transform. This method
+  /// modifies the box it is called on.
+  /// @param trf The transform
   void transform(const transform_type& trf);
 
-  /**
-   * Transforms this bounding box using the given transform. This method returns
-   * a copy of this box, with the transformation applied, and leaves this
-   * instance unchanged.
-   * @param trf The transform
-   * @return The transformed bounding box
-   */
+  /// Transforms this bounding box using the given transform. This method
+  /// returns a copy of this box, with the transformation applied, and leaves
+  /// this instance unchanged.
+  /// @param trf The transform
+  /// @return The transformed bounding box
   self_t transformed(const transform_type& trf) const;
 
-  /**
-   * Draw this bounding box using the given visualization helper. This method is
-   * only available for the 3D case.
-   * @tparam D (used for SFINAE)
-   * @param helper The visualization helper to write to
-   * @param color The color to use for drawing
-   * @param trf An optional transform to apply first.
-   */
-  void draw(IVisualization3D& helper,
-            std::array<int, 3> color = {120, 120, 120},
+  /// Draw this bounding box using the given visualization helper. This method
+  /// is only available for the 3D case.
+  /// @param helper The visualization helper to write to
+  /// @param color The color to use for drawing
+  /// @param trf An optional transform to apply first.
+  void draw(IVisualization3D& helper, Color color = {120, 120, 120},
             const transform_type& trf = transform_type::Identity()) const
     requires(DIM == 3);
 
-  /**
-   * Draw this bounding box as SVG. This method is only available for the 2D
-   * case.
-   * @tparam D (used for SFINAE)
-   * @param os The output stream to write to
-   * @param w The width of the output SVG.
-   * @param h The height of the output SVG.
-   * @param unit A scale factor to apply before drawing
-   * @param label A label to put next to the box.
-   * @param fillcolor Color to fill the box with.
-   * @return The outstream given in @p os.
-   */
+  /// Draw this bounding box as SVG. This method is only available for the 2D
+  /// case.
+  /// @param os The output stream to write to
+  /// @param w The width of the output SVG.
+  /// @param h The height of the output SVG.
+  /// @param unit A scale factor to apply before drawing
+  /// @param label A label to put next to the box.
+  /// @param fillcolor Color to fill the box with.
+  /// @return The outstream given in @p os.
   std::ostream& svg(std::ostream& os, value_type w, value_type h,
                     value_type unit = 10, const std::string& label = "",
                     const std::string& fillcolor = "grey") const
@@ -333,32 +257,28 @@ class AxisAlignedBoundingBox {
   self_t* m_skip{nullptr};
 };
 
-/**
- * Build an octree from a list of bounding boxes.
- * @note @p store and @p prims do not need to contain the same objects. @p store
- * is only used to pass ownership back to the caller while preserving memory
- * location.
- * @tparam box_t Works will all box types.
- * @param store Owns the created boxes by means of `std::unique_ptr`.
- * @param prims Boxes to store. This is a read only vector.
- * @param max_depth No subdivisions beyond this level.
- * @param envelope1 Envelope to add/subtract to dimensions in all directions.
- * @return Pointer to the top most bounding box, containing the entire octree
- */
+/// Build an octree from a list of bounding boxes.
+/// @note @p store and @p prims do not need to contain the same objects. @p store
+/// is only used to pass ownership back to the caller while preserving memory
+/// location.
+/// @tparam box_t Works will all box types.
+/// @param store Owns the created boxes by means of `std::unique_ptr`.
+/// @param prims Boxes to store. This is a read only vector.
+/// @param max_depth No subdivisions beyond this level.
+/// @param envelope1 Envelope to add/subtract to dimensions in all directions.
+/// @return Pointer to the top most bounding box, containing the entire octree
 template <typename box_t>
 box_t* make_octree(std::vector<std::unique_ptr<box_t>>& store,
                    const std::vector<box_t*>& prims, std::size_t max_depth = 1,
                    typename box_t::value_type envelope1 = 0);
 
-/**
- * Overload of the << operator for bounding boxes.
- * @tparam T entity type
- * @tparam U value type
- * @tparam V dimension
- * @param os The output stream
- * @param box The bounding box
- * @return The given output stream.
- */
+/// Overload of the << operator for bounding boxes.
+/// @tparam T entity type
+/// @tparam U value type
+/// @tparam V dimension
+/// @param os The output stream
+/// @param box The bounding box
+/// @return The given output stream.
 template <typename T, typename U, std::size_t V>
 std::ostream& operator<<(std::ostream& os,
                          const AxisAlignedBoundingBox<T, U, V>& box);
diff --git a/Core/include/Acts/Utilities/BoundingBox.ipp b/Core/include/Acts/Utilities/BoundingBox.ipp
index 8dcb2612b48..bce97e29825 100644
--- a/Core/include/Acts/Utilities/BoundingBox.ipp
+++ b/Core/include/Acts/Utilities/BoundingBox.ipp
@@ -353,8 +353,7 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::transformed(
 
 template <typename entity_t, typename value_t, std::size_t DIM>
 void Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::draw(
-    IVisualization3D& helper, std::array<int, 3> color,
-    const transform_type& trf) const
+    IVisualization3D& helper, Color color, const transform_type& trf) const
   requires(DIM == 3)
 {
   static_assert(DIM == 3, "PLY output only supported in 3D");
diff --git a/Core/include/Acts/Utilities/GraphViz.hpp b/Core/include/Acts/Utilities/GraphViz.hpp
new file mode 100644
index 00000000000..2aeb75dba5f
--- /dev/null
+++ b/Core/include/Acts/Utilities/GraphViz.hpp
@@ -0,0 +1,110 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 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 http://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include <ostream>
+#include <vector>
+
+namespace Acts::GraphViz {
+
+enum class Shape {
+  Box,
+  Polygon,
+  Ellipse,
+  Oval,
+  Circle,
+  Point,
+  Egg,
+  Triangle,
+  Plaintext,
+  Plain,
+  Diamond,
+  Trapezium,
+  Parallelogram,
+  House,
+  Pentagon,
+  Hexagon,
+  Septagon,
+  Octagon,
+  DoubleCircle,
+  DoubleOctagon,
+  TripleOctagon,
+  InvTriangle,
+  InvTrapezium,
+  InvHouse,
+  Mdiamond,
+  Msquare,
+  Mcircle,
+  Rect,
+  Rectangle,
+  Square,
+  Star,
+  None,
+  Underline,
+  Cylinder,
+  Note,
+  Tab,
+  Folder,
+  Box3d,
+  Component,
+  Promoter,
+  Cds,
+  Terminator,
+  Utr,
+  PrimerSite,
+  RestrictionSite,
+  FivePOverhang,
+  ThreePOverhang,
+  NOverhang,
+  Assembly,
+  Signature,
+  Insulator,
+  Ribosite,
+  RNAStab,
+  ProteaseSite,
+  ProteinStab,
+  RPromoter,
+  RArrow,
+  LArrow,
+  LPromoter
+};
+
+std::ostream& operator<<(std::ostream& os, const Shape& shape);
+
+enum class Style {
+  Filled,
+  Invisible,
+  Diagonals,
+  Rounded,
+  Dashed,
+  Dotted,
+  Solid,
+  Bold
+};
+
+std::ostream& operator<<(std::ostream& os, const Style& style);
+
+struct Node {
+  std::string id;
+  std::string label;
+  Shape shape = Shape::Ellipse;
+  std::vector<Style> style = {Style::Solid};
+};
+
+std::ostream& operator<<(std::ostream& os, const Node& node);
+
+struct Edge {
+  Node from;
+  Node to;
+  Style style = Style::Solid;
+};
+
+std::ostream& operator<<(std::ostream& os, const Edge& node);
+
+}  // namespace Acts::GraphViz
diff --git a/Core/include/Acts/Utilities/Helpers.hpp b/Core/include/Acts/Utilities/Helpers.hpp
index 99d068cf361..34248fd9047 100644
--- a/Core/include/Acts/Utilities/Helpers.hpp
+++ b/Core/include/Acts/Utilities/Helpers.hpp
@@ -11,6 +11,7 @@
 #include "Acts/Definitions/Algebra.hpp"
 
 #include <algorithm>
+#include <array>
 #include <iostream>
 #include <limits>
 #include <memory>
@@ -71,22 +72,24 @@ std::vector<const T*> unpack_shared_const_vector(
   return rawPtrs;
 }
 
-/// This can be abandoned with C++20 to use the std::to_array method
+/// @brief Converts a vector to a fixed-size array with truncating or padding.
 ///
-/// @note only the first kDIM elements will obviously be filled, if the
-/// vector tends to be longer, it is truncated
+/// This function copies elements from the input vector into a fixed-size array.
+/// If the vector contains more than `kDIM` elements, the array is truncated to
+/// fit. If the vector contains fewer elements than `kDIM`, the remaining array
+/// elements are value-initialized (default-initialized, i.e., filled with zero
+/// or default values).
 ///
-/// @param vecvals the vector of bound values to be converted
-/// @return an array with the filled values
-template <std::size_t kDIM, typename value_type>
-std::array<value_type, kDIM> to_array(const std::vector<value_type>& vecvals) {
-  std::array<value_type, kDIM> rarray = {};
-  for (const auto [iv, v] : enumerate(vecvals)) {
-    if (iv < kDIM) {
-      rarray[iv] = v;
-    }
-  }
-  return rarray;
+/// @tparam kDIM The size of the resulting array.
+/// @tparam value_t The type of elements in the vector and the array.
+/// @param vecvals The input vector to be converted to an array.
+///
+/// @return An array containing the first `kDIM` elements of the vector.
+template <std::size_t kDIM, typename value_t>
+std::array<value_t, kDIM> toArray(const std::vector<value_t>& vecvals) {
+  std::array<value_t, kDIM> arr = {};
+  std::copy_n(vecvals.begin(), std::min(vecvals.size(), kDIM), arr.begin());
+  return arr;
 }
 
 /// @brief Dispatch a call based on a runtime value on a function taking the
@@ -184,4 +187,21 @@ constexpr std::underlying_type_t<enum_t> toUnderlying(enum_t value) {
   return static_cast<std::underlying_type_t<enum_t>>(value);
 }
 
+/// This can be replaced with C++23 to use the std::ranges::contains method
+///
+/// This function searches through the given range for a specified value
+/// and returns `true` if the value is found, or `false` otherwise.
+///
+/// @tparam R The type of the range (e.g., vector, list, array).
+/// @tparam T The type of the value to search for within the range.
+///
+/// @param range The range to search within. This can be any range-compatible container.
+/// @param value The value to search for in the range.
+///
+/// @return `true` if the value is found within the range, `false` otherwise.
+template <typename R, typename T>
+bool rangeContainsValue(const R& range, const T& value) {
+  return std::ranges::find(range, value) != std::ranges::end(range);
+}
+
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/SingleSeedVertexFinder.ipp b/Core/include/Acts/Vertexing/SingleSeedVertexFinder.ipp
index 1206528cd5c..0f26a6a1ed3 100644
--- a/Core/include/Acts/Vertexing/SingleSeedVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/SingleSeedVertexFinder.ipp
@@ -1,11 +1,12 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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 http://mozilla.org/MPL/2.0/.
 
+#include <algorithm>
 #include <cmath>
 #include <system_error>
 
@@ -463,10 +464,8 @@ Acts::SingleSeedVertexFinder<spacepoint_t>::findClosestPointFromPlanes(
         triplet.second = distance;
       }
 
-      std::sort(tripletsWithPlanes.begin(), tripletsWithPlanes.end(),
-                [](const auto& lhs, const auto& rhs) {
-                  return lhs.second < rhs.second;
-                });
+      std::ranges::sort(tripletsWithPlanes, {},
+                        [](const auto& t) { return t.second; });
 
       std::uint32_t threshold = static_cast<std::uint32_t>(
           tripletsWithPlanes.size() * (1. - m_cfg.removeFraction));
@@ -571,10 +570,8 @@ Acts::SingleSeedVertexFinder<spacepoint_t>::findClosestPointFromRays(
         triplet.second = distance;
       }
 
-      std::sort(tripletsWithRays.begin(), tripletsWithRays.end(),
-                [](const auto& lhs, const auto& rhs) {
-                  return lhs.second < rhs.second;
-                });
+      std::ranges::sort(tripletsWithRays, {},
+                        [](const auto& t) { return t.second; });
 
       std::uint32_t threshold = static_cast<std::uint32_t>(
           tripletsWithRays.size() * (1. - m_cfg.removeFraction));
diff --git a/Core/include/Acts/Visualization/EventDataView3D.hpp b/Core/include/Acts/Visualization/EventDataView3D.hpp
index d7de8e94eda..ca60fb25fce 100644
--- a/Core/include/Acts/Visualization/EventDataView3D.hpp
+++ b/Core/include/Acts/Visualization/EventDataView3D.hpp
@@ -32,11 +32,11 @@
 namespace Acts {
 class IVisualization3D;
 
-static ViewConfig s_viewParameter = ViewConfig({0, 0, 255});
-static ViewConfig s_viewMeasurement = ViewConfig({255, 102, 0});
-static ViewConfig s_viewPredicted = ViewConfig({51, 204, 51});
-static ViewConfig s_viewFiltered = ViewConfig({255, 255, 0});
-static ViewConfig s_viewSmoothed = ViewConfig({0, 102, 255});
+static ViewConfig s_viewParameter = {.color = {0, 0, 255}};
+static ViewConfig s_viewMeasurement = {.color = {255, 102, 0}};
+static ViewConfig s_viewPredicted = {.color = {51, 204, 51}};
+static ViewConfig s_viewFiltered = {.color = {255, 255, 0}};
+static ViewConfig s_viewSmoothed = {.color = {0, 102, 25}};
 
 struct EventDataView3D {
   /// Helper to find the eigen values and corr angle
@@ -277,7 +277,7 @@ struct EventDataView3D {
                                  state.predicted(), state.predictedCovariance(),
                                  particleHypothesis),
             gctx, momentumScale, locErrorScale, angularErrorScale,
-            predictedConfig, predictedConfig, ViewConfig(false));
+            predictedConfig, predictedConfig, {.visible = false});
       }
       // (b) filtered track parameters
       if (filteredConfig.visible && state.hasFiltered()) {
@@ -287,7 +287,7 @@ struct EventDataView3D {
                                  state.filtered(), state.filteredCovariance(),
                                  particleHypothesis),
             gctx, momentumScale, locErrorScale, angularErrorScale,
-            filteredConfig, filteredConfig, ViewConfig(false));
+            filteredConfig, filteredConfig, {.visible = false});
       }
       // (c) smoothed track parameters
       if (smoothedConfig.visible && state.hasSmoothed()) {
@@ -297,7 +297,7 @@ struct EventDataView3D {
                                  state.smoothed(), state.smoothedCovariance(),
                                  particleHypothesis),
             gctx, momentumScale, locErrorScale, angularErrorScale,
-            smoothedConfig, smoothedConfig, ViewConfig(false));
+            smoothedConfig, smoothedConfig, {.visible = false});
       }
       return true;
     });
diff --git a/Core/include/Acts/Visualization/GeometryView3D.hpp b/Core/include/Acts/Visualization/GeometryView3D.hpp
index f1abba71424..cd313561f61 100644
--- a/Core/include/Acts/Visualization/GeometryView3D.hpp
+++ b/Core/include/Acts/Visualization/GeometryView3D.hpp
@@ -102,9 +102,9 @@ struct GeometryView3D {
                          const Experimental::Portal& portal,
                          const GeometryContext& gctx,
                          const Transform3& transform = Transform3::Identity(),
-                         const ViewConfig& connected = ViewConfig({0, 255, 0}),
-                         const ViewConfig& disconnected = ViewConfig({255, 0,
-                                                                      0}));
+                         const ViewConfig& connected = {.color = {0, 255, 0}},
+                         const ViewConfig& disconnected = {
+                             .color = {255, 0, 0}});
 
   /// Helper method to draw DetectorVolume objects
   ///
@@ -120,8 +120,8 @@ struct GeometryView3D {
       const Acts::Experimental::DetectorVolume& volume,
       const GeometryContext& gctx,
       const Transform3& transform = Transform3::Identity(),
-      const ViewConfig& connected = ViewConfig({0, 255, 0}),
-      const ViewConfig& unconnected = ViewConfig({255, 0, 0}),
+      const ViewConfig& connected = {.color = {0, 255, 0}},
+      const ViewConfig& unconnected = {.color = {255, 0, 0}},
       const ViewConfig& viewConfig = s_viewSensitive);
 
   /// Helper method to draw Layer objects
diff --git a/Core/include/Acts/Visualization/IVisualization3D.hpp b/Core/include/Acts/Visualization/IVisualization3D.hpp
index 96af6328979..b012fb6447c 100644
--- a/Core/include/Acts/Visualization/IVisualization3D.hpp
+++ b/Core/include/Acts/Visualization/IVisualization3D.hpp
@@ -11,11 +11,8 @@
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Visualization/ViewConfig.hpp"
 
-#include <array>
 #include <cstddef>
 #include <filesystem>
-#include <fstream>
-#include <string>
 #include <vector>
 
 namespace Acts {
@@ -27,11 +24,13 @@ class IVisualization3D {
  public:
   using FaceType = std::vector<std::size_t>;
 
+  static constexpr Color s_defaultColor = {120, 120, 120};
+
   /// Draw a vertex at a given location and a color.
   /// @param vtx The vertex position
   /// @param color The color
   ///
-  virtual void vertex(const Vector3& vtx, ColorRGB color = {120, 120, 120}) = 0;
+  virtual void vertex(const Vector3& vtx, Color color = s_defaultColor) = 0;
 
   /// Draw a face that connects a list of vertices.
   /// @note Depending on the helper implementation, out of plane vertices might
@@ -40,7 +39,7 @@ class IVisualization3D {
   /// @param color The color of the face
   ///
   virtual void face(const std::vector<Vector3>& vtxs,
-                    ColorRGB color = {120, 120, 120}) = 0;
+                    Color color = s_defaultColor) = 0;
 
   /// Draw a faces that connects a list of vertices - expert only
   ///
@@ -52,7 +51,7 @@ class IVisualization3D {
   ///
   virtual void faces(const std::vector<Vector3>& vtxs,
                      const std::vector<FaceType>& faces,
-                     ColorRGB color = {120, 120, 120}) = 0;
+                     Color color = s_defaultColor) = 0;
 
   /// Draw a line from a vertex to another
   /// @param a The start vertex
@@ -60,7 +59,7 @@ class IVisualization3D {
   /// @param color The color of the line
   ///
   virtual void line(const Vector3& a, const Vector3& b,
-                    ColorRGB color = {120, 120, 120}) = 0;
+                    Color color = s_defaultColor) = 0;
 
   /// Write the content of the helper to an outstream.
   /// @param os The output stream for file
diff --git a/Core/include/Acts/Visualization/ObjVisualization3D.hpp b/Core/include/Acts/Visualization/ObjVisualization3D.hpp
index 79da56d3e9c..e7a65b62720 100644
--- a/Core/include/Acts/Visualization/ObjVisualization3D.hpp
+++ b/Core/include/Acts/Visualization/ObjVisualization3D.hpp
@@ -48,19 +48,20 @@ class ObjVisualization3D : public IVisualization3D {
       : m_outputPrecision(prec), m_outputScalor(scale) {}
 
   /// @copydoc Acts::IVisualization3D::vertex()
-  void vertex(const Vector3& vtx, ColorRGB color = {0, 0, 0}) final;
+  void vertex(const Vector3& vtx, Color color = s_defaultColor) final;
 
   /// @copydoc Acts::IVisualization3D::line()
   void line(const Vector3& a, const Vector3& b,
-            ColorRGB color = {0, 0, 0}) final;
+            Color color = s_defaultColor) final;
 
   /// @copydoc Acts::IVisualization3D::face()
-  void face(const std::vector<Vector3>& vtxs, ColorRGB color = {0, 0, 0}) final;
+  void face(const std::vector<Vector3>& vtxs,
+            Color color = s_defaultColor) final;
 
   /// @copydoc Acts::IVisualization3D::faces()
   void faces(const std::vector<Vector3>& vtxs,
              const std::vector<FaceType>& faces,
-             ColorRGB color = {0, 0, 0}) final;
+             Color color = s_defaultColor) final;
 
   /// @copydoc Acts::IVisualization3D::write(const std::filesystem::path&) const
   void write(const std::filesystem::path& path) const final;
@@ -85,9 +86,9 @@ class ObjVisualization3D : public IVisualization3D {
   std::vector<FaceType> m_faces;
   std::vector<LineType> m_lines;
   /// Map of colors to be written at given index position
-  std::map<std::size_t, ColorRGB> m_lineColors;
-  std::map<std::size_t, ColorRGB> m_vertexColors;
-  std::map<std::size_t, ColorRGB> m_faceColors;
+  std::map<std::size_t, Color> m_lineColors;
+  std::map<std::size_t, Color> m_vertexColors;
+  std::map<std::size_t, Color> m_faceColors;
 };
 
 #ifndef DOXYGEN
diff --git a/Core/include/Acts/Visualization/PlyVisualization3D.hpp b/Core/include/Acts/Visualization/PlyVisualization3D.hpp
index 95f2fdacd28..f8a5bee466d 100644
--- a/Core/include/Acts/Visualization/PlyVisualization3D.hpp
+++ b/Core/include/Acts/Visualization/PlyVisualization3D.hpp
@@ -36,20 +36,20 @@ class PlyVisualization3D : public IVisualization3D {
   using VertexType = Eigen::Matrix<ValueType, 3, 1>;
 
   /// @copydoc Acts::IVisualization3D::vertex()
-  void vertex(const Vector3& vtx, ColorRGB color = {120, 120, 120}) final;
+  void vertex(const Vector3& vtx, Color color = {120, 120, 120}) final;
 
   /// @copydoc Acts::IVisualization3D::face()
   void face(const std::vector<Vector3>& vtxs,
-            ColorRGB color = {120, 120, 120}) final;
+            Color color = {120, 120, 120}) final;
 
   /// @copydoc Acts::IVisualization3D::faces()
   void faces(const std::vector<Vector3>& vtxs,
              const std::vector<FaceType>& faces,
-             ColorRGB color = {120, 120, 120}) final;
+             Color color = {120, 120, 120}) final;
 
   /// @copydoc Acts::IVisualization3D::line()
   void line(const Vector3& a, const Vector3& b,
-            ColorRGB color = {120, 120, 120}) final;
+            Color color = {120, 120, 120}) final;
 
   /// @copydoc Acts::IVisualization3D::write(const std::filesystem::path&) const
   void write(const std::filesystem::path& path) const final;
@@ -61,9 +61,9 @@ class PlyVisualization3D : public IVisualization3D {
   void clear() final;
 
  private:
-  std::vector<std::pair<VertexType, ColorRGB>> m_vertices;
+  std::vector<std::pair<VertexType, Color>> m_vertices;
   std::vector<FaceType> m_faces;
-  std::vector<std::pair<std::pair<std::size_t, std::size_t>, ColorRGB>> m_edges;
+  std::vector<std::pair<std::pair<std::size_t, std::size_t>, Color>> m_edges;
 };
 
 #ifndef DOXYGEN
diff --git a/Core/include/Acts/Visualization/ViewConfig.hpp b/Core/include/Acts/Visualization/ViewConfig.hpp
index 7e6e70dbdcc..cdda1e027c4 100644
--- a/Core/include/Acts/Visualization/ViewConfig.hpp
+++ b/Core/include/Acts/Visualization/ViewConfig.hpp
@@ -14,24 +14,98 @@
 
 namespace Acts {
 
-/// The color typedef. It's an array of three numbers [0, 255]
-/// representing the RGB color values.
-///
-using ColorRGB = std::array<int, 3>;
+/// Struct describing a color. Internally, the color is represented using a
+/// triplet of integers between 0 and 255 corresponding to red green and blue.
+struct Color {
+  // Copy and move constructors are defaulted
+  Color() = default;
+  Color(const Color&) = default;
+  Color(Color&&) = default;
+  Color& operator=(const Color&) = default;
+  Color& operator=(Color&&) = default;
+
+  /// Constructor from raw integer rgb values [0, 255]
+  /// @param r The red component
+  /// @param g The green component
+  /// @param b The blue component
+  constexpr Color(int r, int g, int b) : rgb{r, g, b} {}
+
+  /// Constructor from array of integer rgb values [0, 255]
+  /// @param values The rgb values
+  constexpr explicit Color(std::array<int, 3> values) : rgb(values) {}
+
+  /// Constructor from array of double rgb values [0, 1]
+  /// @param values The rgb values
+  constexpr explicit Color(std::array<double, 3> values) {
+    rgb[0] = static_cast<int>(values[0] * 255);
+    rgb[1] = static_cast<int>(values[1] * 255);
+    rgb[2] = static_cast<int>(values[2] * 255);
+  }
+
+  /// Constructor from raw double dgb values [0, 1]
+  /// @param r The red component
+  /// @param g The green component
+  /// @param b The blue component
+  constexpr Color(double r, double g, double b)
+      : Color{std::array<double, 3>{r, g, b}} {}
+
+  /// Constructor from hex string. The expected format is `#RRGGBB`
+  /// @param hex The hex string
+  constexpr explicit Color(std::string_view hex) {
+    auto hexToInt = [](std::string_view hexStr) {
+      int value = 0;
+      std::stringstream ss;
+      ss << std::hex << hexStr;
+      ss >> value;
+      return value;
+    };
+
+    if (hex[0] == '#' && hex.size() == 7) {
+      rgb[0] = hexToInt(hex.substr(1, 2));  // Extract R component
+      rgb[1] = hexToInt(hex.substr(3, 2));  // Extract G component
+      rgb[2] = hexToInt(hex.substr(5, 2));  // Extract B component
+    } else {
+      throw std::invalid_argument{
+          "Invalid hex color format. Expected format: #RRGGBB"};
+    }
+  }
+
+  /// Operator to access the color components
+  /// @param i The index of the component
+  /// @return The color component
+  int operator[](unsigned int i) const { return rgb.at(i); }
+
+  /// Operator to access the color components
+  /// @param i The index of the component
+  /// @return The color component
+  int& operator[](unsigned int i) { return rgb.at(i); }
+
+  /// Operator to compare two colors
+  /// @param lhs The first color
+  /// @param rhs The second color
+  /// @return True if the colors are equal
+  friend bool operator==(const Color& lhs, const Color& rhs) = default;
+
+  /// Output stream operator
+  /// @param os The output stream
+  /// @param color The color to be printed
+  /// @return The output stream
+  friend std::ostream& operator<<(std::ostream& os, const Color& color) {
+    os << "[" << color.rgb[0] << ", " << color.rgb[1] << ", " << color.rgb[2]
+       << "]";
+    return os;
+  }
+
+  std::array<int, 3> rgb{};
+};
 
 /// @brief Struct to concentrate all visualization configurations
 /// in order to harmonize visualization interfaces
 struct ViewConfig {
-  /// Constructor to switch visibility off
-  ViewConfig(bool vis = true) : visible(vis) {}
-
-  /// Constructor for color settings only
-  ViewConfig(const ColorRGB& rgb) : color(rgb) {}
-
   /// Visible flag
   bool visible = true;
-  /// The RGB color for this object
-  ColorRGB color = {250, 0, 0};
+  /// The color for this object
+  Color color = {250, 0, 0};
   /// Out of plane drawing parameter for objects
   double offset = 0.1;
   /// The visual line thickness for this object
diff --git a/Core/include/Acts/Visualization/detail/ObjVisualization3D.ipp b/Core/include/Acts/Visualization/detail/ObjVisualization3D.ipp
index e43bbb11f19..b959eb9e18c 100644
--- a/Core/include/Acts/Visualization/detail/ObjVisualization3D.ipp
+++ b/Core/include/Acts/Visualization/detail/ObjVisualization3D.ipp
@@ -7,15 +7,15 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 template <typename T>
-void ObjVisualization3D<T>::vertex(const Vector3& vtx, ColorRGB color) {
+void ObjVisualization3D<T>::vertex(const Vector3& vtx, Color color) {
   m_vertexColors[m_vertices.size()] = color;
   m_vertices.push_back(vtx.template cast<ValueType>());
 }
 
 template <typename T>
 void ObjVisualization3D<T>::line(const Vector3& a, const Vector3& b,
-                                 ColorRGB color) {
-  if (color != ColorRGB{0, 0, 0}) {
+                                 Color color) {
+  if (color != Color{0, 0, 0}) {
     m_lineColors[m_lines.size()] = color;
   }
   // not implemented
@@ -26,8 +26,8 @@ void ObjVisualization3D<T>::line(const Vector3& a, const Vector3& b,
 
 template <typename T>
 void ObjVisualization3D<T>::face(const std::vector<Vector3>& vtxs,
-                                 ColorRGB color) {
-  if (color != ColorRGB{0, 0, 0}) {
+                                 Color color) {
+  if (color != Color{0, 0, 0}) {
     m_faceColors[m_faces.size()] = color;
   }
   FaceType idxs;
@@ -42,16 +42,16 @@ void ObjVisualization3D<T>::face(const std::vector<Vector3>& vtxs,
 template <typename T>
 void ObjVisualization3D<T>::faces(const std::vector<Vector3>& vtxs,
                                   const std::vector<FaceType>& faces,
-                                  ColorRGB color) {
+                                  Color color) {
   // No faces given - call the face() method
   if (faces.empty()) {
     face(vtxs, color);
   } else {
-    if (color != ColorRGB{0, 0, 0}) {
+    if (color != Color{0, 0, 0}) {
       m_faceColors[m_faces.size()] = color;
     }
     auto vtxoffs = m_vertices.size();
-    if (color != ColorRGB{0, 0, 0}) {
+    if (color != Color{0, 0, 0}) {
       m_vertexColors[m_vertices.size()] = color;
     }
     m_vertices.insert(m_vertices.end(), vtxs.begin(), vtxs.end());
@@ -99,7 +99,7 @@ template <typename T>
 void ObjVisualization3D<T>::write(std::ostream& os, std::ostream& mos) const {
   std::map<std::string, bool> materials;
 
-  auto mixColor = [&](const ColorRGB& color) -> std::string {
+  auto mixColor = [&](const Color& color) -> std::string {
     std::string materialName;
     materialName = "material_";
     materialName += std::to_string(color[0]) + std::string("_");
@@ -121,7 +121,7 @@ void ObjVisualization3D<T>::write(std::ostream& os, std::ostream& mos) const {
   };
 
   std::size_t iv = 0;
-  ColorRGB lastVertexColor = {0, 0, 0};
+  Color lastVertexColor = {0, 0, 0};
   for (const VertexType& vtx : m_vertices) {
     if (m_vertexColors.find(iv) != m_vertexColors.end()) {
       auto color = m_vertexColors.find(iv)->second;
@@ -137,7 +137,7 @@ void ObjVisualization3D<T>::write(std::ostream& os, std::ostream& mos) const {
     ++iv;
   }
   std::size_t il = 0;
-  ColorRGB lastLineColor = {0, 0, 0};
+  Color lastLineColor = {0, 0, 0};
   for (const LineType& ln : m_lines) {
     if (m_lineColors.find(il) != m_lineColors.end()) {
       auto color = m_lineColors.find(il)->second;
@@ -150,7 +150,7 @@ void ObjVisualization3D<T>::write(std::ostream& os, std::ostream& mos) const {
     ++il;
   }
   std::size_t is = 0;
-  ColorRGB lastFaceColor = {0, 0, 0};
+  Color lastFaceColor = {0, 0, 0};
   for (const FaceType& fc : m_faces) {
     if (m_faceColors.find(is) != m_faceColors.end()) {
       auto color = m_faceColors.find(is)->second;
diff --git a/Core/include/Acts/Visualization/detail/PlyVisualization3D.ipp b/Core/include/Acts/Visualization/detail/PlyVisualization3D.ipp
index c5c12b2dc89..30d69126b0e 100644
--- a/Core/include/Acts/Visualization/detail/PlyVisualization3D.ipp
+++ b/Core/include/Acts/Visualization/detail/PlyVisualization3D.ipp
@@ -7,13 +7,13 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 template <typename T>
-void PlyVisualization3D<T>::vertex(const Vector3& vtx, ColorRGB color) {
+void PlyVisualization3D<T>::vertex(const Vector3& vtx, Color color) {
   m_vertices.emplace_back(vtx.template cast<ValueType>(), color);
 }
 
 template <typename T>
 void PlyVisualization3D<T>::face(const std::vector<Vector3>& vtxs,
-                                 ColorRGB color) {
+                                 Color color) {
   FaceType idxs;
   idxs.reserve(vtxs.size());
   for (const auto& vtx : vtxs) {
@@ -26,13 +26,13 @@ void PlyVisualization3D<T>::face(const std::vector<Vector3>& vtxs,
 template <typename T>
 void PlyVisualization3D<T>::faces(const std::vector<Vector3>& vtxs,
                                   const std::vector<FaceType>& /*faces*/,
-                                  ColorRGB color) {
+                                  Color color) {
   face(vtxs, color);
 }
 
 template <typename T>
 void PlyVisualization3D<T>::line(const Vector3& a, const Vector3& b,
-                                 ColorRGB color) {
+                                 Color color) {
   vertex(a, color);
   std::size_t idx_a = m_vertices.size() - 1;
   vertex(b, color);
@@ -73,7 +73,7 @@ void PlyVisualization3D<T>::write(std::ostream& os) const {
   os << "property uchar blue\n";
   os << "end_header\n";
 
-  for (const std::pair<VertexType, ColorRGB>& vtx : m_vertices) {
+  for (const std::pair<VertexType, Color>& vtx : m_vertices) {
     os << vtx.first.x() << " " << vtx.first.y() << " " << vtx.first.z() << " ";
     os << vtx.second[0] << " " << vtx.second[1] << " " << vtx.second[2] << "\n";
   }
@@ -86,7 +86,7 @@ void PlyVisualization3D<T>::write(std::ostream& os) const {
     os << "\n";
   }
 
-  for (const std::pair<std::pair<std::size_t, std::size_t>, ColorRGB>& edge :
+  for (const std::pair<std::pair<std::size_t, std::size_t>, Color>& edge :
        m_edges) {
     std::pair<std::size_t, std::size_t> idxs = edge.first;
     os << idxs.first << " " << idxs.second << " ";
diff --git a/Core/src/Detector/LayerStructureBuilder.cpp b/Core/src/Detector/LayerStructureBuilder.cpp
index 6a421671cf1..c12bafc7b4c 100644
--- a/Core/src/Detector/LayerStructureBuilder.cpp
+++ b/Core/src/Detector/LayerStructureBuilder.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -23,7 +23,9 @@
 #include "Acts/Utilities/Enumerate.hpp"
 #include "Acts/Utilities/Grid.hpp"
 #include "Acts/Utilities/GridAxisGenerators.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 
+#include <algorithm>
 #include <cmath>
 #include <cstddef>
 #include <ostream>
@@ -242,9 +244,7 @@ Acts::Experimental::LayerStructureBuilder::construct(
       // the binning value that are not constrained by the internal surfaces
       for (const auto& bv : allBinningValues()) {
         if (support.volumeExtent.constrains(bv) &&
-            std::find(support.internalConstraints.begin(),
-                      support.internalConstraints.end(),
-                      bv) == support.internalConstraints.end()) {
+            !rangeContainsValue(support.internalConstraints, bv)) {
           ACTS_VERBOSE("  Support surface is constrained by volume extent in "
                        << binningValueName(bv));
           supportExtent.set(bv, support.volumeExtent.min(bv),
@@ -339,10 +339,7 @@ Acts::Experimental::LayerStructureBuilder::construct(
         adaptBinningRange(binnings, m_cfg.extent.value());
       }
       // Sort the binning for conventions
-      std::sort(binnings.begin(), binnings.end(),
-                [](const ProtoBinning& a, const ProtoBinning& b) {
-                  return a.binValue < b.binValue;
-                });
+      std::ranges::sort(binnings, {}, [](const auto& b) { return b.binValue; });
 
       ACTS_DEBUG("- 2-dimensional surface binning detected.");
       // Capture the binnings
diff --git a/Core/src/Detector/VolumeStructureBuilder.cpp b/Core/src/Detector/VolumeStructureBuilder.cpp
index 49dba260a52..afa10e45cd7 100644
--- a/Core/src/Detector/VolumeStructureBuilder.cpp
+++ b/Core/src/Detector/VolumeStructureBuilder.cpp
@@ -62,7 +62,7 @@ Acts::Experimental::VolumeStructureBuilder::construct(
             "object. It needs at least 5 parameters, while " +
             std::to_string(boundValues.size()) + " where given");
       }
-      auto bArray = to_array<ConeVolumeBounds::BoundValues::eSize, ActsScalar>(
+      auto bArray = toArray<ConeVolumeBounds::BoundValues::eSize, ActsScalar>(
           boundValues);
       volumeBounds = std::make_unique<ConeVolumeBounds>(bArray);
     } break;
@@ -94,7 +94,7 @@ Acts::Experimental::VolumeStructureBuilder::construct(
             std::to_string(boundValues.size()) + " where given");
       }
       auto bArray =
-          to_array<CuboidVolumeBounds::BoundValues::eSize>(boundValues);
+          toArray<CuboidVolumeBounds::BoundValues::eSize>(boundValues);
       volumeBounds = std::make_unique<CuboidVolumeBounds>(bArray);
     } break;
     case VolumeBounds::BoundsType::eCutoutCylinder: {
@@ -108,7 +108,7 @@ Acts::Experimental::VolumeStructureBuilder::construct(
             std::to_string(boundValues.size()) + " where given");
       }
       auto bArray =
-          to_array<CutoutCylinderVolumeBounds::BoundValues::eSize>(boundValues);
+          toArray<CutoutCylinderVolumeBounds::BoundValues::eSize>(boundValues);
       volumeBounds = std::make_unique<CutoutCylinderVolumeBounds>(bArray);
     } break;
     case VolumeBounds::BoundsType::eCylinder: {
@@ -150,7 +150,7 @@ Acts::Experimental::VolumeStructureBuilder::construct(
                    << boundValues[2] << ", " << boundValues[3] << ", "
                    << boundValues[4]);
       auto bArray =
-          to_array<CylinderVolumeBounds::BoundValues::eSize>(boundValues);
+          toArray<CylinderVolumeBounds::BoundValues::eSize>(boundValues);
       volumeBounds = std::make_unique<CylinderVolumeBounds>(bArray);
     } break;
     case VolumeBounds::BoundsType::eGenericCuboid: {
@@ -164,7 +164,7 @@ Acts::Experimental::VolumeStructureBuilder::construct(
             std::to_string(boundValues.size()) + " where given");
       }
       auto bArray =
-          to_array<GenericCuboidVolumeBounds::BoundValues::eSize>(boundValues);
+          toArray<GenericCuboidVolumeBounds::BoundValues::eSize>(boundValues);
       volumeBounds = std::make_unique<GenericCuboidVolumeBounds>(bArray);
     } break;
     case VolumeBounds::BoundsType::eTrapezoid: {
@@ -178,7 +178,7 @@ Acts::Experimental::VolumeStructureBuilder::construct(
             std::to_string(boundValues.size()) + " where given");
       }
       auto bArray =
-          to_array<TrapezoidVolumeBounds::BoundValues::eSize>(boundValues);
+          toArray<TrapezoidVolumeBounds::BoundValues::eSize>(boundValues);
       volumeBounds = std::make_unique<TrapezoidVolumeBounds>(bArray);
     } break;
     default:
diff --git a/Core/src/Detector/detail/BlueprintDrawer.cpp b/Core/src/Detector/detail/BlueprintDrawer.cpp
index 7d76c9614eb..47ee292fe99 100644
--- a/Core/src/Detector/detail/BlueprintDrawer.cpp
+++ b/Core/src/Detector/detail/BlueprintDrawer.cpp
@@ -84,9 +84,11 @@ void Acts::Experimental::detail::BlueprintDrawer::dotStream(
 
   // Shape
   Options::Node shape = node.isLeaf() ? options.shape : options.virtualShape;
+  std::stringstream bts;
+  bts << node.boundsType;
   ss << node.name + "_shape " << shapeStr(shape) << '\n';
   ss << node.name + "_shape "
-     << labelStr(shape, VolumeBounds::s_boundsTypeNames[node.boundsType],
+     << labelStr(shape, bts.str(),
                  {"t = " + toString(node.transform.translation(), 1),
                   "b = " + toString(node.boundaryValues, 1)})
      << '\n';
diff --git a/Core/src/Detector/detail/BlueprintHelper.cpp b/Core/src/Detector/detail/BlueprintHelper.cpp
index 305cd58f349..502d91f4d10 100644
--- a/Core/src/Detector/detail/BlueprintHelper.cpp
+++ b/Core/src/Detector/detail/BlueprintHelper.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -12,6 +12,7 @@
 #include "Acts/Definitions/Tolerance.hpp"
 #include "Acts/Geometry/VolumeBounds.hpp"
 
+#include <algorithm>
 #include <array>
 
 namespace {
@@ -55,19 +56,14 @@ void Acts::Experimental::detail::BlueprintHelper::sort(Blueprint::Node& node,
         bVal == BinningValue::binZ) {
       Vector3 nodeCenter = node.transform.translation();
       Vector3 nodeSortAxis = node.transform.rotation().col(toUnderlying(bVal));
-      std::sort(
-          node.children.begin(), node.children.end(),
-          [&](const auto& a, const auto& b) {
-            return (a->transform.translation() - nodeCenter).dot(nodeSortAxis) <
-                   (b->transform.translation() - nodeCenter).dot(nodeSortAxis);
-          });
+      std::ranges::sort(node.children, {}, [&](const auto& c) {
+        return (c->transform.translation() - nodeCenter).dot(nodeSortAxis);
+      });
     } else if (bVal == BinningValue::binR &&
                node.boundsType == VolumeBounds::eCylinder) {
-      std::sort(node.children.begin(), node.children.end(),
-                [](const auto& a, const auto& b) {
-                  return 0.5 * (a->boundaryValues[0] + a->boundaryValues[1]) <
-                         0.5 * (b->boundaryValues[0] + b->boundaryValues[1]);
-                });
+      std::ranges::sort(node.children, {}, [](const auto& c) {
+        return c->boundaryValues[0] + c->boundaryValues[1];
+      });
     }
   }
 
diff --git a/Core/src/Detector/detail/CuboidalDetectorHelper.cpp b/Core/src/Detector/detail/CuboidalDetectorHelper.cpp
index 4bf7edbabd2..fe7656cdfcd 100644
--- a/Core/src/Detector/detail/CuboidalDetectorHelper.cpp
+++ b/Core/src/Detector/detail/CuboidalDetectorHelper.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -19,6 +19,7 @@
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/BinningData.hpp"
 #include "Acts/Utilities/Enumerate.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Utilities/StringHelpers.hpp"
 
 #include <algorithm>
@@ -190,9 +191,7 @@ Acts::Experimental::detail::CuboidalDetectorHelper::connect(
 
     for (auto [is, index] : enumerate(portalSets[toUnderlying(mergeValue)])) {
       // Check if you need to skip due to selections
-      if (!selectedOnly.empty() &&
-          std::find(selectedOnly.begin(), selectedOnly.end(), index) ==
-              selectedOnly.end()) {
+      if (!selectedOnly.empty() && !rangeContainsValue(selectedOnly, index)) {
         continue;
       }
 
@@ -380,7 +379,7 @@ Acts::Experimental::detail::CuboidalDetectorHelper::xyzBoundaries(
     for (auto [key, value] : map) {
       boundaries[im].push_back(key);
     }
-    std::sort(boundaries[im].begin(), boundaries[im].end());
+    std::ranges::sort(boundaries[im]);
   }
 
   ACTS_VERBOSE("- did yield " << boundaries[0u].size() << " boundaries in X.");
diff --git a/Core/src/Detector/detail/CylindricalDetectorHelper.cpp b/Core/src/Detector/detail/CylindricalDetectorHelper.cpp
index 7fce725b4f6..2ed29f0b35a 100644
--- a/Core/src/Detector/detail/CylindricalDetectorHelper.cpp
+++ b/Core/src/Detector/detail/CylindricalDetectorHelper.cpp
@@ -325,9 +325,7 @@ Acts::Experimental::detail::CylindricalDetectorHelper::connectInR(
   rBoundaries.push_back(refValues[CylinderVolumeBounds::BoundValues::eMaxR]);
 
   // Connect in R ? (2u is the index of the outer cylinder)
-  bool connectR = selectedOnly.empty() ||
-                  std::find(selectedOnly.begin(), selectedOnly.end(), 2u) !=
-                      selectedOnly.end();
+  bool connectR = selectedOnly.empty() || rangeContainsValue(selectedOnly, 2u);
 
   // Get phi sector and average phi
   ActsScalar phiSector =
@@ -376,9 +374,7 @@ Acts::Experimental::detail::CylindricalDetectorHelper::connectInR(
   std::vector<Acts::Direction> discDirs = {Acts::Direction::Forward,
                                            Acts::Direction::Backward};
   for (const auto [iu, idir] : enumerate(discDirs)) {
-    if (selectedOnly.empty() ||
-        std::find(selectedOnly.begin(), selectedOnly.end(), iu) !=
-            selectedOnly.end()) {
+    if (selectedOnly.empty() || rangeContainsValue(selectedOnly, iu)) {
       const Surface& refSurface = volumes[0u]->portals()[iu]->surface();
       const Transform3& refTransform = refSurface.transform(gctx);
       pReplacements.push_back(createDiscReplacement(
@@ -397,9 +393,7 @@ Acts::Experimental::detail::CylindricalDetectorHelper::connectInR(
     for (const auto [iu, idir] : enumerate(sectorDirs)) {
       // (iu + 4u) corresponds to the indices of the phi-low and phi-high sector
       // planes.
-      if (selectedOnly.empty() ||
-          std::find(selectedOnly.begin(), selectedOnly.end(), iu + 4u) !=
-              selectedOnly.end()) {
+      if (selectedOnly.empty() || rangeContainsValue(selectedOnly, iu + 4u)) {
         // As it is r-wrapping, the inner tube is guaranteed
         const Surface& refSurface =
             volumes[volumes.size() - 1u]->portals()[iu + 4u]->surface();
@@ -471,9 +465,8 @@ Acts::Experimental::detail::CylindricalDetectorHelper::connectInZ(
   // Connect in Z ?
   // - 1u corresponds to the index of the high-z disc portal for the reference
   // volume.
-  bool connectZ = selectedOnly.empty() ||
-                  std::find(selectedOnly.begin(), selectedOnly.end(), 1u) !=
-                      selectedOnly.end();
+  const bool connectZ =
+      selectedOnly.empty() || rangeContainsValue(selectedOnly, 1u);
   // Reference z axis
   const auto rotation = volumes[0u]->transform(gctx).rotation();
 
@@ -586,9 +579,7 @@ Acts::Experimental::detail::CylindricalDetectorHelper::connectInZ(
   unsigned int iSecOffset = innerPresent ? 4u : 3u;
   // Prepare the cylinder replacements
   for (const auto [iu, idir] : enumerate(cylinderDirs)) {
-    if (selectedOnly.empty() ||
-        std::find(selectedOnly.begin(), selectedOnly.end(), iu + 2u) !=
-            selectedOnly.end()) {
+    if (selectedOnly.empty() || rangeContainsValue(selectedOnly, iu + 2u)) {
       pReplacements.push_back(createCylinderReplacement(
           combinedTransform, cylinderR[iu], zBoundaries,
           {avgPhi - phiSector, avgPhi + phiSector}, iu + 2u, idir));
@@ -603,9 +594,7 @@ Acts::Experimental::detail::CylindricalDetectorHelper::connectInZ(
                                                Acts::Direction::Backward};
     for (const auto [iu, idir] : enumerate(sectorDirs)) {
       // Access with 3u or 4u but always write 4u (to be caught later)
-      if (selectedOnly.empty() ||
-          std::find(selectedOnly.begin(), selectedOnly.end(), iu + 4u) !=
-              selectedOnly.end()) {
+      if (selectedOnly.empty() || rangeContainsValue(selectedOnly, iu + 4u)) {
         const Surface& refSurface =
             volumes[0u]->portals()[iu + iSecOffset]->surface();
         pReplacements.push_back(createSectorReplacement(
diff --git a/Core/src/Detector/detail/IndexedGridFiller.cpp b/Core/src/Detector/detail/IndexedGridFiller.cpp
index 82373d23947..d1bd5d17634 100644
--- a/Core/src/Detector/detail/IndexedGridFiller.cpp
+++ b/Core/src/Detector/detail/IndexedGridFiller.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -82,12 +82,12 @@ std::vector<std::size_t> Acts::Experimental::detail::binSequence(
             abs(static_cast<int>(bmin) - static_cast<int>(expand));
         fill_linear(nBins - understep, nBins);
       }
-      std::sort(rBins.begin(), rBins.end());
+      std::ranges::sort(rBins);
     } else {
       // Jump over the phi boundary
       fill_linear(bmax - expand, nBins);
       fill_linear(1, bmin + expand);
-      std::sort(rBins.begin(), rBins.end());
+      std::ranges::sort(rBins);
     }
   }
   return rBins;
diff --git a/Core/src/Geometry/CuboidVolumeBuilder.cpp b/Core/src/Geometry/CuboidVolumeBuilder.cpp
index 02b600b37ef..1d226ca05fd 100644
--- a/Core/src/Geometry/CuboidVolumeBuilder.cpp
+++ b/Core/src/Geometry/CuboidVolumeBuilder.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2018-2024 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
@@ -212,10 +212,7 @@ Acts::MutableTrackingVolumePtr Acts::CuboidVolumeBuilder::trackingVolume(
 
   // Sort the volumes vectors according to the center location, otherwise the
   // binning boundaries will fail
-  std::sort(volumes.begin(), volumes.end(),
-            [](const TrackingVolumePtr& lhs, const TrackingVolumePtr& rhs) {
-              return lhs->center().x() < rhs->center().x();
-            });
+  std::ranges::sort(volumes, {}, [](const auto& v) { return v->center().x(); });
 
   // Glue volumes
   for (unsigned int i = 0; i < volumes.size() - 1; i++) {
diff --git a/Core/src/Geometry/CylinderVolumeBuilder.cpp b/Core/src/Geometry/CylinderVolumeBuilder.cpp
index 195eaefffe6..8690c1d9b82 100644
--- a/Core/src/Geometry/CylinderVolumeBuilder.cpp
+++ b/Core/src/Geometry/CylinderVolumeBuilder.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2016-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2016-2024 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
@@ -295,8 +295,8 @@ Acts::CylinderVolumeBuilder::trackingVolume(
 
       // we check radii for consistency from the inside outwards, so need to
       // sort
-      std::sort(innerRadii.begin(), innerRadii.end());
-      std::sort(outerRadii.begin(), outerRadii.end());
+      std::ranges::sort(innerRadii);
+      std::ranges::sort(outerRadii);
 
       ACTS_DEBUG("Inner radii:" << [&]() {
         std::stringstream ss;
diff --git a/Core/src/Geometry/CylinderVolumeStack.cpp b/Core/src/Geometry/CylinderVolumeStack.cpp
index 9b4f05fc43e..af32f1b743e 100644
--- a/Core/src/Geometry/CylinderVolumeStack.cpp
+++ b/Core/src/Geometry/CylinderVolumeStack.cpp
@@ -15,6 +15,7 @@
 #include "Acts/Utilities/BinningType.hpp"
 #include "Acts/Utilities/Logger.hpp"
 
+#include <algorithm>
 #include <memory>
 #include <sstream>
 
@@ -159,11 +160,9 @@ void CylinderVolumeStack::initializeOuterVolume(BinningValue direction,
 
   if (direction == Acts::BinningValue::binZ) {
     ACTS_VERBOSE("Sorting by volume z position");
-    std::sort(volumeTuples.begin(), volumeTuples.end(),
-              [](const auto& a, const auto& b) {
-                return a.localTransform.translation()[eZ] <
-                       b.localTransform.translation()[eZ];
-              });
+    std::ranges::sort(volumeTuples, {}, [](const auto& v) {
+      return v.localTransform.translation()[eZ];
+    });
 
     ACTS_VERBOSE("Checking for overlaps and attaching volumes in z");
     std::vector<VolumeTuple> gapVolumes =
@@ -192,8 +191,7 @@ void CylinderVolumeStack::initializeOuterVolume(BinningValue direction,
     ACTS_VERBOSE("*** Volume configuration after r synchronization:");
     printVolumeSequence(volumeTuples, logger, Acts::Logging::VERBOSE);
 
-    std::sort(volumeTuples.begin(), volumeTuples.end(),
-              [](const auto& a, const auto& b) { return a.midZ() < b.midZ(); });
+    std::ranges::sort(volumeTuples, {}, [](const auto& v) { return v.midZ(); });
 
     m_volumes.clear();
     for (const auto& vt : volumeTuples) {
@@ -222,8 +220,7 @@ void CylinderVolumeStack::initializeOuterVolume(BinningValue direction,
 
   } else if (direction == Acts::BinningValue::binR) {
     ACTS_VERBOSE("Sorting by volume r middle point");
-    std::sort(volumeTuples.begin(), volumeTuples.end(),
-              [](const auto& a, const auto& b) { return a.midR() < b.midR(); });
+    std::ranges::sort(volumeTuples, {}, [](const auto& v) { return v.midR(); });
 
     ACTS_VERBOSE("Checking for overlaps and attaching volumes in r");
     std::vector<VolumeTuple> gapVolumes =
@@ -250,8 +247,7 @@ void CylinderVolumeStack::initializeOuterVolume(BinningValue direction,
     ACTS_VERBOSE("*** Volume configuration after z synchronization:");
     printVolumeSequence(volumeTuples, logger, Acts::Logging::VERBOSE);
 
-    std::sort(volumeTuples.begin(), volumeTuples.end(),
-              [](const auto& a, const auto& b) { return a.midR() < b.midR(); });
+    std::ranges::sort(volumeTuples, {}, [](const auto& v) { return v.midR(); });
 
     m_volumes.clear();
     for (const auto& vt : volumeTuples) {
diff --git a/Core/src/Geometry/GridPortalLinkMerging.cpp b/Core/src/Geometry/GridPortalLinkMerging.cpp
index 51dfd89548b..80ad2b78ca9 100644
--- a/Core/src/Geometry/GridPortalLinkMerging.cpp
+++ b/Core/src/Geometry/GridPortalLinkMerging.cpp
@@ -213,11 +213,11 @@ std::unique_ptr<GridPortalLink> colinearMerge(
     auto mergedPortalLink = mergeVariableLocal();
     return mergedPortalLink;
   } else if (aType == AxisType::Equidistant && bType == AxisType::Variable) {
-    ACTS_WARNING("===> mixed merged");
+    ACTS_VERBOSE("===> mixed merged");
     auto mergedPortalLink = mergeVariableLocal();
     return mergedPortalLink;
   } else {
-    ACTS_WARNING("===> mixed merged");
+    ACTS_VERBOSE("===> mixed merged");
     auto mergedPortalLink = mergeVariableLocal();
     return mergedPortalLink;
   }
diff --git a/Core/src/Geometry/Layer.cpp b/Core/src/Geometry/Layer.cpp
index 5598a854a41..af9ea08da42 100644
--- a/Core/src/Geometry/Layer.cpp
+++ b/Core/src/Geometry/Layer.cpp
@@ -14,6 +14,7 @@
 #include "Acts/Propagator/Navigator.hpp"
 #include "Acts/Surfaces/BoundaryTolerance.hpp"
 #include "Acts/Surfaces/Surface.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Utilities/Intersection.hpp"
 
 #include <algorithm>
@@ -159,9 +160,7 @@ Acts::Layer::compatibleSurfaces(
       return;
     }
     BoundaryTolerance boundaryTolerance = options.boundaryTolerance;
-    if (std::find(options.externalSurfaces.begin(),
-                  options.externalSurfaces.end(),
-                  sf.geometryId()) != options.externalSurfaces.end()) {
+    if (rangeContainsValue(options.externalSurfaces, sf.geometryId())) {
       boundaryTolerance = BoundaryTolerance::Infinite();
     }
     // the surface intersection
diff --git a/Core/src/Geometry/LayerArrayCreator.cpp b/Core/src/Geometry/LayerArrayCreator.cpp
index baca1a8c13d..0a9c74d76f5 100644
--- a/Core/src/Geometry/LayerArrayCreator.cpp
+++ b/Core/src/Geometry/LayerArrayCreator.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
+// Copyright (C) 2016-2024 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
@@ -42,7 +42,7 @@ std::unique_ptr<const Acts::LayerArray> Acts::LayerArrayCreator::layerArray(
 
   // sort it accordingly to the binning value
   GeometryObjectSorterT<std::shared_ptr<const Layer>> layerSorter(gctx, bValue);
-  std::sort(layers.begin(), layers.end(), layerSorter);
+  std::ranges::sort(layers, layerSorter);
   // useful typedef
   using LayerOrderPosition = std::pair<std::shared_ptr<const Layer>, Vector3>;
   // needed for all cases
diff --git a/Core/src/Geometry/Polyhedron.cpp b/Core/src/Geometry/Polyhedron.cpp
index 6663a49705a..437d8d951cb 100644
--- a/Core/src/Geometry/Polyhedron.cpp
+++ b/Core/src/Geometry/Polyhedron.cpp
@@ -10,6 +10,7 @@
 
 #include "Acts/Surfaces/detail/VerticesHelper.hpp"
 #include "Acts/Utilities/BinningType.hpp"
+#include "Acts/Visualization/IVisualization3D.hpp"
 
 #include <algorithm>
 #include <cmath>
@@ -96,3 +97,14 @@ Acts::Extent Acts::Polyhedron::extent(const Transform3& transform) const {
   }
   return extent;
 }
+
+void Acts::Polyhedron::visualize(IVisualization3D& helper,
+                                 const ViewConfig& viewConfig) const {
+  if (viewConfig.visible) {
+    if (!viewConfig.triangulate) {
+      helper.faces(vertices, faces, viewConfig.color);
+    } else {
+      helper.faces(vertices, triangularMesh, viewConfig.color);
+    }
+  }
+}
diff --git a/Core/src/Geometry/Portal.cpp b/Core/src/Geometry/Portal.cpp
index 4b1e65356af..fac9041b40f 100644
--- a/Core/src/Geometry/Portal.cpp
+++ b/Core/src/Geometry/Portal.cpp
@@ -175,7 +175,7 @@ const RegularSurface& Portal::surface() const {
 Portal Portal::merge(const GeometryContext& gctx, Portal& aPortal,
                      Portal& bPortal, BinningValue direction,
                      const Logger& logger) {
-  ACTS_DEBUG("Merging to portals along " << direction);
+  ACTS_VERBOSE("Merging two portals along " << direction);
 
   if (&aPortal == &bPortal) {
     ACTS_ERROR("Cannot merge a portal with itself");
@@ -238,7 +238,7 @@ Portal Portal::merge(const GeometryContext& gctx, Portal& aPortal,
 
 Portal Portal::fuse(const GeometryContext& gctx, Portal& aPortal,
                     Portal& bPortal, const Logger& logger) {
-  ACTS_DEBUG("Fusing two portals");
+  ACTS_VERBOSE("Fusing two portals");
   if (&aPortal == &bPortal) {
     ACTS_ERROR("Cannot merge a portal with itself");
     throw PortalMergingException{};
diff --git a/Core/src/Geometry/PortalLinkBase.cpp b/Core/src/Geometry/PortalLinkBase.cpp
index 9a6be75794c..46d3d25e202 100644
--- a/Core/src/Geometry/PortalLinkBase.cpp
+++ b/Core/src/Geometry/PortalLinkBase.cpp
@@ -64,7 +64,7 @@ void PortalLinkBase::checkMergePreconditions(const PortalLinkBase& a,
 std::unique_ptr<PortalLinkBase> PortalLinkBase::merge(
     std::unique_ptr<PortalLinkBase> a, std::unique_ptr<PortalLinkBase> b,
     BinningValue direction, const Logger& logger) {
-  ACTS_DEBUG("Merging two arbitrary portals");
+  ACTS_VERBOSE("Merging two arbitrary portals");
 
   ACTS_VERBOSE(" - a: " << *a);
   ACTS_VERBOSE(" - b: " << *b);
diff --git a/Core/src/Geometry/SurfaceArrayCreator.cpp b/Core/src/Geometry/SurfaceArrayCreator.cpp
index c01a4473b4f..7968b576f2c 100644
--- a/Core/src/Geometry/SurfaceArrayCreator.cpp
+++ b/Core/src/Geometry/SurfaceArrayCreator.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2016-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2016-2024 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
@@ -539,7 +539,7 @@ Acts::SurfaceArrayCreator::createVariableAxis(
       previous = perp((*surface)->binningPosition(gctx, BinningValue::binR));
     }
   }
-  std::sort(bValues.begin(), bValues.end());
+  std::ranges::sort(bValues);
   ACTS_VERBOSE("Create variable binning Axis for binned SurfaceArray");
   ACTS_VERBOSE("	BinningValue: " << bValue);
   ACTS_VERBOSE("	Number of bins: " << (bValues.size() - 1));
diff --git a/Core/src/Geometry/TrackingGeometry.cpp b/Core/src/Geometry/TrackingGeometry.cpp
index 45cc7ee515d..82e9c09239c 100644
--- a/Core/src/Geometry/TrackingGeometry.cpp
+++ b/Core/src/Geometry/TrackingGeometry.cpp
@@ -22,8 +22,7 @@ Acts::TrackingGeometry::TrackingGeometry(
     const MutableTrackingVolumePtr& highestVolume,
     const IMaterialDecorator* materialDecorator,
     const GeometryIdentifierHook& hook, const Logger& logger)
-    : m_world(highestVolume),
-      m_beam(Surface::makeShared<PerigeeSurface>(Vector3::Zero())) {
+    : m_world(highestVolume) {
   // Close the geometry: assign geometryID and successively the material
   std::size_t volumeID = 0;
   highestVolume->closeGeometry(materialDecorator, m_volumesById, volumeID, hook,
@@ -50,8 +49,8 @@ const Acts::TrackingVolume* Acts::TrackingGeometry::highestTrackingVolume()
   return m_world.get();
 }
 
-const std::shared_ptr<const Acts::TrackingVolume>&
-Acts::TrackingGeometry::highestTrackingVolumeShared() const {
+std::shared_ptr<const Acts::TrackingVolume>
+Acts::TrackingGeometry::highestTrackingVolumePtr() const {
   return m_world;
 }
 
@@ -64,15 +63,6 @@ const Acts::Layer* Acts::TrackingGeometry::associatedLayer(
   return lowestVol->associatedLayer(gctx, gp);
 }
 
-void Acts::TrackingGeometry::registerBeamTube(
-    std::shared_ptr<const PerigeeSurface> beam) {
-  m_beam = std::move(beam);
-}
-
-const Acts::Surface* Acts::TrackingGeometry::getBeamline() const {
-  return m_beam.get();
-}
-
 const Acts::TrackingVolume* Acts::TrackingGeometry::findVolume(
     GeometryIdentifier id) const {
   auto vol = m_volumesById.find(id);
diff --git a/Core/src/Geometry/TrackingVolume.cpp b/Core/src/Geometry/TrackingVolume.cpp
index bbed048efdd..5e9bab8a742 100644
--- a/Core/src/Geometry/TrackingVolume.cpp
+++ b/Core/src/Geometry/TrackingVolume.cpp
@@ -366,7 +366,7 @@ void TrackingVolume::closeGeometry(
         thisVolume->motherVolume()->volumeMaterial());
     if (protoMaterial == nullptr) {
       thisVolume->assignVolumeMaterial(
-          thisVolume->motherVolume()->volumeMaterialSharedPtr());
+          thisVolume->motherVolume()->volumeMaterialPtr());
     }
   }
 
@@ -577,7 +577,7 @@ const IVolumeMaterial* TrackingVolume::volumeMaterial() const {
 }
 
 const std::shared_ptr<const IVolumeMaterial>&
-TrackingVolume::volumeMaterialSharedPtr() const {
+TrackingVolume::volumeMaterialPtr() const {
   return m_volumeMaterial;
 }
 
diff --git a/Core/src/Geometry/TrackingVolumeArrayCreator.cpp b/Core/src/Geometry/TrackingVolumeArrayCreator.cpp
index 15ca130289a..e2d38b15fb0 100644
--- a/Core/src/Geometry/TrackingVolumeArrayCreator.cpp
+++ b/Core/src/Geometry/TrackingVolumeArrayCreator.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
+// Copyright (C) 2016-2024 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
@@ -29,7 +29,7 @@ Acts::TrackingVolumeArrayCreator::trackingVolumeArray(
   // sort it accordingly to the binning value
   GeometryObjectSorterT<std::shared_ptr<const TrackingVolume>> volumeSorter(
       gctx, bValue);
-  std::sort(volumes.begin(), volumes.end(), volumeSorter);
+  std::ranges::sort(volumes, volumeSorter);
 
   // prepare what we need :
   // (1) arbitrary binning for volumes is fast enough
diff --git a/Core/src/Geometry/Volume.cpp b/Core/src/Geometry/Volume.cpp
index a04cab7b6f7..fd521e11a58 100644
--- a/Core/src/Geometry/Volume.cpp
+++ b/Core/src/Geometry/Volume.cpp
@@ -130,4 +130,13 @@ bool Volume::operator==(const Volume& other) const {
 bool Volume::operator!=(const Volume& other) const {
   return !(*this == other);
 }
+
+void Volume::visualize(IVisualization3D& helper, const GeometryContext& gctx,
+                       const ViewConfig& viewConfig) const {
+  auto bSurfaces = volumeBounds().orientedSurfaces(transform());
+  for (const auto& bs : bSurfaces) {
+    bs.surface->visualize(helper, gctx, viewConfig);
+  }
+}
+
 }  // namespace Acts
diff --git a/Core/src/Geometry/VolumeBounds.cpp b/Core/src/Geometry/VolumeBounds.cpp
index 95039632f3e..c9ab6bc41ca 100644
--- a/Core/src/Geometry/VolumeBounds.cpp
+++ b/Core/src/Geometry/VolumeBounds.cpp
@@ -8,11 +8,38 @@
 
 #include "Acts/Geometry/VolumeBounds.hpp"
 
-const std::vector<std::string> Acts::VolumeBounds::s_boundsTypeNames = {
-    "Cone",          "Cuboid",    "CutoutCylinder", "Cylinder",
-    "GenericCuboid", "Trapezoid", "Other"};
+namespace Acts {
 
-/**Overload of << operator for std::ostream for debug output*/
-std::ostream& Acts::operator<<(std::ostream& sl, const Acts::VolumeBounds& vb) {
+std::ostream& operator<<(std::ostream& sl, const Acts::VolumeBounds& vb) {
   return vb.toStream(sl);
 }
+
+std::ostream& operator<<(std::ostream& sl, const VolumeBounds::BoundsType& bt) {
+  switch (bt) {
+    using enum VolumeBounds::BoundsType;
+    case eCone:
+      sl << "Cone";
+      break;
+    case eCuboid:
+      sl << "Cuboid";
+      break;
+    case eCutoutCylinder:
+      sl << "CutoutCylinder";
+      break;
+    case eCylinder:
+      sl << "Cylinder";
+      break;
+    case eGenericCuboid:
+      sl << "GenericCuboid";
+      break;
+    case eTrapezoid:
+      sl << "Trapezoid";
+      break;
+    case eOther:
+      sl << "Other";
+      break;
+  }
+  return sl;
+}
+
+}  // namespace Acts
diff --git a/Core/src/MagneticField/BFieldMapUtils.cpp b/Core/src/MagneticField/BFieldMapUtils.cpp
index b1977daac0b..bffdc7520ef 100644
--- a/Core/src/MagneticField/BFieldMapUtils.cpp
+++ b/Core/src/MagneticField/BFieldMapUtils.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2017-2018 CERN for the benefit of the Acts project
+// Copyright (C) 2017-2024 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
@@ -39,8 +39,8 @@ Acts::fieldMapRZ(
     bool firstQuadrant) {
   // [1] Create Grid
   // sort the values
-  std::sort(rPos.begin(), rPos.end());
-  std::sort(zPos.begin(), zPos.end());
+  std::ranges::sort(rPos);
+  std::ranges::sort(zPos);
   // Get unique values
   rPos.erase(std::unique(rPos.begin(), rPos.end()), rPos.end());
   zPos.erase(std::unique(zPos.begin(), zPos.end()), zPos.end());
@@ -145,9 +145,9 @@ Acts::fieldMapXYZ(
     double lengthUnit, double BFieldUnit, bool firstOctant) {
   // [1] Create Grid
   // Sort the values
-  std::sort(xPos.begin(), xPos.end());
-  std::sort(yPos.begin(), yPos.end());
-  std::sort(zPos.begin(), zPos.end());
+  std::ranges::sort(xPos);
+  std::ranges::sort(yPos);
+  std::ranges::sort(zPos);
   // Get unique values
   xPos.erase(std::unique(xPos.begin(), xPos.end()), xPos.end());
   yPos.erase(std::unique(yPos.begin(), yPos.end()), yPos.end());
diff --git a/Core/src/Material/IntersectionMaterialAssigner.cpp b/Core/src/Material/IntersectionMaterialAssigner.cpp
index f3f068e8b0f..27adf41f78e 100644
--- a/Core/src/Material/IntersectionMaterialAssigner.cpp
+++ b/Core/src/Material/IntersectionMaterialAssigner.cpp
@@ -12,6 +12,8 @@
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/StringHelpers.hpp"
 
+#include <algorithm>
+
 namespace {
 
 std::vector<Acts::SurfaceIntersection> forwardOrderedIntersections(
@@ -35,8 +37,8 @@ std::vector<Acts::SurfaceIntersection> forwardOrderedIntersections(
     }
   }
   // Sort the intersection along the pathlength
-  std::sort(sIntersections.begin(), sIntersections.end(),
-            &Acts::SurfaceIntersection::pathLengthOrder);
+  std::ranges::sort(sIntersections,
+                    &Acts::SurfaceIntersection::pathLengthOrder);
   return sIntersections;
 }
 
diff --git a/Core/src/Material/MaterialMapUtils.cpp b/Core/src/Material/MaterialMapUtils.cpp
index ee866556cd5..64fdd1f5187 100644
--- a/Core/src/Material/MaterialMapUtils.cpp
+++ b/Core/src/Material/MaterialMapUtils.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2019-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2019-2024 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
@@ -44,8 +44,8 @@ auto Acts::materialMapperRZ(
 
   // [2] Create Grid
   // sort the values
-  std::sort(rPos.begin(), rPos.end());
-  std::sort(zPos.begin(), zPos.end());
+  std::ranges::sort(rPos);
+  std::ranges::sort(zPos);
   // Get unique values
   rPos.erase(std::unique(rPos.begin(), rPos.end()), rPos.end());
   zPos.erase(std::unique(zPos.begin(), zPos.end()), zPos.end());
@@ -126,9 +126,9 @@ auto Acts::materialMapperXYZ(
 
   // [2] Create Grid
   // Sort the values
-  std::sort(xPos.begin(), xPos.end());
-  std::sort(yPos.begin(), yPos.end());
-  std::sort(zPos.begin(), zPos.end());
+  std::ranges::sort(xPos);
+  std::ranges::sort(yPos);
+  std::ranges::sort(zPos);
   // Get unique values
   xPos.erase(std::unique(xPos.begin(), xPos.end()), xPos.end());
   yPos.erase(std::unique(yPos.begin(), yPos.end()), yPos.end());
diff --git a/Core/src/Material/SurfaceMaterialMapper.cpp b/Core/src/Material/SurfaceMaterialMapper.cpp
index a8d62f0e75c..f2e928b7a15 100644
--- a/Core/src/Material/SurfaceMaterialMapper.cpp
+++ b/Core/src/Material/SurfaceMaterialMapper.cpp
@@ -173,8 +173,7 @@ void Acts::SurfaceMaterialMapper::collectMaterialVolumes(
                                    << "' for material surfaces.");
   ACTS_VERBOSE("- Insert Volume ...");
   if (tVolume.volumeMaterial() != nullptr) {
-    mState.volumeMaterial[tVolume.geometryId()] =
-        tVolume.volumeMaterialSharedPtr();
+    mState.volumeMaterial[tVolume.geometryId()] = tVolume.volumeMaterialPtr();
   }
 
   // Step down into the sub volume
diff --git a/Core/src/Surfaces/CylinderSurface.cpp b/Core/src/Surfaces/CylinderSurface.cpp
index b53e6bf1b7d..08c614d9879 100644
--- a/Core/src/Surfaces/CylinderSurface.cpp
+++ b/Core/src/Surfaces/CylinderSurface.cpp
@@ -374,8 +374,8 @@ Acts::CylinderSurface::mergedWith(const CylinderSurface& other,
                                   const Logger& logger) const {
   using namespace Acts::UnitLiterals;
 
-  ACTS_DEBUG("Merging cylinder surfaces in " << binningValueName(direction)
-                                             << " direction");
+  ACTS_VERBOSE("Merging cylinder surfaces in " << binningValueName(direction)
+                                               << " direction");
 
   if (m_associatedDetElement != nullptr ||
       other.m_associatedDetElement != nullptr) {
diff --git a/Core/src/Surfaces/DiscSurface.cpp b/Core/src/Surfaces/DiscSurface.cpp
index 140047a5785..f75b5ce463b 100644
--- a/Core/src/Surfaces/DiscSurface.cpp
+++ b/Core/src/Surfaces/DiscSurface.cpp
@@ -385,7 +385,7 @@ Acts::DiscSurface::mergedWith(const DiscSurface& other, BinningValue direction,
                               const Logger& logger) const {
   using namespace Acts::UnitLiterals;
 
-  ACTS_DEBUG("Merging disc surfaces in " << direction << " direction");
+  ACTS_VERBOSE("Merging disc surfaces in " << direction << " direction");
 
   if (m_associatedDetElement != nullptr ||
       other.m_associatedDetElement != nullptr) {
diff --git a/Core/src/Surfaces/Surface.cpp b/Core/src/Surfaces/Surface.cpp
index d6442dbaf49..8cb1c8a7b19 100644
--- a/Core/src/Surfaces/Surface.cpp
+++ b/Core/src/Surfaces/Surface.cpp
@@ -13,6 +13,7 @@
 #include "Acts/Surfaces/detail/AlignmentHelper.hpp"
 #include "Acts/Utilities/JacobianHelpers.hpp"
 #include "Acts/Utilities/VectorHelpers.hpp"
+#include "Acts/Visualization/ViewConfig.hpp"
 
 #include <iomanip>
 #include <utility>
@@ -358,3 +359,10 @@ void Acts::Surface::assignSurfaceMaterial(
 void Acts::Surface::associateLayer(const Acts::Layer& lay) {
   m_associatedLayer = (&lay);
 }
+
+void Acts::Surface::visualize(IVisualization3D& helper,
+                              const GeometryContext& gctx,
+                              const ViewConfig& viewConfig) const {
+  Polyhedron polyhedron = polyhedronRepresentation(gctx, viewConfig.nSegments);
+  polyhedron.visualize(helper, viewConfig);
+}
diff --git a/Core/src/Surfaces/VerticesHelper.cpp b/Core/src/Surfaces/VerticesHelper.cpp
index a0367936dc9..580bb4cbd0c 100644
--- a/Core/src/Surfaces/VerticesHelper.cpp
+++ b/Core/src/Surfaces/VerticesHelper.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2020-2024 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
@@ -8,6 +8,7 @@
 
 #include "Acts/Surfaces/detail/VerticesHelper.hpp"
 
+#include <algorithm>
 #include <cmath>
 #include <cstddef>
 
@@ -42,7 +43,7 @@ std::vector<Acts::ActsScalar> Acts::detail::VerticesHelper::phiSegments(
         phiSegments.push_back(phiRef);
       }
     }
-    std::sort(phiSegments.begin(), phiSegments.end());
+    std::ranges::sort(phiSegments);
   }
   return phiSegments;
 }
diff --git a/Core/src/TrackFitting/GsfMixtureReduction.cpp b/Core/src/TrackFitting/GsfMixtureReduction.cpp
index 6008ad66a81..d0d5b2dfd79 100644
--- a/Core/src/TrackFitting/GsfMixtureReduction.cpp
+++ b/Core/src/TrackFitting/GsfMixtureReduction.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -10,6 +10,8 @@
 
 #include "Acts/TrackFitting/detail/SymmetricKlDistanceMatrix.hpp"
 
+#include <algorithm>
+
 template <typename proj_t, typename angle_desc_t>
 void reduceWithKLDistanceImpl(std::vector<Acts::GsfComponent> &cmpCache,
                               std::size_t maxCmpsAfterMerge, const proj_t &proj,
@@ -35,10 +37,8 @@ void reduceWithKLDistanceImpl(std::vector<Acts::GsfComponent> &cmpCache,
   }
 
   // Remove all components which are labeled with weight -1
-  std::sort(cmpCache.begin(), cmpCache.end(),
-            [&](const auto &a, const auto &b) {
-              return proj(a).weight < proj(b).weight;
-            });
+  std::ranges::sort(cmpCache, {},
+                    [&](const auto &c) { return proj(c).weight; });
   cmpCache.erase(
       std::remove_if(cmpCache.begin(), cmpCache.end(),
                      [&](const auto &a) { return proj(a).weight == -1.0; }),
diff --git a/Core/src/TrackFitting/MbfSmoother.cpp b/Core/src/TrackFitting/MbfSmoother.cpp
index fe668eb41d8..53e29d19598 100644
--- a/Core/src/TrackFitting/MbfSmoother.cpp
+++ b/Core/src/TrackFitting/MbfSmoother.cpp
@@ -11,68 +11,72 @@
 namespace Acts {
 
 void MbfSmoother::calculateSmoothed(InternalTrackState& ts,
-                                    const BoundMatrix& big_lambda_hat,
-                                    const BoundVector& small_lambda_hat) const {
+                                    const BoundMatrix& bigLambdaHat,
+                                    const BoundVector& smallLambdaHat) const {
   ts.smoothedCovariance = ts.filteredCovariance - ts.filteredCovariance *
-                                                      big_lambda_hat *
+                                                      bigLambdaHat *
                                                       ts.filteredCovariance;
-  ts.smoothed = ts.filtered - ts.filteredCovariance * small_lambda_hat;
+  ts.smoothed = ts.filtered - ts.filteredCovariance * smallLambdaHat;
 }
 
 void MbfSmoother::visitNonMeasurement(const InternalTrackState& ts,
-                                      BoundMatrix& big_lambda_hat,
-                                      BoundVector& small_lambda_hat) const {
-  const auto F = ts.jacobian;
+                                      BoundMatrix& bigLambdaHat,
+                                      BoundVector& smallLambdaHat) const {
+  const InternalTrackState::Jacobian F = ts.jacobian;
 
-  big_lambda_hat = F.transpose() * big_lambda_hat * F;
-  small_lambda_hat = F.transpose() * small_lambda_hat;
+  bigLambdaHat = F.transpose() * bigLambdaHat * F;
+  smallLambdaHat = F.transpose() * smallLambdaHat;
 }
 
 void MbfSmoother::visitMeasurement(const InternalTrackState& ts,
-                                   BoundMatrix& big_lambda_hat,
-                                   BoundVector& small_lambda_hat) const {
+                                   BoundMatrix& bigLambdaHat,
+                                   BoundVector& smallLambdaHat) const {
   assert(ts.measurement.has_value());
 
-  const auto& measurement = ts.measurement.value();
+  const InternalTrackState::Measurement& measurement = ts.measurement.value();
+  const InternalTrackState::Jacobian F = ts.jacobian;
 
   visit_measurement(measurement.calibratedSize, [&](auto N) -> void {
     constexpr std::size_t kMeasurementSize = decltype(N)::value;
 
+    using MeasurementMatrix =
+        Eigen::Matrix<ActsScalar, kMeasurementSize, eBoundSize>;
+    using CovarianceMatrix =
+        Eigen::Matrix<ActsScalar, kMeasurementSize, kMeasurementSize>;
+    using KalmanGainMatrix =
+        Eigen::Matrix<ActsScalar, eBoundSize, kMeasurementSize>;
+
     typename TrackStateTraits<kMeasurementSize, true>::Calibrated calibrated{
         measurement.calibrated};
     typename TrackStateTraits<kMeasurementSize, true>::CalibratedCovariance
         calibratedCovariance{measurement.calibratedCovariance};
 
     // Measurement matrix
-    const auto H = measurement.projector
-                       .template topLeftCorner<kMeasurementSize, eBoundSize>()
-                       .eval();
+    const MeasurementMatrix H =
+        measurement.projector
+            .template topLeftCorner<kMeasurementSize, eBoundSize>();
 
     // Residual covariance
-    const auto S =
-        (H * ts.predictedCovariance * H.transpose() + calibratedCovariance)
-            .eval();
+    const CovarianceMatrix S =
+        (H * ts.predictedCovariance * H.transpose() + calibratedCovariance);
     // TODO Sinv could be cached by the filter step
-    const auto S_inv = S.inverse().eval();
+    const CovarianceMatrix SInv = S.inverse();
 
     // Kalman gain
     // TODO K could be cached by the filter step
-    const auto K = (ts.predictedCovariance * H.transpose() * S_inv).eval();
-
-    const auto C_hat = (BoundMatrix::Identity() - K * H).eval();
-    const auto y = (calibrated - H * ts.predicted).eval();
+    const KalmanGainMatrix K = (ts.predictedCovariance * H.transpose() * SInv);
 
-    const auto big_lambda_tilde =
-        (H.transpose() * S_inv * H + C_hat.transpose() * big_lambda_hat * C_hat)
-            .eval();
-    const auto small_lambda_tilde =
-        (-H.transpose() * S_inv * y + C_hat.transpose() * small_lambda_hat)
-            .eval();
+    const Acts::BoundMatrix CHat = (Acts::BoundMatrix::Identity() - K * H);
+    const Eigen::Matrix<ActsScalar, kMeasurementSize, 1> y =
+        (calibrated - H * ts.predicted);
 
-    const auto F = ts.jacobian;
+    const Acts::BoundMatrix bigLambdaTilde =
+        (H.transpose() * SInv * H + CHat.transpose() * bigLambdaHat * CHat);
+    const Eigen::Matrix<ActsScalar, eBoundSize, 1> smallLambdaTilde =
+        (-H.transpose() * SInv * y + CHat.transpose() * smallLambdaHat);
 
-    big_lambda_hat = F.transpose() * big_lambda_tilde * F;
-    small_lambda_hat = F.transpose() * small_lambda_tilde;
+    bigLambdaHat = F.transpose() * bigLambdaTilde * F;
+    smallLambdaHat = F.transpose() * smallLambdaTilde;
   });
 }
 
diff --git a/Core/src/Utilities/CMakeLists.txt b/Core/src/Utilities/CMakeLists.txt
index be3a4f83dfe..6c5553387a0 100644
--- a/Core/src/Utilities/CMakeLists.txt
+++ b/Core/src/Utilities/CMakeLists.txt
@@ -8,4 +8,5 @@ target_sources(
         TrackHelpers.cpp
         BinningType.cpp
         Intersection.cpp
+        GraphViz.cpp
 )
diff --git a/Core/src/Utilities/GraphViz.cpp b/Core/src/Utilities/GraphViz.cpp
new file mode 100644
index 00000000000..f38de83beca
--- /dev/null
+++ b/Core/src/Utilities/GraphViz.cpp
@@ -0,0 +1,286 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 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 http://mozilla.org/MPL/2.0/.
+
+#include "Acts/Utilities/GraphViz.hpp"
+
+#include <algorithm>
+#include <sstream>
+#include <string>
+
+#include <boost/algorithm/string/join.hpp>
+
+namespace Acts::GraphViz {
+
+std::ostream& operator<<(std::ostream& os, const Shape& shape) {
+  switch (shape) {
+    using enum Shape;
+
+    case Box:
+      os << "box";
+      break;
+    case Polygon:
+      os << "polygon";
+      break;
+    case Ellipse:
+      os << "ellipse";
+      break;
+    case Oval:
+      os << "oval";
+      break;
+    case Circle:
+      os << "circle";
+      break;
+    case Point:
+      os << "point";
+      break;
+    case Egg:
+      os << "egg";
+      break;
+    case Triangle:
+      os << "triangle";
+      break;
+    case Plaintext:
+      os << "plaintext";
+      break;
+    case Plain:
+      os << "plain";
+      break;
+    case Diamond:
+      os << "diamond";
+      break;
+    case Trapezium:
+      os << "trapezium";
+      break;
+    case Parallelogram:
+      os << "parallelogram";
+      break;
+    case House:
+      os << "house";
+      break;
+    case Pentagon:
+      os << "pentagon";
+      break;
+    case Hexagon:
+      os << "hexagon";
+      break;
+    case Septagon:
+      os << "septagon";
+      break;
+    case Octagon:
+      os << "octagon";
+      break;
+    case DoubleCircle:
+      os << "doublecircle";
+      break;
+    case DoubleOctagon:
+      os << "doubleoctagon";
+      break;
+    case TripleOctagon:
+      os << "tripleoctagon";
+      break;
+    case InvTriangle:
+      os << "invtriangle";
+      break;
+    case InvTrapezium:
+      os << "invtrapezium";
+      break;
+    case InvHouse:
+      os << "invhouse";
+      break;
+    case Mdiamond:
+      os << "Mdiamond";
+      break;
+    case Msquare:
+      os << "Msquare";
+      break;
+    case Mcircle:
+      os << "Mcircle";
+      break;
+    case Rect:
+      os << "rect";
+      break;
+    case Rectangle:
+      os << "rectangle";
+      break;
+    case Square:
+      os << "square";
+      break;
+    case Star:
+      os << "star";
+      break;
+    case None:
+      os << "none";
+      break;
+    case Underline:
+      os << "underline";
+      break;
+    case Cylinder:
+      os << "cylinder";
+      break;
+    case Note:
+      os << "note";
+      break;
+    case Tab:
+      os << "tab";
+      break;
+    case Folder:
+      os << "folder";
+      break;
+    case Box3d:
+      os << "box3d";
+      break;
+    case Component:
+      os << "component";
+      break;
+    case Promoter:
+      os << "promoter";
+      break;
+    case Cds:
+      os << "cds";
+      break;
+    case Terminator:
+      os << "terminator";
+      break;
+    case Utr:
+      os << "utr";
+      break;
+    case PrimerSite:
+      os << "primersite";
+      break;
+    case RestrictionSite:
+      os << "restrictionsite";
+      break;
+    case FivePOverhang:
+      os << "fivepoverhang";
+      break;
+    case ThreePOverhang:
+      os << "threepoverhang";
+      break;
+    case NOverhang:
+      os << "noverhang";
+      break;
+    case Assembly:
+      os << "assembly";
+      break;
+    case Signature:
+      os << "signature";
+      break;
+    case Insulator:
+      os << "insulator";
+      break;
+    case Ribosite:
+      os << "ribosite";
+      break;
+    case RNAStab:
+      os << "rnastab";
+      break;
+    case ProteaseSite:
+      os << "proteasesite";
+      break;
+    case ProteinStab:
+      os << "proteinstab";
+      break;
+    case RPromoter:
+      os << "rpromoter";
+      break;
+    case RArrow:
+      os << "rarrow";
+      break;
+    case LArrow:
+      os << "larrow";
+      break;
+    case LPromoter:
+      os << "lpromoter";
+      break;
+    default:
+      std::terminate();
+  }
+
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const Style& style) {
+  switch (style) {
+    using enum Style;
+    case Filled:
+      os << "filled";
+      break;
+    case Invisible:
+      os << "invisible";
+      break;
+    case Diagonals:
+      os << "diagonals";
+      break;
+    case Rounded:
+      os << "rounded";
+      break;
+    case Dashed:
+      os << "dashed";
+      break;
+    case Dotted:
+      os << "dotted";
+      break;
+    case Solid:
+      os << "solid";
+      break;
+    case Bold:
+      os << "bold";
+      break;
+    default:
+      os << "unknown";
+      break;
+  }
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const Node& node) {
+  if (node.id.empty()) {
+    throw std::runtime_error("Node id must not be empty");
+  }
+
+  std::string id = node.id;
+  std::ranges::replace(id, ' ', '_');
+  os << id << " [";
+
+  std::vector<std::string> attributes;
+
+  std::vector<std::string> styles;
+  std::ranges::transform(node.style, std::back_inserter(styles),
+                         [](const Style& style) {
+                           std::stringstream ss;
+                           ss << style;
+                           return ss.str();
+                         });
+
+  if (!node.label.empty()) {
+    attributes.push_back("label=<" + node.label + ">");
+  }
+
+  std::stringstream ss;
+  ss << node.shape;
+  attributes.push_back("shape=" + ss.str());
+
+  attributes.push_back("style=" + boost::algorithm::join(styles, ","));
+
+  os << boost::algorithm::join(attributes, ", ");
+
+  os << "];\n";
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const Edge& node) {
+  os << node.from.id << " -> " << node.to.id << " [";
+
+  os << "style=" << node.style;
+
+  os << "];\n";
+
+  return os;
+}
+
+}  // namespace Acts::GraphViz
diff --git a/Core/src/Vertexing/AdaptiveMultiVertexFitter.cpp b/Core/src/Vertexing/AdaptiveMultiVertexFitter.cpp
index 6a6a879278a..cc70cee6b15 100644
--- a/Core/src/Vertexing/AdaptiveMultiVertexFitter.cpp
+++ b/Core/src/Vertexing/AdaptiveMultiVertexFitter.cpp
@@ -9,6 +9,7 @@
 #include "Acts/Vertexing/AdaptiveMultiVertexFitter.hpp"
 
 #include "Acts/Surfaces/PerigeeSurface.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Vertexing/KalmanVertexUpdater.hpp"
 #include "Acts/Vertexing/VertexingError.hpp"
 
@@ -189,7 +190,7 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter::addVtxToFit(
 
 bool Acts::AdaptiveMultiVertexFitter::isAlreadyInList(
     Vertex* vtx, const std::vector<Vertex*>& vertices) const {
-  return std::find(vertices.begin(), vertices.end(), vtx) != vertices.end();
+  return rangeContainsValue(vertices, vtx);
 }
 
 Acts::Result<void> Acts::AdaptiveMultiVertexFitter::prepareVertexForFit(
diff --git a/Core/src/Vertexing/FsmwMode1dFinder.cpp b/Core/src/Vertexing/FsmwMode1dFinder.cpp
index d17518be20b..8d075fe131b 100644
--- a/Core/src/Vertexing/FsmwMode1dFinder.cpp
+++ b/Core/src/Vertexing/FsmwMode1dFinder.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2019 CERN for the benefit of the Acts project
+// Copyright (C) 2019-2024 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
@@ -28,10 +28,7 @@ Acts::Result<double> Acts::FsmwMode1dFinder::getMode(
 
   // first of all order the vector according to the double value
 
-  std::sort(inputVector.begin(), inputVector.end(),
-            [](std::pair<double, double> a, std::pair<double, double> b) {
-              return a.first < b.first;
-            });
+  std::ranges::sort(inputVector, {}, [](const auto& i) { return i.first; });
 
   // begin to consider a certain number of elements according to the fraction
   auto begin = inputVector.begin();
diff --git a/Core/src/Visualization/GeometryView3D.cpp b/Core/src/Visualization/GeometryView3D.cpp
index 14923b66a50..f6ee3427e38 100644
--- a/Core/src/Visualization/GeometryView3D.cpp
+++ b/Core/src/Visualization/GeometryView3D.cpp
@@ -41,37 +41,25 @@
 #include <vector>
 
 namespace Acts::Experimental {
-ViewConfig s_viewSensitive = ViewConfig({0, 180, 240});
-ViewConfig s_viewPassive = ViewConfig({240, 280, 0});
-ViewConfig s_viewVolume = ViewConfig({220, 220, 0});
-ViewConfig s_viewGrid = ViewConfig({220, 0, 0});
-ViewConfig s_viewLine = ViewConfig({0, 0, 220});
+ViewConfig s_viewSensitive = {.color = {0, 180, 240}};
+ViewConfig s_viewPassive = {.color = {240, 280, 0}};
+ViewConfig s_viewVolume = {.color = {220, 220, 0}};
+ViewConfig s_viewGrid = {.color = {220, 0, 0}};
+ViewConfig s_viewLine = {.color = {0, 0, 220}};
 }  // namespace Acts::Experimental
 
 void Acts::GeometryView3D::drawPolyhedron(IVisualization3D& helper,
                                           const Polyhedron& polyhedron,
                                           const ViewConfig& viewConfig) {
-  if (viewConfig.visible) {
-    if (!viewConfig.triangulate) {
-      helper.faces(polyhedron.vertices, polyhedron.faces, viewConfig.color);
-    } else {
-      helper.faces(polyhedron.vertices, polyhedron.triangularMesh,
-                   viewConfig.color);
-    }
-  }
+  polyhedron.visualize(helper, viewConfig);
 }
 
 void Acts::GeometryView3D::drawSurface(IVisualization3D& helper,
                                        const Surface& surface,
                                        const GeometryContext& gctx,
-                                       const Transform3& transform,
+                                       const Transform3& /*transform*/,
                                        const ViewConfig& viewConfig) {
-  Polyhedron surfaceHedron =
-      surface.polyhedronRepresentation(gctx, viewConfig.nSegments);
-  if (!transform.isApprox(Transform3::Identity())) {
-    surfaceHedron.move(transform);
-  }
-  drawPolyhedron(helper, surfaceHedron, viewConfig);
+  surface.visualize(helper, gctx, viewConfig);
 }
 
 void Acts::GeometryView3D::drawSurfaceArray(
@@ -163,12 +151,9 @@ void Acts::GeometryView3D::drawSurfaceArray(
 void Acts::GeometryView3D::drawVolume(IVisualization3D& helper,
                                       const Volume& volume,
                                       const GeometryContext& gctx,
-                                      const Transform3& transform,
+                                      const Transform3& /*transform*/,
                                       const ViewConfig& viewConfig) {
-  auto bSurfaces = volume.volumeBounds().orientedSurfaces(volume.transform());
-  for (const auto& bs : bSurfaces) {
-    drawSurface(helper, *bs.surface, gctx, transform, viewConfig);
-  }
+  volume.visualize(helper, gctx, viewConfig);
 }
 
 void Acts::GeometryView3D::drawPortal(IVisualization3D& helper,
diff --git a/Examples/Algorithms/Digitization/include/ActsExamples/Digitization/DigitizationAlgorithm.hpp b/Examples/Algorithms/Digitization/include/ActsExamples/Digitization/DigitizationAlgorithm.hpp
index 9fafaf0af21..1c8a0c8e322 100644
--- a/Examples/Algorithms/Digitization/include/ActsExamples/Digitization/DigitizationAlgorithm.hpp
+++ b/Examples/Algorithms/Digitization/include/ActsExamples/Digitization/DigitizationAlgorithm.hpp
@@ -96,6 +96,9 @@ class DigitizationAlgorithm final : public IAlgorithm {
   /// Geometric digtizer
   ActsFatras::Channelizer m_channelizer;
 
+  using CellsMap =
+      std::map<Acts::GeometryIdentifier, std::vector<Cluster::Cell>>;
+
   ReadDataHandle<SimHitContainer> m_simContainerReadHandle{this,
                                                            "SimHitContainer"};
 
@@ -103,6 +106,7 @@ class DigitizationAlgorithm final : public IAlgorithm {
       this, "SourceLinks"};
   WriteDataHandle<MeasurementContainer> m_measurementWriteHandle{
       this, "Measurements"};
+  WriteDataHandle<CellsMap> m_cellsWriteHandle{this, "Cells"};
   WriteDataHandle<ClusterContainer> m_clusterWriteHandle{this, "Clusters"};
   WriteDataHandle<IndexMultimap<ActsFatras::Barcode>>
       m_measurementParticlesMapWriteHandle{this, "MeasurementParticlesMap"};
diff --git a/Examples/Algorithms/Digitization/include/ActsExamples/Digitization/DigitizationConfig.hpp b/Examples/Algorithms/Digitization/include/ActsExamples/Digitization/DigitizationConfig.hpp
index 5f1088d4c58..c49e62ae653 100644
--- a/Examples/Algorithms/Digitization/include/ActsExamples/Digitization/DigitizationConfig.hpp
+++ b/Examples/Algorithms/Digitization/include/ActsExamples/Digitization/DigitizationConfig.hpp
@@ -139,6 +139,8 @@ class DigitizationConfig {
   std::string outputSourceLinks = "sourcelinks";
   /// Output measurements collection.
   std::string outputMeasurements = "measurements";
+  /// Output cells map (geoID -> collection of cells).
+  std::string outputCells = "cells";
   /// Output cluster collection.
   std::string outputClusters = "clusters";
   /// Output collection to map measured hits to contributing particles.
@@ -150,6 +152,12 @@ class DigitizationConfig {
       surfaceByIdentifier;
   /// Random numbers tool.
   std::shared_ptr<const RandomNumbers> randomNumbers = nullptr;
+  /// Flag to determine whether cell data should be written to the
+  /// `outputCells` collection; if true, writes (rather voluminous) cell data.
+  bool doOutputCells = false;
+  /// Flag to determine whether or not to run the clusterization; if true,
+  /// clusters, measurements, and sim-hit-maps are output.
+  bool doClusterization = true;
   /// Do we merge hits or not
   bool doMerge;
   /// How close do parameters have to be to consider merged
diff --git a/Examples/Algorithms/Digitization/src/DigitizationAlgorithm.cpp b/Examples/Algorithms/Digitization/src/DigitizationAlgorithm.cpp
index 3ac84f45bac..40b9120a9c4 100644
--- a/Examples/Algorithms/Digitization/src/DigitizationAlgorithm.cpp
+++ b/Examples/Algorithms/Digitization/src/DigitizationAlgorithm.cpp
@@ -44,39 +44,53 @@ ActsExamples::DigitizationAlgorithm::DigitizationAlgorithm(
   if (m_cfg.inputSimHits.empty()) {
     throw std::invalid_argument("Missing simulated hits input collection");
   }
-  if (m_cfg.outputMeasurements.empty()) {
-    throw std::invalid_argument("Missing measurements output collection");
-  }
-  if (m_cfg.outputSourceLinks.empty()) {
-    throw std::invalid_argument("Missing source links output collection");
-  }
-  if (m_cfg.outputMeasurementParticlesMap.empty()) {
-    throw std::invalid_argument(
-        "Missing hit-to-particles map output collection");
-  }
-  if (m_cfg.outputMeasurementSimHitsMap.empty()) {
-    throw std::invalid_argument(
-        "Missing hit-to-simulated-hits map output collection");
-  }
   if (m_cfg.surfaceByIdentifier.empty()) {
     throw std::invalid_argument("Missing Surface-GeometryID association map");
   }
   if (!m_cfg.randomNumbers) {
     throw std::invalid_argument("Missing random numbers tool");
   }
-
   if (m_cfg.digitizationConfigs.empty()) {
     throw std::invalid_argument("Missing digitization configuration");
   }
 
+  if (m_cfg.doClusterization) {
+    if (m_cfg.outputSourceLinks.empty()) {
+      throw std::invalid_argument("Missing source links output collection");
+    }
+    if (m_cfg.outputMeasurements.empty()) {
+      throw std::invalid_argument("Missing measurements output collection");
+    }
+    if (m_cfg.outputClusters.empty()) {
+      throw std::invalid_argument("Missing cluster output collection");
+    }
+    if (m_cfg.outputMeasurementParticlesMap.empty()) {
+      throw std::invalid_argument(
+          "Missing hit-to-particles map output collection");
+    }
+    if (m_cfg.outputMeasurementSimHitsMap.empty()) {
+      throw std::invalid_argument(
+          "Missing hit-to-simulated-hits map output collection");
+    }
+
+    m_sourceLinkWriteHandle.initialize(m_cfg.outputSourceLinks);
+    m_measurementWriteHandle.initialize(m_cfg.outputMeasurements);
+    m_clusterWriteHandle.initialize(m_cfg.outputClusters);
+    m_measurementParticlesMapWriteHandle.initialize(
+        m_cfg.outputMeasurementParticlesMap);
+    m_measurementSimHitsMapWriteHandle.initialize(
+        m_cfg.outputMeasurementSimHitsMap);
+  }
+
+  if (m_cfg.doOutputCells) {
+    if (m_cfg.outputCells.empty()) {
+      throw std::invalid_argument("Missing cell output collection");
+    }
+
+    m_cellsWriteHandle.initialize(m_cfg.outputCells);
+  }
+
   m_simContainerReadHandle.initialize(m_cfg.inputSimHits);
-  m_sourceLinkWriteHandle.initialize(m_cfg.outputSourceLinks);
-  m_measurementWriteHandle.initialize(m_cfg.outputMeasurements);
-  m_clusterWriteHandle.initialize(m_cfg.outputClusters);
-  m_measurementParticlesMapWriteHandle.initialize(
-      m_cfg.outputMeasurementParticlesMap);
-  m_measurementSimHitsMapWriteHandle.initialize(
-      m_cfg.outputMeasurementSimHitsMap);
 
   // Create the digitizers from the configuration
   std::vector<std::pair<Acts::GeometryIdentifier, Digitizer>> digitizerInput;
@@ -98,7 +112,7 @@ ActsExamples::DigitizationAlgorithm::DigitizationAlgorithm(
                    geoCfg.indices.end());
 
     // Make sure the configured input parameter indices are sorted and unique
-    std::sort(indices.begin(), indices.end());
+    std::ranges::sort(indices);
 
     auto dup = std::adjacent_find(indices.begin(), indices.end());
     if (dup != indices.end()) {
@@ -154,6 +168,10 @@ ActsExamples::ProcessCode ActsExamples::DigitizationAlgorithm::execute(
   // Some statistics
   std::size_t skippedHits = 0;
 
+  // Some algorithms do the clusterization themselves such as the traccc chain.
+  // Thus we need to store the cell data from the simulation.
+  CellsMap cellsMap;
+
   ACTS_DEBUG("Starting loop over modules ...");
   for (const auto& simHitsGroup : groupByModule(simHits)) {
     // Manual pair unpacking instead of using
@@ -255,29 +273,44 @@ ActsExamples::ProcessCode ActsExamples::DigitizationAlgorithm::execute(
             moduleClusters.add(std::move(dParameters), simHitIdx);
           }
 
-          for (auto& [dParameters, simhits] :
-               moduleClusters.digitizedParameters()) {
-            // The measurement container is unordered and the index under which
-            // the measurement will be stored is known before adding it.
-            Index measurementIdx = measurements.size();
-            IndexSourceLink sourceLink{moduleGeoId, measurementIdx};
-
-            // Add to output containers:
-            // index map and source link container are geometry-ordered.
-            // since the input is also geometry-ordered, new items can
-            // be added at the end.
-            sourceLinks.insert(sourceLinks.end(), sourceLink);
-
-            createMeasurement(measurements, dParameters, sourceLink);
-            clusters.emplace_back(std::move(dParameters.cluster));
-            // this digitization does hit merging so there can be more than one
-            // mapping entry for each digitized hit.
-            for (auto simHitIdx : simhits) {
-              measurementParticlesMap.emplace_hint(
-                  measurementParticlesMap.end(), measurementIdx,
-                  simHits.nth(simHitIdx)->particleId());
-              measurementSimHitsMap.emplace_hint(measurementSimHitsMap.end(),
-                                                 measurementIdx, simHitIdx);
+          auto digitizeParametersResult = moduleClusters.digitizedParameters();
+
+          // Store the cell data into a map.
+          if (m_cfg.doOutputCells) {
+            std::vector<Cluster::Cell> cells;
+            for (const auto& [dParameters, simhits] :
+                 digitizeParametersResult) {
+              for (const auto& cell : dParameters.cluster.channels) {
+                cells.push_back(cell);
+              }
+            }
+            cellsMap.insert({moduleGeoId, std::move(cells)});
+          }
+
+          if (m_cfg.doClusterization) {
+            for (auto& [dParameters, simhits] : digitizeParametersResult) {
+              // The measurement container is unordered and the index under
+              // which the measurement will be stored is known before adding it.
+              Index measurementIdx = measurements.size();
+              IndexSourceLink sourceLink{moduleGeoId, measurementIdx};
+
+              // Add to output containers:
+              // index map and source link container are geometry-ordered.
+              // since the input is also geometry-ordered, new items can
+              // be added at the end.
+              sourceLinks.insert(sourceLinks.end(), sourceLink);
+
+              createMeasurement(measurements, dParameters, sourceLink);
+              clusters.emplace_back(std::move(dParameters.cluster));
+              // this digitization does hit merging so there can be more than
+              // one mapping entry for each digitized hit.
+              for (auto simHitIdx : simhits) {
+                measurementParticlesMap.emplace_hint(
+                    measurementParticlesMap.end(), measurementIdx,
+                    simHits.nth(simHitIdx)->particleId());
+                measurementSimHitsMap.emplace_hint(measurementSimHitsMap.end(),
+                                                   measurementIdx, simHitIdx);
+              }
             }
           }
         },
@@ -290,11 +323,19 @@ ActsExamples::ProcessCode ActsExamples::DigitizationAlgorithm::execute(
         << " skipped in Digitization. Enable DEBUG mode to see more details.");
   }
 
-  m_sourceLinkWriteHandle(ctx, std::move(sourceLinks));
-  m_measurementWriteHandle(ctx, std::move(measurements));
-  m_clusterWriteHandle(ctx, std::move(clusters));
-  m_measurementParticlesMapWriteHandle(ctx, std::move(measurementParticlesMap));
-  m_measurementSimHitsMapWriteHandle(ctx, std::move(measurementSimHitsMap));
+  if (m_cfg.doOutputCells) {
+    m_cellsWriteHandle(ctx, std::move(cellsMap));
+  }
+
+  if (m_cfg.doClusterization) {
+    m_sourceLinkWriteHandle(ctx, std::move(sourceLinks));
+    m_measurementWriteHandle(ctx, std::move(measurements));
+    m_clusterWriteHandle(ctx, std::move(clusters));
+    m_measurementParticlesMapWriteHandle(ctx,
+                                         std::move(measurementParticlesMap));
+    m_measurementSimHitsMapWriteHandle(ctx, std::move(measurementSimHitsMap));
+  }
+
   return ProcessCode::SUCCESS;
 }
 
diff --git a/Examples/Algorithms/Digitization/src/ModuleClusters.cpp b/Examples/Algorithms/Digitization/src/ModuleClusters.cpp
index f82ec7063c4..b5e7ab8e462 100644
--- a/Examples/Algorithms/Digitization/src/ModuleClusters.cpp
+++ b/Examples/Algorithms/Digitization/src/ModuleClusters.cpp
@@ -9,6 +9,7 @@
 #include "ActsExamples/Digitization/ModuleClusters.hpp"
 
 #include "Acts/Clusterization/Clusterization.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "ActsExamples/Digitization/MeasurementCreation.hpp"
 #include "ActsFatras/Digitization/Channelizer.hpp"
 
@@ -139,8 +140,7 @@ std::vector<std::size_t> ModuleClusters::nonGeoEntries(
   std::vector<std::size_t> retv;
   for (std::size_t i = 0; i < indices.size(); i++) {
     auto idx = indices.at(i);
-    if (std::find(m_geoIndices.begin(), m_geoIndices.end(), idx) ==
-        m_geoIndices.end()) {
+    if (!rangeContainsValue(m_geoIndices, idx)) {
       retv.push_back(i);
     }
   }
@@ -245,10 +245,8 @@ ModuleValue ModuleClusters::squash(std::vector<ModuleValue>& values) {
     ModuleValue& other = values.at(i);
     for (std::size_t j = 0; j < other.paramIndices.size(); j++) {
       auto idx = other.paramIndices.at(j);
-      if (std::find(m_geoIndices.begin(), m_geoIndices.end(), idx) ==
-          m_geoIndices.end()) {
-        if (std::find(mval.paramIndices.begin(), mval.paramIndices.end(),
-                      idx) == mval.paramIndices.end()) {
+      if (!rangeContainsValue(m_geoIndices, idx)) {
+        if (!rangeContainsValue(mval.paramIndices, idx)) {
           mval.paramIndices.push_back(idx);
         }
         if (mval.paramValues.size() < (j + 1)) {
diff --git a/Examples/Algorithms/Geant4/src/SensitiveSurfaceMapper.cpp b/Examples/Algorithms/Geant4/src/SensitiveSurfaceMapper.cpp
index 341e0531b07..58cd3e6ba3c 100644
--- a/Examples/Algorithms/Geant4/src/SensitiveSurfaceMapper.cpp
+++ b/Examples/Algorithms/Geant4/src/SensitiveSurfaceMapper.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2021 CERN for the benefit of the Acts project
+// Copyright (C) 2021-2024 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
@@ -11,6 +11,7 @@
 #include "Acts/Definitions/Units.hpp"
 #include "Acts/Surfaces/AnnulusBounds.hpp"
 #include "Acts/Surfaces/ConvexPolygonBounds.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Visualization/GeometryView3D.hpp"
 #include "Acts/Visualization/ObjVisualization3D.hpp"
 
@@ -65,7 +66,7 @@ namespace {
 void writeG4Polyhedron(
     Acts::IVisualization3D& visualizer, const G4Polyhedron& polyhedron,
     const Acts::Transform3& trafo = Acts::Transform3::Identity(),
-    Acts::ColorRGB color = {0, 0, 0}) {
+    Acts::Color color = {0, 0, 0}) {
   constexpr double convertLength = CLHEP::mm / Acts::UnitConstants::mm;
 
   for (int i = 1; i <= polyhedron.GetNoFacets(); ++i) {
@@ -185,13 +186,11 @@ void ActsExamples::SensitiveSurfaceMapper::remapSensitiveNames(
   std::string volumeName = g4LogicalVolume->GetName();
   std::string volumeMaterialName = g4LogicalVolume->GetMaterial()->GetName();
 
-  bool isSensitive = g4SensitiveDetector != nullptr;
-  bool isMappedMaterial =
-      std::find(m_cfg.materialMappings.begin(), m_cfg.materialMappings.end(),
-                volumeMaterialName) != m_cfg.materialMappings.end();
-  bool isMappedVolume =
-      std::find(m_cfg.volumeMappings.begin(), m_cfg.volumeMappings.end(),
-                volumeName) != m_cfg.volumeMappings.end();
+  const bool isSensitive = g4SensitiveDetector != nullptr;
+  const bool isMappedMaterial =
+      Acts::rangeContainsValue(m_cfg.materialMappings, volumeMaterialName);
+  const bool isMappedVolume =
+      Acts::rangeContainsValue(m_cfg.volumeMappings, volumeName);
 
   if (!(isSensitive || isMappedMaterial || isMappedVolume)) {
     ACTS_VERBOSE("Did not try mapping '"
@@ -296,13 +295,13 @@ bool ActsExamples::SensitiveSurfaceMapper::checkMapping(
     const State& state, const Acts::GeometryContext& gctx,
     bool writeMissingG4VolsAsObj, bool writeMissingSurfacesAsObj) const {
   auto allSurfaces = m_cfg.candidateSurfaces->queryAll();
-  std::sort(allSurfaces.begin(), allSurfaces.end());
+  std::ranges::sort(allSurfaces);
 
   std::vector<const Acts::Surface*> found;
   for (const auto [_, surfacePtr] : state.g4VolumeToSurfaces) {
     found.push_back(surfacePtr);
   }
-  std::sort(found.begin(), found.end());
+  std::ranges::sort(found);
   auto newEnd = std::unique(found.begin(), found.end());
   found.erase(newEnd, found.end());
 
diff --git a/Examples/Algorithms/Geant4HepMC/src/EventAction.cpp b/Examples/Algorithms/Geant4HepMC/src/EventAction.cpp
index b9e5b07c22f..eb5de237061 100644
--- a/Examples/Algorithms/Geant4HepMC/src/EventAction.cpp
+++ b/Examples/Algorithms/Geant4HepMC/src/EventAction.cpp
@@ -8,6 +8,8 @@
 
 #include "EventAction.hpp"
 
+#include "Acts/Utilities/Helpers.hpp"
+
 #include <stdexcept>
 
 #include <G4Event.hh>
@@ -32,8 +34,7 @@ bool findAttribute(const HepMC3::ConstGenVertexPtr& vertex,
     const std::vector<std::string> vertexAttributes = vertex->attribute_names();
     for (const auto& att : vertexAttributes) {
       const std::string process = vertex->attribute_as_string(att);
-      if (std::find(processFilter.begin(), processFilter.end(), process) !=
-          processFilter.end()) {
+      if (Acts::rangeContainsValue(processFilter, process)) {
         return true;
       }
     }
diff --git a/Examples/Algorithms/Geant4HepMC/src/SteppingAction.cpp b/Examples/Algorithms/Geant4HepMC/src/SteppingAction.cpp
index ad9b91ac7b4..8852349dc60 100644
--- a/Examples/Algorithms/Geant4HepMC/src/SteppingAction.cpp
+++ b/Examples/Algorithms/Geant4HepMC/src/SteppingAction.cpp
@@ -8,6 +8,8 @@
 
 #include "SteppingAction.hpp"
 
+#include "Acts/Utilities/Helpers.hpp"
+
 #include <stdexcept>
 
 #include <G4RunManager.hh>
@@ -43,10 +45,10 @@ SteppingAction::~SteppingAction() {
 
 void SteppingAction::UserSteppingAction(const G4Step* step) {
   // Test if the event should be aborted
-  if (std::find(m_eventRejectionProcess.begin(), m_eventRejectionProcess.end(),
-                step->GetPostStepPoint()
-                    ->GetProcessDefinedStep()
-                    ->GetProcessName()) != m_eventRejectionProcess.end()) {
+  if (Acts::rangeContainsValue(m_eventRejectionProcess,
+                               step->GetPostStepPoint()
+                                   ->GetProcessDefinedStep()
+                                   ->GetProcessName())) {
     m_eventAborted = true;
     G4RunManager::GetRunManager()->AbortEvent();
     return;
diff --git a/Examples/Algorithms/HepMC/src/HepMCProcessExtractor.cpp b/Examples/Algorithms/HepMC/src/HepMCProcessExtractor.cpp
index 5dfbdcbcf73..9faa55eecc6 100644
--- a/Examples/Algorithms/HepMC/src/HepMCProcessExtractor.cpp
+++ b/Examples/Algorithms/HepMC/src/HepMCProcessExtractor.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2020-2024 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
@@ -11,6 +11,7 @@
 #include "ActsExamples/Framework/WhiteBoard.hpp"
 #include "ActsExamples/Io/HepMC3/HepMC3Particle.hpp"
 
+#include <algorithm>
 #include <stdexcept>
 
 #include <HepMC3/GenEvent.h>
@@ -167,10 +168,8 @@ void filterAndSort(
 
   // Sort the particles based on their momentum
   for (auto& interaction : interactions) {
-    std::sort(interaction.after.begin(), interaction.after.end(),
-              [](ActsExamples::SimParticle& a, ActsExamples::SimParticle& b) {
-                return a.absoluteMomentum() > b.absoluteMomentum();
-              });
+    std::ranges::sort(interaction.after, std::greater{},
+                      [](const auto& a) { return a.absoluteMomentum(); });
   }
 }
 }  // namespace
diff --git a/Examples/Algorithms/MaterialMapping/include/ActsExamples/MaterialMapping/MappingMaterialDecorator.hpp b/Examples/Algorithms/MaterialMapping/include/ActsExamples/MaterialMapping/MappingMaterialDecorator.hpp
index 2231e8c7e6b..7a260c5c8ef 100644
--- a/Examples/Algorithms/MaterialMapping/include/ActsExamples/MaterialMapping/MappingMaterialDecorator.hpp
+++ b/Examples/Algorithms/MaterialMapping/include/ActsExamples/MaterialMapping/MappingMaterialDecorator.hpp
@@ -106,7 +106,7 @@ class MappingMaterialDecorator : public IMaterialDecorator {
     }
     if (tVolume->volumeMaterial() != nullptr) {
       m_volumeMaterialMap.insert(
-          {tVolume->geometryId(), tVolume->volumeMaterialSharedPtr()});
+          {tVolume->geometryId(), tVolume->volumeMaterialPtr()});
     }
     // there are confined volumes
     if (tVolume->confinedVolumes() != nullptr) {
diff --git a/Examples/Algorithms/Traccc/include/ActsExamples/Traccc/DetrayPropagator.hpp b/Examples/Algorithms/Traccc/include/ActsExamples/Traccc/DetrayPropagator.hpp
index 8c42ecbeab0..8e7e415fa4e 100644
--- a/Examples/Algorithms/Traccc/include/ActsExamples/Traccc/DetrayPropagator.hpp
+++ b/Examples/Algorithms/Traccc/include/ActsExamples/Traccc/DetrayPropagator.hpp
@@ -17,7 +17,7 @@
 #include "ActsExamples/Traccc/DetrayStore.hpp"
 
 #include <detray/navigation/navigator.hpp>
-#include <detray/utils/inspectors.hpp>
+#include <detray/test/utils/inspectors.hpp>
 
 namespace ActsExamples {
 
diff --git a/Examples/Algorithms/TrackFinding/src/HoughTransformSeeder.cpp b/Examples/Algorithms/TrackFinding/src/HoughTransformSeeder.cpp
index 3c16d146d65..acd705d855a 100644
--- a/Examples/Algorithms/TrackFinding/src/HoughTransformSeeder.cpp
+++ b/Examples/Algorithms/TrackFinding/src/HoughTransformSeeder.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2020-2024 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
@@ -121,10 +121,11 @@ ActsExamples::HoughTransformSeeder::HoughTransformSeeder(
     // within the same volume hierarchy only consider layers
     return (ref.layer() == cmp.layer());
   };
+  // sort geometry selection so the unique filtering works
+  std::ranges::sort(m_cfg.geometrySelection,
+                    std::less<Acts::GeometryIdentifier>{});
   auto geoSelBeg = m_cfg.geometrySelection.begin();
   auto geoSelEnd = m_cfg.geometrySelection.end();
-  // sort geometry selection so the unique filtering works
-  std::sort(geoSelBeg, geoSelEnd);
   auto geoSelLastUnique = std::unique(geoSelBeg, geoSelEnd, isDuplicate);
   if (geoSelLastUnique != geoSelEnd) {
     ACTS_WARNING("Removed " << std::distance(geoSelLastUnique, geoSelEnd)
diff --git a/Examples/Algorithms/TrackFinding/src/SpacePointMaker.cpp b/Examples/Algorithms/TrackFinding/src/SpacePointMaker.cpp
index 0605e1b4bc4..99de1dfd646 100644
--- a/Examples/Algorithms/TrackFinding/src/SpacePointMaker.cpp
+++ b/Examples/Algorithms/TrackFinding/src/SpacePointMaker.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020-2022 CERN for the benefit of the Acts project
+// Copyright (C) 2020-2024 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
@@ -80,10 +80,11 @@ ActsExamples::SpacePointMaker::SpacePointMaker(Config cfg,
     // within the same volume hierarchy only consider layers
     return (ref.layer() == cmp.layer());
   };
+  // sort geometry selection so the unique filtering works
+  std::ranges::sort(m_cfg.geometrySelection,
+                    std::less<Acts::GeometryIdentifier>{});
   auto geoSelBeg = m_cfg.geometrySelection.begin();
   auto geoSelEnd = m_cfg.geometrySelection.end();
-  // sort geometry selection so the unique filtering works
-  std::sort(geoSelBeg, geoSelEnd);
   auto geoSelLastUnique = std::unique(geoSelBeg, geoSelEnd, isDuplicate);
   if (geoSelLastUnique != geoSelEnd) {
     ACTS_WARNING("Removed " << std::distance(geoSelLastUnique, geoSelEnd)
diff --git a/Examples/Algorithms/TrackFindingExaTrkX/src/PrototracksToParameters.cpp b/Examples/Algorithms/TrackFindingExaTrkX/src/PrototracksToParameters.cpp
index 83714f83f46..5904b2dddc7 100644
--- a/Examples/Algorithms/TrackFindingExaTrkX/src/PrototracksToParameters.cpp
+++ b/Examples/Algorithms/TrackFindingExaTrkX/src/PrototracksToParameters.cpp
@@ -22,6 +22,7 @@
 #include "ActsExamples/Utilities/EventDataTransforms.hpp"
 
 #include <algorithm>
+#include <tuple>
 
 using namespace ActsExamples;
 using namespace Acts::UnitLiterals;
@@ -96,11 +97,8 @@ ProcessCode PrototracksToParameters::execute(
     // layer-volume spacepoints has 3 or more hits. However, if this is the
     // case, we want to keep the whole prototrack. Therefore, we operate on a
     // tmpTrack.
-    std::sort(track.begin(), track.end(), [&](auto a, auto b) {
-      if (indexToGeoId[a].volume() != indexToGeoId[b].volume()) {
-        return indexToGeoId[a].volume() < indexToGeoId[b].volume();
-      }
-      return indexToGeoId[a].layer() < indexToGeoId[b].layer();
+    std::ranges::sort(track, {}, [&](const auto &t) {
+      return std::make_tuple(indexToGeoId[t].volume(), indexToGeoId[t].layer());
     });
 
     tmpTrack.clear();
@@ -134,8 +132,7 @@ ProcessCode PrototracksToParameters::execute(
       continue;
     }
 
-    std::sort(tmpSps.begin(), tmpSps.end(),
-              [](const auto &a, const auto &b) { return a->r() < b->r(); });
+    std::ranges::sort(tmpSps, {}, [](const auto &t) { return t->r(); });
 
     // Simply use r = m*z + t and solve for r=0 to find z vertex position...
     // Probably not the textbook way to do
diff --git a/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingAlgorithmExaTrkX.cpp b/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingAlgorithmExaTrkX.cpp
index 6bd254a0120..dbc123fc4d3 100644
--- a/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingAlgorithmExaTrkX.cpp
+++ b/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingAlgorithmExaTrkX.cpp
@@ -11,6 +11,7 @@
 #include "Acts/Definitions/Units.hpp"
 #include "Acts/Plugins/ExaTrkX/TorchGraphStoreHook.hpp"
 #include "Acts/Plugins/ExaTrkX/TorchTruthGraphMetricsHook.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Utilities/Zip.hpp"
 #include "ActsExamples/EventData/Index.hpp"
 #include "ActsExamples/EventData/IndexSourceLink.hpp"
@@ -97,10 +98,8 @@ ActsExamples::TrackFindingAlgorithmExaTrkX::TrackFindingAlgorithmExaTrkX(
       NodeFeature::eCellSum,  NodeFeature::eCluster1R, NodeFeature::eCluster2R};
 
   auto wantClFeatures = std::any_of(
-      m_cfg.nodeFeatures.begin(), m_cfg.nodeFeatures.end(), [&](const auto& f) {
-        return std::find(clFeatures.begin(), clFeatures.end(), f) !=
-               clFeatures.end();
-      });
+      m_cfg.nodeFeatures.begin(), m_cfg.nodeFeatures.end(),
+      [&](const auto& f) { return Acts::rangeContainsValue(clFeatures, f); });
 
   if (wantClFeatures && !m_inputClusters.isInitialized()) {
     throw std::invalid_argument("Cluster features requested, but not provided");
diff --git a/Examples/Algorithms/TrackFindingExaTrkX/src/TruthGraphBuilder.cpp b/Examples/Algorithms/TrackFindingExaTrkX/src/TruthGraphBuilder.cpp
index 4d8df390e50..489bf042ecd 100644
--- a/Examples/Algorithms/TrackFindingExaTrkX/src/TruthGraphBuilder.cpp
+++ b/Examples/Algorithms/TrackFindingExaTrkX/src/TruthGraphBuilder.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -9,6 +9,8 @@
 #include <Acts/Definitions/Units.hpp>
 #include <ActsExamples/TrackFindingExaTrkX/TruthGraphBuilder.hpp>
 
+#include <algorithm>
+
 using namespace Acts::UnitLiterals;
 
 namespace ActsExamples {
@@ -82,9 +84,8 @@ std::vector<std::int64_t> TruthGraphBuilder::buildFromMeasurements(
     };
 
     // Sort by radius (this breaks down if the particle has to low momentum)
-    std::sort(track.begin(), track.end(), [&](const auto& a, const auto& b) {
-      return radiusForOrdering(a) < radiusForOrdering(b);
-    });
+    std::ranges::sort(track, {},
+                      [&](const auto& t) { return radiusForOrdering(t); });
 
     if (m_cfg.uniqueModules) {
       auto newEnd = std::unique(
@@ -148,9 +149,7 @@ std::vector<std::int64_t> TruthGraphBuilder::buildFromSimhits(
 
   for (auto& [pid, track] : tracks) {
     // Sort by hit index, so the edges are connected correctly
-    std::sort(track.begin(), track.end(), [](const auto& a, const auto& b) {
-      return a.hitIndex < b.hitIndex;
-    });
+    std::ranges::sort(track, {}, [](const auto& t) { return t.hitIndex; });
 
     auto found = particles.find(pid);
     if (found == particles.end()) {
diff --git a/Examples/Algorithms/TrackFitting/src/RefittingAlgorithm.cpp b/Examples/Algorithms/TrackFitting/src/RefittingAlgorithm.cpp
index f3d0df6d1ad..ac1e41f005f 100644
--- a/Examples/Algorithms/TrackFitting/src/RefittingAlgorithm.cpp
+++ b/Examples/Algorithms/TrackFitting/src/RefittingAlgorithm.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -24,6 +24,7 @@
 #include "ActsExamples/TrackFitting/RefittingCalibrator.hpp"
 #include "ActsExamples/TrackFitting/TrackFitterFunction.hpp"
 
+#include <algorithm>
 #include <functional>
 #include <optional>
 #include <ostream>
@@ -96,13 +97,13 @@ ActsExamples::ProcessCode ActsExamples::RefittingAlgorithm::execute(
       trackSourceLinks.push_back(Acts::SourceLink{sl});
     }
 
-    std::reverse(surfSequence.begin(), surfSequence.end());
-
     if (surfSequence.empty()) {
       ACTS_WARNING("Empty track " << itrack << " found.");
       continue;
     }
 
+    std::ranges::reverse(surfSequence);
+
     ACTS_VERBOSE("Initial parameters: "
                  << initialParams.fourPosition(ctx.geoContext).transpose()
                  << " -> " << initialParams.direction().transpose());
diff --git a/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/TruthSeedingAlgorithm.cpp b/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/TruthSeedingAlgorithm.cpp
index 99e6c3ccb8e..5a79534d141 100644
--- a/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/TruthSeedingAlgorithm.cpp
+++ b/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/TruthSeedingAlgorithm.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2021 CERN for the benefit of the Acts project
+// Copyright (C) 2021-2024 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
@@ -151,11 +151,9 @@ ActsExamples::ProcessCode ActsExamples::TruthSeedingAlgorithm::execute(
       continue;
     }
     // Sort the space points
-    std::sort(spacePointsOnTrack.begin(), spacePointsOnTrack.end(),
-              [](const SimSpacePoint* lhs, const SimSpacePoint* rhs) {
-                return std::hypot(lhs->r(), lhs->z()) <
-                       std::hypot(rhs->r(), rhs->z());
-              });
+    std::ranges::sort(spacePointsOnTrack, {}, [](const SimSpacePoint* s) {
+      return std::hypot(s->r(), s->z());
+    });
 
     // Loop over the found space points to find the seed with maximum deltaR
     // between the bottom and top space point
diff --git a/Examples/Algorithms/Vertexing/src/AdaptiveMultiVertexFinderAlgorithm.cpp b/Examples/Algorithms/Vertexing/src/AdaptiveMultiVertexFinderAlgorithm.cpp
index 0844ed89f1d..c4a471669d6 100644
--- a/Examples/Algorithms/Vertexing/src/AdaptiveMultiVertexFinderAlgorithm.cpp
+++ b/Examples/Algorithms/Vertexing/src/AdaptiveMultiVertexFinderAlgorithm.cpp
@@ -31,6 +31,7 @@
 #include "ActsExamples/Framework/ProcessCode.hpp"
 #include "ActsExamples/TruthTracking/TruthVertexFinder.hpp"
 
+#include <algorithm>
 #include <memory>
 #include <optional>
 #include <ostream>
@@ -256,12 +257,10 @@ ProcessCode AdaptiveMultiVertexFinderAlgorithm::execute(
     }
 
     // sort by number of particles
-    std::sort(vertexSeederState.truthVertices.begin(),
-              vertexSeederState.truthVertices.end(),
-              [&vertexParticleCount](const auto& lhs, const auto& rhs) {
-                return vertexParticleCount[lhs.vertexId()] >
-                       vertexParticleCount[rhs.vertexId()];
-              });
+    std::ranges::sort(vertexSeederState.truthVertices, {},
+                      [&vertexParticleCount](const auto& v) {
+                        return vertexParticleCount[v.vertexId()];
+                      });
 
     ACTS_INFO("Got " << truthVertices.size() << " truth vertices and selected "
                      << vertexSeederState.truthVertices.size() << " in event");
diff --git a/Examples/Detectors/MuonSpectrometerMockupDetector/src/MockupSectorBuilder.cpp b/Examples/Detectors/MuonSpectrometerMockupDetector/src/MockupSectorBuilder.cpp
index b9b6e3ec3b1..7b3323fe7af 100644
--- a/Examples/Detectors/MuonSpectrometerMockupDetector/src/MockupSectorBuilder.cpp
+++ b/Examples/Detectors/MuonSpectrometerMockupDetector/src/MockupSectorBuilder.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022-2023 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -167,10 +167,8 @@ ActsExamples::MockupSectorBuilder::buildSector(
 
   // sort the detector volumes by their radial distance (from
   // innermost---->outermost)
-  std::sort(detVolumes.begin(), detVolumes.end(),
-            [](const auto& detVol1, const auto& detVol2) {
-              return detVol1->center().y() < detVol2->center().y();
-            });
+  std::ranges::sort(detVolumes, {},
+                    [](const auto& detVol) { return detVol->center().y(); });
 
   auto xA = detVolumes.back()->center().x() +
             detVolumes.back()->volumeBounds().values()[0];
diff --git a/Examples/Detectors/TelescopeDetector/src/TelescopeDetector.cpp b/Examples/Detectors/TelescopeDetector/src/TelescopeDetector.cpp
index 0d5c35800d5..47dcf82bbd9 100644
--- a/Examples/Detectors/TelescopeDetector/src/TelescopeDetector.cpp
+++ b/Examples/Detectors/TelescopeDetector/src/TelescopeDetector.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020-2021 CERN for the benefit of the Acts project
+// Copyright (C) 2020-2024 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
@@ -46,7 +46,7 @@ auto ActsExamples::Telescope::TelescopeDetector::finalize(
   // Sort the provided distances
   std::vector<double> positions = cfg.positions;
   std::vector<double> stereos = cfg.stereos;
-  std::sort(positions.begin(), positions.end());
+  std::ranges::sort(positions);
 
   /// Return the telescope detector
   TrackingGeometryPtr gGeometry = ActsExamples::Telescope::buildDetector(
diff --git a/Examples/Framework/ML/src/NeuralCalibrator.cpp b/Examples/Framework/ML/src/NeuralCalibrator.cpp
index 54003b3bfc1..8b0e07f1a62 100644
--- a/Examples/Framework/ML/src/NeuralCalibrator.cpp
+++ b/Examples/Framework/ML/src/NeuralCalibrator.cpp
@@ -12,6 +12,7 @@
 #include "Acts/EventData/MeasurementHelpers.hpp"
 #include "Acts/EventData/SourceLink.hpp"
 #include "Acts/Utilities/CalibrationContext.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Utilities/UnitVectors.hpp"
 #include "ActsExamples/EventData/Measurement.hpp"
 
@@ -84,8 +85,7 @@ void ActsExamples::NeuralCalibrator::calibrate(
   assert((idxSourceLink.index() < measurements.size()) and
          "Source link index is outside the container bounds");
 
-  if (std::find(m_volumeIds.begin(), m_volumeIds.end(),
-                idxSourceLink.geometryId().volume()) == m_volumeIds.end()) {
+  if (!rangeContainsValue(m_volumeIds, idxSourceLink.geometryId())) {
     m_fallback.calibrate(measurements, clusters, gctx, cctx, sourceLink,
                          trackState);
     return;
diff --git a/Examples/Framework/include/ActsExamples/EventData/Index.hpp b/Examples/Framework/include/ActsExamples/EventData/Index.hpp
index 74e7153b78f..6502c246065 100644
--- a/Examples/Framework/include/ActsExamples/EventData/Index.hpp
+++ b/Examples/Framework/include/ActsExamples/EventData/Index.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2019-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2019-2024 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
@@ -55,7 +55,7 @@ inline boost::container::flat_multimap<value_t, Index> invertIndexMultimap(
     inverse.insert(i);
   }
 #else
-  std::sort(unordered.begin(), unordered.end());
+  std::ranges::sort(unordered);
   inverse.insert(boost::container::ordered_range_t{}, unordered.begin(),
                  unordered.end());
 #endif
diff --git a/Examples/Framework/include/ActsExamples/Framework/Sequencer.hpp b/Examples/Framework/include/ActsExamples/Framework/Sequencer.hpp
index bb332145ae6..460580e5f97 100644
--- a/Examples/Framework/include/ActsExamples/Framework/Sequencer.hpp
+++ b/Examples/Framework/include/ActsExamples/Framework/Sequencer.hpp
@@ -82,9 +82,6 @@ class Sequencer {
     /// Callback that is invoked in the event loop.
     /// @warning This function can be called from multiple threads and should therefore be thread-safe
     IterationCallback iterationCallback = []() {};
-    /// Run data flow consistency checks
-    /// Defaults to false right now until all components are migrated
-    bool runDataFlowChecks = true;
 
     bool trackFpes = true;
     std::vector<FpeMask> fpeMasks{};
diff --git a/Examples/Framework/src/Framework/Sequencer.cpp b/Examples/Framework/src/Framework/Sequencer.cpp
index 520bc86587e..908f202bfb2 100644
--- a/Examples/Framework/src/Framework/Sequencer.cpp
+++ b/Examples/Framework/src/Framework/Sequencer.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2017-2019 CERN for the benefit of the Acts project
+// Copyright (C) 2017-2024 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
@@ -172,10 +172,6 @@ void Sequencer::addElement(const std::shared_ptr<SequenceElement>& element) {
   elementTypeCapitalized[0] = std::toupper(elementTypeCapitalized[0]);
   ACTS_INFO("Add " << elementType << " '" << element->name() << "'");
 
-  if (!m_cfg.runDataFlowChecks) {
-    return;
-  }
-
   auto symbol = [&](const char* in) {
     std::string s = demangleAndShorten(in);
     std::size_t pos = 0;
@@ -622,9 +618,8 @@ void Sequencer::fpeReport() const {
     std::transform(merged.stackTraces().begin(), merged.stackTraces().end(),
                    std::back_inserter(sorted),
                    [](const auto& f) -> const auto& { return f; });
-    std::sort(sorted.begin(), sorted.end(), [](const auto& a, const auto& b) {
-      return a.get().count > b.get().count;
-    });
+    std::ranges::sort(sorted, std::greater{},
+                      [](const auto& s) { return s.get().count; });
 
     std::vector<std::reference_wrapper<const Acts::FpeMonitor::Result::FpeInfo>>
         remaining;
diff --git a/Examples/Framework/src/Framework/WhiteBoard.cpp b/Examples/Framework/src/Framework/WhiteBoard.cpp
index b7e53eaeda5..a71ac23e7b0 100644
--- a/Examples/Framework/src/Framework/WhiteBoard.cpp
+++ b/Examples/Framework/src/Framework/WhiteBoard.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -8,6 +8,7 @@
 
 #include "ActsExamples/Framework/WhiteBoard.hpp"
 
+#include <algorithm>
 #include <array>
 #include <string_view>
 
@@ -67,8 +68,7 @@ std::vector<std::string_view> ActsExamples::WhiteBoard::similarNames(
     }
   }
 
-  std::sort(names.begin(), names.end(),
-            [&](const auto &a, const auto &b) { return a.first < b.first; });
+  std::ranges::sort(names, {}, [](const auto &n) { return n.first; });
 
   std::vector<std::string_view> selected_names;
   for (std::size_t i = 0; i < std::min(names.size(), maxNumber); ++i) {
diff --git a/Examples/Framework/src/Utilities/EventDataTransforms.cpp b/Examples/Framework/src/Utilities/EventDataTransforms.cpp
index c32c1875d5d..ab94a4a61a1 100644
--- a/Examples/Framework/src/Utilities/EventDataTransforms.cpp
+++ b/Examples/Framework/src/Utilities/EventDataTransforms.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -12,6 +12,7 @@
 #include "ActsExamples/EventData/IndexSourceLink.hpp"
 #include "ActsExamples/EventData/SimSpacePoint.hpp"
 
+#include <algorithm>
 #include <vector>
 
 ActsExamples::ProtoTrack ActsExamples::seedToPrototrack(
@@ -68,8 +69,7 @@ ActsExamples::SimSeed ActsExamples::prototrackToSeed(
 
   std::transform(track.begin(), track.end(), std::back_inserter(ps),
                  findSpacePoint);
-  std::sort(ps.begin(), ps.end(),
-            [](const auto& a, const auto& b) { return a->r() < b->r(); });
+  std::ranges::sort(ps, {}, [](const auto& p) { return p->r(); });
 
   // Simply use r = m*z + t and solve for r=0 to find z vertex position...
   // Probably not the textbook way to do
diff --git a/Examples/Framework/src/Validation/TrackClassification.cpp b/Examples/Framework/src/Validation/TrackClassification.cpp
index e163106b291..5763b41d369 100644
--- a/Examples/Framework/src/Validation/TrackClassification.cpp
+++ b/Examples/Framework/src/Validation/TrackClassification.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2019-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2019-2024 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
@@ -40,11 +40,8 @@ inline void increaseHitCount(
 /// Sort hit counts by decreasing values, i.e. majority particle comes first.
 inline void sortHitCount(
     std::vector<ActsExamples::ParticleHitCount>& particleHitCounts) {
-  std::sort(particleHitCounts.begin(), particleHitCounts.end(),
-            [](const ActsExamples::ParticleHitCount& lhs,
-               const ActsExamples::ParticleHitCount& rhs) {
-              return (lhs.hitCount > rhs.hitCount);
-            });
+  std::ranges::sort(particleHitCounts, std::greater{},
+                    [](const auto& p) { return p.hitCount; });
 }
 
 }  // namespace
diff --git a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvInputOutput.hpp b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvInputOutput.hpp
index 7c4ede4659c..3006f498cc6 100644
--- a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvInputOutput.hpp
+++ b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvInputOutput.hpp
@@ -36,6 +36,7 @@
 // SOFTWARE.
 
 #include "Acts/Utilities/Concepts.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 
 #include <array>
 #include <cassert>
@@ -590,13 +591,11 @@ inline void NamedTupleDsvReader<Delimiter, NamedTuple>::parse_header(
   // check that all non-optional columns are available
   for (const auto& name : names) {
     // no need to for availability if the column is optional
-    auto o = std::find(optional_columns.begin(), optional_columns.end(), name);
-    if (o != optional_columns.end()) {
+    if (Acts::rangeContainsValue(optional_columns, name)) {
       continue;
     }
     // missing, non-optional column mean we can not continue
-    auto c = std::find(m_columns.begin(), m_columns.end(), name);
-    if (c == m_columns.end()) {
+    if (!Acts::rangeContainsValue(m_columns, name)) {
       throw std::runtime_error("Missing header column '" + name + "'");
     }
   }
diff --git a/Examples/Io/Csv/src/CsvMeasurementReader.cpp b/Examples/Io/Csv/src/CsvMeasurementReader.cpp
index ee036ea86a9..aa68cfce2ba 100644
--- a/Examples/Io/Csv/src/CsvMeasurementReader.cpp
+++ b/Examples/Io/Csv/src/CsvMeasurementReader.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2021 CERN for the benefit of the Acts project
+// Copyright (C) 2021-2024 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
@@ -124,7 +124,7 @@ std::vector<ActsExamples::MeasurementData> readMeasurementsByGeometryId(
   auto measurements = readEverything<ActsExamples::MeasurementData>(
       inputDir, "measurements.csv", {"geometry_id", "t"}, event);
   // sort same way they will be sorted in the output container
-  std::sort(measurements.begin(), measurements.end(), CompareGeometryId{});
+  std::ranges::sort(measurements, CompareGeometryId{});
   return measurements;
 }
 
diff --git a/Examples/Io/Csv/src/CsvSeedWriter.cpp b/Examples/Io/Csv/src/CsvSeedWriter.cpp
index 2b3be226c48..f406c327913 100644
--- a/Examples/Io/Csv/src/CsvSeedWriter.cpp
+++ b/Examples/Io/Csv/src/CsvSeedWriter.cpp
@@ -22,6 +22,7 @@
 #include "ActsExamples/Utilities/Range.hpp"
 #include "ActsExamples/Validation/TrackClassification.hpp"
 
+#include <fstream>
 #include <ios>
 #include <iostream>
 #include <stdexcept>
@@ -163,13 +164,8 @@ ActsExamples::ProcessCode ActsExamples::CsvSeedWriter::writeT(
     infoMap[toAdd.seedID] = toAdd;
   }
 
-  mos << "seed_id,particleId,"
-      << "pT,eta,phi,"
-      << "bX,bY,bZ,"
-      << "mX,mY,mZ,"
-      << "tX,tY,tZ,"
-      << "good/duplicate/fake,"
-      << "vertexZ,quality,"
+  mos << "seed_id,particleId," << "pT,eta,phi," << "bX,bY,bZ," << "mX,mY,mZ,"
+      << "tX,tY,tZ," << "good/duplicate/fake," << "vertexZ,quality,"
       << "Hits_ID" << '\n';
 
   for (auto& [id, info] : infoMap) {
diff --git a/Examples/Io/Csv/src/CsvTrackWriter.cpp b/Examples/Io/Csv/src/CsvTrackWriter.cpp
index 5ac430f4b7a..a4155e7c029 100644
--- a/Examples/Io/Csv/src/CsvTrackWriter.cpp
+++ b/Examples/Io/Csv/src/CsvTrackWriter.cpp
@@ -28,6 +28,7 @@
 #include <memory>
 #include <stdexcept>
 #include <string>
+#include <tuple>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -159,19 +160,13 @@ ProcessCode CsvTrackWriter::writeT(const AlgorithmContext& context,
   // Find duplicates
   std::unordered_set<std::size_t> listGoodTracks;
   for (auto& [particleId, matchedTracks] : matched) {
-    std::sort(matchedTracks.begin(), matchedTracks.end(),
-              [](const RecoTrackInfo& lhs, const RecoTrackInfo& rhs) {
-                // sort by nMajorityHits
-                if (lhs.first.nMajorityHits != rhs.first.nMajorityHits) {
-                  return (lhs.first.nMajorityHits > rhs.first.nMajorityHits);
-                }
-                // sort by nOutliers
-                if (lhs.first.nOutliers != rhs.first.nOutliers) {
-                  return (lhs.first.nOutliers < rhs.first.nOutliers);
-                }
-                // sort by chi2
-                return (lhs.first.chi2Sum < rhs.first.chi2Sum);
-              });
+    std::ranges::sort(matchedTracks, [](const auto& lhs, const auto& rhs) {
+      const auto& t1 = lhs.first;
+      const auto& t2 = rhs.first;
+      // nMajorityHits are sorted descending, others ascending
+      return std::tie(t2.nMajorityHits, t1.nOutliers, t1.chi2Sum) <
+             std::tie(t1.nMajorityHits, t2.nOutliers, t2.chi2Sum);
+    });
 
     listGoodTracks.insert(matchedTracks.front().first.trackId);
   }
diff --git a/Examples/Io/EDM4hep/src/EDM4hepReader.cpp b/Examples/Io/EDM4hep/src/EDM4hepReader.cpp
index 7e61ba2a561..5409d67e233 100644
--- a/Examples/Io/EDM4hep/src/EDM4hepReader.cpp
+++ b/Examples/Io/EDM4hep/src/EDM4hepReader.cpp
@@ -396,10 +396,9 @@ ProcessCode EDM4hepReader::read(const AlgorithmContext& ctx) {
         }
       }
 
-      std::sort(hitIndices.begin(), hitIndices.end(),
-                [&](std::size_t a, std::size_t b) {
-                  return simHits.nth(a)->time() < simHits.nth(b)->time();
-                });
+      std::ranges::sort(hitIndices, {}, [&simHits](std::size_t h) {
+        return simHits.nth(h)->time();
+      });
 
       for (std::size_t i = 0; i < hitIndices.size(); ++i) {
         auto& hit = *simHits.nth(hitIndices[i]);
diff --git a/Examples/Io/Json/src/JsonSurfacesWriter.cpp b/Examples/Io/Json/src/JsonSurfacesWriter.cpp
index 99176f742b3..01546a12ebe 100644
--- a/Examples/Io/Json/src/JsonSurfacesWriter.cpp
+++ b/Examples/Io/Json/src/JsonSurfacesWriter.cpp
@@ -26,6 +26,7 @@
 #include "ActsExamples/Utilities/Paths.hpp"
 
 #include <cstddef>
+#include <fstream>
 #include <iomanip>
 #include <sstream>
 #include <stdexcept>
diff --git a/Examples/Io/Obj/include/ActsExamples/Plugins/Obj/ObjTrackingGeometryWriter.hpp b/Examples/Io/Obj/include/ActsExamples/Plugins/Obj/ObjTrackingGeometryWriter.hpp
index 086d973a282..e77497bac8e 100644
--- a/Examples/Io/Obj/include/ActsExamples/Plugins/Obj/ObjTrackingGeometryWriter.hpp
+++ b/Examples/Io/Obj/include/ActsExamples/Plugins/Obj/ObjTrackingGeometryWriter.hpp
@@ -43,11 +43,11 @@ class ObjTrackingGeometryWriter {
     std::size_t outputPrecision = 6;  ///< floating point precision
     std::string outputDir = ".";
 
-    Acts::ViewConfig containerView = Acts::ViewConfig({220, 220, 220});
-    Acts::ViewConfig volumeView = Acts::ViewConfig({220, 220, 0});
-    Acts::ViewConfig sensitiveView = Acts::ViewConfig({0, 180, 240});
-    Acts::ViewConfig passiveView = Acts::ViewConfig({240, 280, 0});
-    Acts::ViewConfig gridView = Acts::ViewConfig({220, 0, 0});
+    Acts::ViewConfig containerView = {.color = {220, 220, 220}};
+    Acts::ViewConfig volumeView = {.color = {220, 220, 0}};
+    Acts::ViewConfig sensitiveView = {.color = {0, 180, 240}};
+    Acts::ViewConfig passiveView = {.color = {240, 280, 0}};
+    Acts::ViewConfig gridView = {.color = {220, 0, 0}};
   };
 
   /// Constructor
diff --git a/Examples/Io/Performance/ActsExamples/Io/Performance/TrackFitterPerformanceWriter.cpp b/Examples/Io/Performance/ActsExamples/Io/Performance/TrackFitterPerformanceWriter.cpp
index 3c4c263b533..a420d07aee0 100644
--- a/Examples/Io/Performance/ActsExamples/Io/Performance/TrackFitterPerformanceWriter.cpp
+++ b/Examples/Io/Performance/ActsExamples/Io/Performance/TrackFitterPerformanceWriter.cpp
@@ -161,10 +161,8 @@ ActsExamples::ProcessCode ActsExamples::TrackFitterPerformanceWriter::writeT(
   // one truth track)
   for (const auto& particle : particles) {
     bool isReconstructed = false;
-    // Find if the particle has been reconstructed
-    auto it = std::find(reconParticleIds.begin(), reconParticleIds.end(),
-                        particle.particleId());
-    if (it != reconParticleIds.end()) {
+    // Check if the particle has been reconstructed
+    if (rangeContainsValue(reconParticleIds, particle.particleId())) {
       isReconstructed = true;
     }
     // Loop over all the other truth particle and find the distance to the
diff --git a/Examples/Io/Root/include/ActsExamples/Io/Root/RootPropagationSummaryWriter.hpp b/Examples/Io/Root/include/ActsExamples/Io/Root/RootPropagationSummaryWriter.hpp
index b55db747128..84781680240 100644
--- a/Examples/Io/Root/include/ActsExamples/Io/Root/RootPropagationSummaryWriter.hpp
+++ b/Examples/Io/Root/include/ActsExamples/Io/Root/RootPropagationSummaryWriter.hpp
@@ -92,7 +92,7 @@ class RootPropagationSummaryWriter : public WriterT<PropagationSummaries> {
   /// track number
   int m_trackNr = 0;
 
-  // initial trajectory parameters
+  /// initial trajectory parameters
   float m_d0 = 0;
   float m_z0 = 0;
   float m_phi = 0;
@@ -100,11 +100,16 @@ class RootPropagationSummaryWriter : public WriterT<PropagationSummaries> {
   float m_qOverP = 0;
   float m_t = 0;
 
-  // derived initial trajectory parameters
+  /// derived initial trajectory parameters
   float m_eta = 0;
   float m_pt = 0;
   float m_p = 0;
 
+  /// Propagation summary statstics
+  int m_nSensitives = 0;
+  int m_nMaterials = 0;
+  int m_nPortals = 0;
+
   // steper statistics
   int m_nSteps = 0;
   int m_nStepTrials = 0;
diff --git a/Examples/Io/Root/src/RootMaterialWriter.cpp b/Examples/Io/Root/src/RootMaterialWriter.cpp
index 692036667a9..f219c48ddde 100644
--- a/Examples/Io/Root/src/RootMaterialWriter.cpp
+++ b/Examples/Io/Root/src/RootMaterialWriter.cpp
@@ -351,8 +351,8 @@ void ActsExamples::RootMaterialWriter::collectMaterial(
     const Acts::TrackingVolume& tVolume,
     Acts::DetectorMaterialMaps& detMatMap) {
   // If the volume has volume material, write that
-  if (tVolume.volumeMaterialSharedPtr() != nullptr && m_cfg.processVolumes) {
-    detMatMap.second[tVolume.geometryId()] = tVolume.volumeMaterialSharedPtr();
+  if (tVolume.volumeMaterialPtr() != nullptr && m_cfg.processVolumes) {
+    detMatMap.second[tVolume.geometryId()] = tVolume.volumeMaterialPtr();
   }
 
   // If confined layers exist, loop over them and collect the layer material
diff --git a/Examples/Io/Root/src/RootPropagationSummaryWriter.cpp b/Examples/Io/Root/src/RootPropagationSummaryWriter.cpp
index 561d1bdc9e8..ea2fa3191e4 100644
--- a/Examples/Io/Root/src/RootPropagationSummaryWriter.cpp
+++ b/Examples/Io/Root/src/RootPropagationSummaryWriter.cpp
@@ -73,6 +73,10 @@ RootPropagationSummaryWriter::RootPropagationSummaryWriter(
   m_outputTree->Branch("pt", &m_pt);
   m_outputTree->Branch("p", &m_p);
 
+  m_outputTree->Branch("nSensitives", &m_nSensitives);
+  m_outputTree->Branch("nMaterials", &m_nMaterials);
+  m_outputTree->Branch("nPortals", &m_nPortals);
+
   m_outputTree->Branch("nSteps", &m_nSteps);
   m_outputTree->Branch("nStepTrials", &m_nStepTrials);
   m_outputTree->Branch("pathLength", &m_pathLength);
@@ -134,6 +138,28 @@ ProcessCode RootPropagationSummaryWriter::writeT(
     m_nStepTrials = static_cast<int>(summary.nStepTrials);
     m_pathLength = static_cast<int>(summary.pathLength);
 
+    m_nMaterials = 0;
+    m_nSensitives = 0;
+    m_nPortals = 0;
+
+    // Loop over the steps & count for the statistics
+    std::ranges::for_each(summary.steps, [&](const auto& step) {
+      // Check if the step is a sensitive step
+      if (step.geoID.sensitive() > 0) {
+        m_nSensitives++;
+      }
+      // Check if the step is a portal step
+      if (step.geoID.boundary() > 0) {
+        m_nPortals++;
+      }
+
+      if (step.surface != nullptr) {
+        // Check if the step is a material step
+        if (step.surface->surfaceMaterial() != nullptr) {
+          m_nMaterials++;
+        }
+      }
+    });
     m_outputTree->Fill();
   }
 
diff --git a/Examples/Io/Root/src/RootSimHitReader.cpp b/Examples/Io/Root/src/RootSimHitReader.cpp
index 4acd9825af0..65fcb446f0e 100644
--- a/Examples/Io/Root/src/RootSimHitReader.cpp
+++ b/Examples/Io/Root/src/RootSimHitReader.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -94,10 +94,8 @@ RootSimHitReader::RootSimHitReader(const RootSimHitReader::Config& config,
   std::get<2>(m_eventMap.back()) = nEntries;
 
   // Sort by event id
-  std::sort(m_eventMap.begin(), m_eventMap.end(),
-            [](const auto& a, const auto& b) {
-              return std::get<0>(a) < std::get<0>(b);
-            });
+  std::ranges::sort(m_eventMap, {},
+                    [](const auto& m) { return std::get<0>(m); });
 
   // Re-Enable all branches
   m_inputChain->SetBranchStatus("*", true);
diff --git a/Examples/Python/src/Base.cpp b/Examples/Python/src/Base.cpp
index aae48a6a3b4..e92e4d17895 100644
--- a/Examples/Python/src/Base.cpp
+++ b/Examples/Python/src/Base.cpp
@@ -268,7 +268,12 @@ void addAlgebra(Acts::Python::Context& ctx) {
         return v;
       }))
       .def("__getitem__",
-           [](const Acts::Vector2& self, Eigen::Index i) { return self[i]; });
+           [](const Acts::Vector2& self, Eigen::Index i) { return self[i]; })
+      .def("__str__", [](const Acts::Vector3& self) {
+        std::stringstream ss;
+        ss << self.transpose();
+        return ss.str();
+      });
 
   py::class_<Acts::Vector3>(m, "Vector3")
       .def(py::init<double, double, double>())
@@ -277,8 +282,17 @@ void addAlgebra(Acts::Python::Context& ctx) {
         v << a[0], a[1], a[2];
         return v;
       }))
+      .def_static("UnitX", []() -> Vector3 { return Acts::Vector3::UnitX(); })
+      .def_static("UnitY", []() -> Vector3 { return Acts::Vector3::UnitY(); })
+      .def_static("UnitZ", []() -> Vector3 { return Acts::Vector3::UnitZ(); })
+
       .def("__getitem__",
-           [](const Acts::Vector3& self, Eigen::Index i) { return self[i]; });
+           [](const Acts::Vector3& self, Eigen::Index i) { return self[i]; })
+      .def("__str__", [](const Acts::Vector3& self) {
+        std::stringstream ss;
+        ss << self.transpose();
+        return ss.str();
+      });
 
   py::class_<Acts::Vector4>(m, "Vector4")
       .def(py::init<double, double, double, double>())
@@ -291,43 +305,74 @@ void addAlgebra(Acts::Python::Context& ctx) {
            [](const Acts::Vector4& self, Eigen::Index i) { return self[i]; });
 
   py::class_<Acts::Transform3>(m, "Transform3")
-      .def(py::init([](std::array<double, 3> translation) {
-        Acts::Transform3 t = Acts::Transform3::Identity();
-        t.pretranslate(
-            Acts::Vector3(translation[0], translation[1], translation[2]));
-        return t;
+      .def(py::init<>())
+      .def(py::init([](const Vector3& translation) -> Transform3 {
+        return Transform3{Translation3{translation}};
       }))
-      .def("getTranslation",
-           [](const Acts::Transform3& self) {
-             return Vector3(self.translation());
+      .def_property_readonly("translation",
+                             [](const Acts::Transform3& self) -> Vector3 {
+                               return self.translation();
+                             })
+      .def_static("Identity", &Acts::Transform3::Identity)
+      .def("__mul__",
+           [](const Acts::Transform3& self, const Acts::Transform3& other) {
+             return self * other;
+           })
+      .def("__mul__",
+           [](const Acts::Transform3& self, const Acts::Translation3& other) {
+             return self * other;
            })
-      .def_static("Identity", &Acts::Transform3::Identity);
-  ;
+      .def("__mul__",
+           [](const Acts::Transform3& self, const Acts::AngleAxis3& other) {
+             return self * other;
+           })
+      .def("__str__", [](const Acts::Transform3& self) {
+        std::stringstream ss;
+        ss << self.matrix();
+        return ss.str();
+      });
+
+  py::class_<Acts::Translation3>(m, "Translation3")
+      .def(py::init(
+          [](const Acts::Vector3& a) { return Acts::Translation3(a); }))
+      .def(py::init([](std::array<double, 3> a) {
+        return Acts::Translation3(Acts::Vector3(a[0], a[1], a[2]));
+      }))
+      .def("__str__", [](const Acts::Translation3& self) {
+        std::stringstream ss;
+        ss << self.translation().transpose();
+        return ss.str();
+      });
+
+  py::class_<Acts::AngleAxis3>(m, "AngleAxis3")
+      .def(py::init([](double angle, const Acts::Vector3& axis) {
+        return Acts::AngleAxis3(angle, axis);
+      }))
+      .def("__str__", [](const Acts::Transform3& self) {
+        std::stringstream ss;
+        ss << self.matrix();
+        return ss.str();
+      });
 }
 
 void addBinning(Context& ctx) {
   auto& m = ctx.get("main");
-  auto binning = m.def_submodule("Binning", "");
-
-  auto binningValue = py::enum_<Acts::BinningValue>(binning, "BinningValue")
-                          .value("x", Acts::BinningValue::binX)
-                          .value("y", Acts::BinningValue::binY)
-                          .value("z", Acts::BinningValue::binZ)
-                          .value("r", Acts::BinningValue::binR)
-                          .value("phi", Acts::BinningValue::binPhi)
-                          .export_values();
-
-  auto boundaryType =
-      py::enum_<Acts::AxisBoundaryType>(binning, "AxisBoundaryType")
-          .value("bound", Acts::AxisBoundaryType::Bound)
-          .value("closed", Acts::AxisBoundaryType::Closed)
-          .value("open", Acts::AxisBoundaryType::Open)
-          .export_values();
-
-  auto axisType = py::enum_<Acts::AxisType>(binning, "AxisType")
+
+  auto binningValue = py::enum_<Acts::BinningValue>(m, "BinningValue")
+                          .value("binX", Acts::BinningValue::binX)
+                          .value("binY", Acts::BinningValue::binY)
+                          .value("binZ", Acts::BinningValue::binZ)
+                          .value("binR", Acts::BinningValue::binR)
+                          .value("binPhi", Acts::BinningValue::binPhi);
+
+  auto boundaryType = py::enum_<Acts::AxisBoundaryType>(m, "AxisBoundaryType")
+                          .value("bound", Acts::AxisBoundaryType::Bound)
+                          .value("closed", Acts::AxisBoundaryType::Closed)
+                          .value("open", Acts::AxisBoundaryType::Open);
+
+  auto axisType = py::enum_<Acts::AxisType>(m, "AxisType")
                       .value("equidistant", Acts::AxisType::Equidistant)
-                      .value("variable", Acts::AxisType::Variable)
-                      .export_values();
+                      .value("variable", Acts::AxisType::Variable);
 }
 
 }  // namespace Acts::Python
diff --git a/Examples/Python/src/Digitization.cpp b/Examples/Python/src/Digitization.cpp
index 54ec8934ac1..ef0e52015e8 100644
--- a/Examples/Python/src/Digitization.cpp
+++ b/Examples/Python/src/Digitization.cpp
@@ -69,6 +69,8 @@ void addDigitization(Context& ctx) {
     ACTS_PYTHON_MEMBER(outputMeasurementSimHitsMap);
     ACTS_PYTHON_MEMBER(surfaceByIdentifier);
     ACTS_PYTHON_MEMBER(randomNumbers);
+    ACTS_PYTHON_MEMBER(doOutputCells);
+    ACTS_PYTHON_MEMBER(doClusterization);
     ACTS_PYTHON_MEMBER(doMerge);
     ACTS_PYTHON_MEMBER(minEnergyDeposit);
     ACTS_PYTHON_MEMBER(digitizationConfigs);
diff --git a/Examples/Python/src/Geometry.cpp b/Examples/Python/src/Geometry.cpp
index 4f4752aa4ef..a8d3218014e 100644
--- a/Examples/Python/src/Geometry.cpp
+++ b/Examples/Python/src/Geometry.cpp
@@ -35,6 +35,7 @@
 #include "Acts/Plugins/Python/Utilities.hpp"
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Surfaces/SurfaceArray.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Utilities/RangeXD.hpp"
 #include "ActsExamples/Geometry/VolumeAssociationTest.hpp"
 
@@ -66,11 +67,9 @@ struct MaterialSurfaceSelector {
 
   /// @param surface is the test surface
   void operator()(const Acts::Surface* surface) {
-    if (surface->surfaceMaterial() != nullptr) {
-      if (std::find(surfaces.begin(), surfaces.end(), surface) ==
-          surfaces.end()) {
-        surfaces.push_back(surface);
-      }
+    if (surface->surfaceMaterial() != nullptr &&
+        !rangeContainsValue(surfaces, surface)) {
+      surfaces.push_back(surface);
     }
   }
 };
@@ -167,8 +166,8 @@ void addGeometry(Context& ctx) {
                return selector.surfaces;
              })
         .def_property_readonly(
-            "worldVolume",
-            &Acts::TrackingGeometry::highestTrackingVolumeShared);
+            "highestTrackingVolume",
+            &Acts::TrackingGeometry::highestTrackingVolumePtr);
   }
 
   {
@@ -253,7 +252,8 @@ void addExperimentalGeometry(Context& ctx) {
       });
 
   // Portal definition
-  py::class_<Portal, std::shared_ptr<Portal>>(m, "Portal");
+  py::class_<Experimental::Portal, std::shared_ptr<Experimental::Portal>>(
+      m, "Portal");
 
   {
     // The surface hierarchy map
diff --git a/Examples/Python/src/Obj.cpp b/Examples/Python/src/Obj.cpp
index 1a7faa287fd..2a36d06ad09 100644
--- a/Examples/Python/src/Obj.cpp
+++ b/Examples/Python/src/Obj.cpp
@@ -40,35 +40,29 @@ void addObj(Context& ctx) {
     ///
     mex.def("writeSurfacesObj",
             [](const std::vector<std::shared_ptr<Surface>>& surfaces,
-               const GeometryContext& viewContext,
-               const std::array<int, 3>& viewRgb, unsigned int viewSegements,
+               const GeometryContext& viewContext, const ViewConfig& viewConfig,
                const std::string& fileName) {
-              Acts::ViewConfig sConfig = Acts::ViewConfig{viewRgb};
-              sConfig.nSegments = viewSegements;
               Acts::GeometryView3D view3D;
               Acts::ObjVisualization3D obj;
 
               for (const auto& surface : surfaces) {
                 view3D.drawSurface(obj, *surface, viewContext,
-                                   Acts::Transform3::Identity(), sConfig);
+                                   Acts::Transform3::Identity(), viewConfig);
               }
               obj.write(fileName);
             });
     mex.def("writeVolumesObj",
             [](const std::vector<std::shared_ptr<Experimental::DetectorVolume>>&
                    Volumes,
-               const GeometryContext& viewContext,
-               const std::array<int, 3>& viewRgb, unsigned int viewSegements,
+               const GeometryContext& viewContext, const ViewConfig& viewConfig,
                const std::string& fileName) {
-              Acts::ViewConfig sConfig = Acts::ViewConfig{viewRgb};
-              sConfig.nSegments = viewSegements;
               Acts::GeometryView3D view3D;
               Acts::ObjVisualization3D obj;
 
               for (const auto& volume : Volumes) {
                 view3D.drawDetectorVolume(obj, *volume, viewContext,
                                           Acts::Transform3::Identity(),
-                                          sConfig);
+                                          viewConfig);
               }
               obj.write(fileName);
             });
@@ -76,22 +70,19 @@ void addObj(Context& ctx) {
             [](const std::vector<std::shared_ptr<Surface>>& surfaces,
                const std::vector<std::shared_ptr<Experimental::DetectorVolume>>&
                    Volumes,
-               const GeometryContext& viewContext,
-               const std::array<int, 3>& viewRgb, unsigned int viewSegements,
+               const GeometryContext& viewContext, const ViewConfig& viewConfig,
                const std::string& fileName) {
-              Acts::ViewConfig sConfig = Acts::ViewConfig{viewRgb};
-              sConfig.nSegments = viewSegements;
               Acts::GeometryView3D view3D;
               Acts::ObjVisualization3D obj;
 
               for (const auto& volume : Volumes) {
                 view3D.drawDetectorVolume(obj, *volume, viewContext,
                                           Acts::Transform3::Identity(),
-                                          sConfig);
+                                          viewConfig);
               }
               for (const auto& surface : surfaces) {
                 view3D.drawSurface(obj, *surface, viewContext,
-                                   Acts::Transform3::Identity(), sConfig);
+                                   Acts::Transform3::Identity(), viewConfig);
               }
               obj.write(fileName);
             });
diff --git a/Examples/Python/src/Output.cpp b/Examples/Python/src/Output.cpp
index d12e98294ec..7e78dbcde9b 100644
--- a/Examples/Python/src/Output.cpp
+++ b/Examples/Python/src/Output.cpp
@@ -125,6 +125,13 @@ void addOutput(Context& ctx) {
     ACTS_PYTHON_STRUCT_END();
 
     patchKwargsConstructor(c);
+
+    py::class_<Color>(m, "Color")
+        .def(py::init<>())
+        .def(py::init<int, int, int>())
+        .def(py::init<double, double, double>())
+        .def(py::init<std::string>())
+        .def_readonly("rgb", &Color::rgb);
   }
 
   {
diff --git a/Examples/Python/src/Svg.cpp b/Examples/Python/src/Svg.cpp
index 74d6197ea2f..36bec574e22 100644
--- a/Examples/Python/src/Svg.cpp
+++ b/Examples/Python/src/Svg.cpp
@@ -20,6 +20,7 @@
 #include "Acts/Plugins/ActSVG/TrackingGeometrySvgConverter.hpp"
 #include "Acts/Plugins/Python/Utilities.hpp"
 #include "Acts/Utilities/Enumerate.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "ActsExamples/EventData/GeometryContainers.hpp"
 #include "ActsExamples/EventData/SimHit.hpp"
 #include "ActsExamples/EventData/SimSpacePoint.hpp"
@@ -68,17 +69,13 @@ actsvg::svg::object viewDetectorVolume(const Svg::ProtoVolume& pVolume,
   svgDet._id = identification;
   svgDet._tag = "g";
 
-  auto [view, selection, viewRange] = viewAndRange;
+  const auto& [view, selection, viewRange] = viewAndRange;
 
   // Translate selection into booleans
-  bool all =
-      std::find(selection.begin(), selection.end(), "all") != selection.end();
-  bool sensitives = std::find(selection.begin(), selection.end(),
-                              "sensitives") != selection.end();
-  bool portals = std::find(selection.begin(), selection.end(), "portals") !=
-                 selection.end();
-  bool materials = std::find(selection.begin(), selection.end(), "materials") !=
-                   selection.end();
+  const bool all = rangeContainsValue(selection, "all");
+  const bool sensitives = rangeContainsValue(selection, "sensitives");
+  const bool portals = rangeContainsValue(selection, "portals");
+  const bool materials = rangeContainsValue(selection, "materials");
 
   // Helper lambda for material selection
   auto materialSel = [&](const Svg::ProtoSurface& s) -> bool {
@@ -138,8 +135,7 @@ actsvg::svg::object viewDetectorVolume(const Svg::ProtoVolume& pVolume,
       gpIDs = pgID->second._id;
     }
 
-    if (std::find(portalCache.begin(), portalCache.end(), gpIDs) !=
-        portalCache.end()) {
+    if (rangeContainsValue(portalCache, gpIDs)) {
       continue;
     }
 
diff --git a/Examples/Python/src/Traccc.cpp b/Examples/Python/src/Traccc.cpp
index d620a5584f7..e5a5f22be7e 100644
--- a/Examples/Python/src/Traccc.cpp
+++ b/Examples/Python/src/Traccc.cpp
@@ -25,7 +25,6 @@
 #include <detray/propagator/actor_chain.hpp>
 #include <detray/propagator/line_stepper.hpp>
 #include <detray/propagator/propagator.hpp>
-#include <detray/utils/inspectors.hpp>
 #include <pybind11/pybind11.h>
 #include <vecmem/memory/host_memory_resource.hpp>
 #include <vecmem/memory/memory_resource.hpp>
@@ -72,7 +71,9 @@ void addTraccc(Context& ctx) {
 
       // Navigation with inspection
       using DetrayNavigator =
-          detray::navigator<DetrayHostDetector, DetrayInspector>;
+          detray::navigator<DetrayHostDetector,
+                            detray::navigation::default_cache_size,
+                            DetrayInspector>;
       // Line stepper
       using DetrayLineStepper =
           detray::line_stepper<typename DetrayHostDetector::algebra_type>;
diff --git a/Examples/Python/tests/root_file_hashes.txt b/Examples/Python/tests/root_file_hashes.txt
index f46e52e5aa1..547d53b9a78 100644
--- a/Examples/Python/tests/root_file_hashes.txt
+++ b/Examples/Python/tests/root_file_hashes.txt
@@ -16,7 +16,7 @@ test_itk_seeding__estimatedparams.root: 7e3acb54fcaabae19fe5b8601bd5bd3e5f65d6a1
 test_itk_seeding__performance_seeding.root: 78ebda54cd0f026ba4b7f316724ffd946de56a932735914baf1b7bba9505c29d
 test_itk_seeding__particles.root: 0b6f4ad438010ac48803d48ed98e80b5e87d310bae6c2c02b16cd94d7a4d7d07
 test_itk_seeding__particles_simulation.root: ef0246069aa697019f28a8b270a68de95312cae5f2f2c74848566c3ce4f70363
-test_propagation__propagation_summary.root: 85d877c3a48a6235d3d5a398b47130d5d17d4d3724128ccb339d8174e71a5bb0
+test_propagation__propagation_summary.root: 280c1a6fcfe71974ac39587b4afad27a31640bec42ca6537cc92e2d5e09d7ed6
 test_material_recording__geant4_material_tracks.root: c022b9362249b29f57a07926b20644e3ab4ab8ebcf03f773fbf46c446fc1a0a1
 test_truth_tracking_gsf[generic]__trackstates_gsf.root: 974968d9c867a18e2477fb241288e8d8a4a5e7499495d3e1a7b9cafa26c6dda5
 test_truth_tracking_gsf[generic]__tracksummary_gsf.root: b698e3d21eacc34fc8b0ce1d3fbe07405a4b8b549e07f0160573e64c3b401f04
diff --git a/Examples/Scripts/MaterialMapping/Mat_map_detector_plot.C b/Examples/Scripts/MaterialMapping/Mat_map_detector_plot.C
index deeb7c275a3..ae4c7c5588b 100644
--- a/Examples/Scripts/MaterialMapping/Mat_map_detector_plot.C
+++ b/Examples/Scripts/MaterialMapping/Mat_map_detector_plot.C
@@ -8,6 +8,8 @@
 
 #include <TROOT.h>
 
+#include "Acts/Utilities/Helpers.hpp"
+
 #include "materialPlotHelper.cpp"
 
 #include <fstream>
@@ -153,7 +155,7 @@ void Fill(std::vector<TH2F*>& detector_hist, const std::string& input_file, std:
       }
 
       // Check if the volume/surface is part of the selected ones
-      if(std::find(detectors.begin(), detectors.end(), ID.volume()) != detectors.end()) {
+      if(rangeContainsValue(detectors, ID.volume())) {
         matX0 += mat_step_length->at(j) / mat_X0->at(j);
         matL0 += mat_step_length->at(j) / mat_L0->at(j);
       }
diff --git a/Examples/Scripts/Python/full_chain_odd.py b/Examples/Scripts/Python/full_chain_odd.py
index a5d0dda2c58..e76111da7ac 100755
--- a/Examples/Scripts/Python/full_chain_odd.py
+++ b/Examples/Scripts/Python/full_chain_odd.py
@@ -273,7 +273,7 @@
             outputDirRoot=outputDir if args.output_root else None,
             outputDirCsv=outputDir if args.output_csv else None,
             rnd=rnd,
-            killVolume=trackingGeometry.worldVolume,
+            killVolume=trackingGeometry.highestTrackingVolume,
             killAfterTime=25 * u.ns,
         )
     else:
diff --git a/Examples/Scripts/Python/full_chain_odd_LRT.py b/Examples/Scripts/Python/full_chain_odd_LRT.py
index 2971ac694c8..a5fd294ceda 100644
--- a/Examples/Scripts/Python/full_chain_odd_LRT.py
+++ b/Examples/Scripts/Python/full_chain_odd_LRT.py
@@ -276,7 +276,7 @@
             outputDirRoot=outputDir if args.output_root else None,
             outputDirCsv=outputDir if args.output_csv else None,
             rnd=rnd,
-            killVolume=trackingGeometry.worldVolume,
+            killVolume=trackingGeometry.highestTrackingVolume,
             killAfterTime=25 * u.ns,
         )
     else:
diff --git a/Examples/Scripts/Python/geomodel.py b/Examples/Scripts/Python/geomodel.py
index 9cfca061b24..8bc49d59090 100644
--- a/Examples/Scripts/Python/geomodel.py
+++ b/Examples/Scripts/Python/geomodel.py
@@ -129,16 +129,16 @@ def main():
     # Read the geometry model from the database
     gmTree = acts.geomodel.readFromDb(args.input)
 
-    gmFactoryConfig = gm.GeoModelDetectorSurfaceFactory.Config()
+    gmFactoryConfig = gm.GeoModelDetectorObjectFactory.Config()
     gmFactoryConfig.materialList = args.material_list
     gmFactoryConfig.nameList = args.name_list
     gmFactoryConfig.convertSubVolumes = args.convert_subvols
-    gmFactory = gm.GeoModelDetectorSurfaceFactory(gmFactoryConfig, logLevel)
+    gmFactory = gm.GeoModelDetectorObjectFactory(gmFactoryConfig, logLevel)
     # The options
-    gmFactoryOptions = gm.GeoModelDetectorSurfaceFactory.Options()
+    gmFactoryOptions = gm.GeoModelDetectorObjectFactory.Options()
     gmFactoryOptions.queries = args.queries
     # The Cache & construct call
-    gmFactoryCache = gm.GeoModelDetectorSurfaceFactory.Cache()
+    gmFactoryCache = gm.GeoModelDetectorObjectFactory.Cache()
     gmFactory.construct(gmFactoryCache, gContext, gmTree, gmFactoryOptions)
 
     # All surfaces from GeoModel
@@ -236,7 +236,7 @@ def main():
                 [[ivol, volumeOptions] for ivol in range(detector.numberVolumes())],
                 [
                     ["xy", ["sensitives", "portals"], xyRange],
-                    ["zr", ["", "", "materials"], zrRange],
+                    ["zr", ["sensitives", "portals", "materials"], zrRange],
                 ],
                 args.output + "_detector",
             )
diff --git a/Examples/Scripts/TrackingPerformance/defineReconstructionPerformance.C b/Examples/Scripts/TrackingPerformance/defineReconstructionPerformance.C
index 04715e27fe7..c2c0322b609 100644
--- a/Examples/Scripts/TrackingPerformance/defineReconstructionPerformance.C
+++ b/Examples/Scripts/TrackingPerformance/defineReconstructionPerformance.C
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2021 CERN for the benefit of the Acts project
+// Copyright (C) 2021-2024 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
@@ -8,6 +8,7 @@
 
 #include <array>
 #include <iostream>
+#include <algorithm>
 #include <string>
 #include <tuple>
 #include <vector>
@@ -189,19 +190,9 @@ void defineReconstructionPerformance(
       for (auto& [id, matchedTracks] : matchedParticles) {
         // Sort all tracks matched to this particle according to majority prob
         // and track quality
-        std::sort(matchedTracks.begin(), matchedTracks.end(),
-                  [](const RecoTrackInfo& lhs, const RecoTrackInfo& rhs) {
-                    if (lhs.nMajorityHits > rhs.nMajorityHits) {
-                      return true;
-                    }
-                    if (lhs.nMajorityHits < rhs.nMajorityHits) {
-                      return false;
-                    }
-                    if (lhs.nMeasurements > rhs.nMeasurements) {
-                      return true;
-                    }
-                    return false;
-                  });
+        std::ranges::sort(matchedTracks, std::greater{}, [](const auto& m) {
+            return std::make_tuple(m.nMajorityHits, m.nMeasurements);
+          });
         // Fill the duplication rate plots
         for (std::size_t k = 0; k < matchedTracks.size(); ++k) {
           auto eta = matchedTracks[k].eta;
diff --git a/Fatras/src/Digitization/PlanarSurfaceMask.cpp b/Fatras/src/Digitization/PlanarSurfaceMask.cpp
index f660082bfad..fc25f609917 100644
--- a/Fatras/src/Digitization/PlanarSurfaceMask.cpp
+++ b/Fatras/src/Digitization/PlanarSurfaceMask.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2020-2024 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
@@ -58,8 +58,7 @@ void checkIntersection(std::vector<Acts::Intersection2D>& intersections,
 Acts::Result<ActsFatras::PlanarSurfaceMask::Segment2D> maskAndReturn(
     std::vector<Acts::Intersection2D>& intersections,
     const ActsFatras::PlanarSurfaceMask::Segment2D& segment, bool firstInside) {
-  std::sort(intersections.begin(), intersections.end(),
-            Acts::Intersection2D::pathLengthOrder);
+  std::ranges::sort(intersections, Acts::Intersection2D::pathLengthOrder);
   if (intersections.size() >= 2) {
     return ActsFatras::PlanarSurfaceMask::Segment2D{
         intersections[0].position(), intersections[1].position()};
diff --git a/Fatras/src/Digitization/Segmentizer.cpp b/Fatras/src/Digitization/Segmentizer.cpp
index 9c2bb72c972..8a3702a772f 100644
--- a/Fatras/src/Digitization/Segmentizer.cpp
+++ b/Fatras/src/Digitization/Segmentizer.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2020-2024 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
@@ -140,7 +140,7 @@ ActsFatras::Segmentizer::segments(const Acts::GeometryContext& geoCtx,
   // Register the last step if successful
   if (!cSteps.empty()) {
     cSteps.push_back(ChannelStep({0, 0}, end, start));
-    std::sort(cSteps.begin(), cSteps.end());
+    std::ranges::sort(cSteps, std::less<ChannelStep>{});
   }
 
   std::vector<ChannelSegment> cSegments;
diff --git a/Plugins/ActSVG/include/Acts/Plugins/ActSVG/EventDataSvgConverter.hpp b/Plugins/ActSVG/include/Acts/Plugins/ActSVG/EventDataSvgConverter.hpp
index e162db5dce4..afcb255a197 100644
--- a/Plugins/ActSVG/include/Acts/Plugins/ActSVG/EventDataSvgConverter.hpp
+++ b/Plugins/ActSVG/include/Acts/Plugins/ActSVG/EventDataSvgConverter.hpp
@@ -13,11 +13,7 @@
 #include "Acts/Utilities/Logger.hpp"
 #include <actsvg/core.hpp>
 
-namespace Acts {
-
-namespace Svg {
-
-namespace EventDataConverter {
+namespace Acts::Svg::EventDataConverter {
 
 /// Write/create a 3D point in XY view
 ///
@@ -62,8 +58,4 @@ actsvg::svg::object point(const Vector3& pos, ActsScalar size,
   return circle;
 }
 
-}  // namespace EventDataConverter
-
-}  // namespace Svg
-
-}  // namespace Acts
+}  // namespace Acts::Svg::EventDataConverter
diff --git a/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp b/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp
index 1f788a11b5e..71a5e6862fa 100644
--- a/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp
+++ b/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp
@@ -27,9 +27,7 @@
 #include <tuple>
 #include <vector>
 
-namespace Acts {
-
-namespace Svg {
+namespace Acts::Svg {
 
 using ProtoSurface = actsvg::proto::surface<std::vector<Vector3>>;
 using ProtoGrid = actsvg::proto::grid;
@@ -340,5 +338,4 @@ static inline actsvg::svg::object zphi(
 }
 
 }  // namespace View
-}  // namespace Svg
-}  // namespace Acts
+}  // namespace Acts::Svg
diff --git a/Plugins/ActSVG/include/Acts/Plugins/ActSVG/SvgUtils.hpp b/Plugins/ActSVG/include/Acts/Plugins/ActSVG/SvgUtils.hpp
index 8a4b5cb89a0..4567190e921 100644
--- a/Plugins/ActSVG/include/Acts/Plugins/ActSVG/SvgUtils.hpp
+++ b/Plugins/ActSVG/include/Acts/Plugins/ActSVG/SvgUtils.hpp
@@ -17,8 +17,7 @@
 #include <tuple>
 #include <vector>
 
-namespace Acts {
-namespace Svg {
+namespace Acts::Svg {
 
 struct Style {
   // Fill parameters
@@ -178,5 +177,4 @@ inline static void toFile(const std::vector<actsvg::svg::object>& objects,
   fout.close();
 }
 
-}  // namespace Svg
-}  // namespace Acts
+}  // namespace Acts::Svg
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp
index 6049dd3876b..7ccdc1cee62 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp
@@ -306,9 +306,9 @@ SeedFinder<external_spacepoint_t, Acts::Cuda>::createSeedsForGroup(
                                 false);
       }
 
-      std::sort(candidates.begin(), candidates.end(),
-                CandidatesForMiddleSp<const InternalSpacePoint<
-                    external_spacepoint_t>>::descendingByQuality);
+      std::ranges::sort(candidates,
+                        CandidatesForMiddleSp<const InternalSpacePoint<
+                            external_spacepoint_t>>::descendingByQuality);
       std::size_t numQualitySeeds = 0;  // not used but needs to be fixed
       m_config.seedFilter->filterSeeds_1SpFixed(spacePointData, candidates,
                                                 numQualitySeeds,
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp
index deee520fab0..7304496aace 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp
@@ -23,11 +23,11 @@
 #include "Acts/Seeding/InternalSpacePoint.hpp"
 
 // System include(s).
+#include <algorithm>
 #include <cstring>
 #include <vector>
 
-namespace Acts {
-namespace Cuda {
+namespace Acts::Cuda {
 
 template <typename external_spacepoint_t>
 SeedFinder<external_spacepoint_t>::SeedFinder(
@@ -226,8 +226,8 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
       candidates.emplace_back(bottomSP, middleSP, topSP, triplet.weight, 0,
                               false);
     }
-    std::sort(
-        candidates.begin(), candidates.end(),
+    std::ranges::sort(
+        candidates,
         CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>::
             descendingByQuality);
     std::size_t numQualitySeeds = 0;  // not used but needs to be fixed
@@ -249,5 +249,4 @@ void SeedFinder<external_spacepoint_t>::setLogger(
   return m_logger.swap(newLogger);
 }
 
-}  // namespace Cuda
-}  // namespace Acts
+}  // namespace Acts::Cuda
diff --git a/Plugins/DD4hep/src/DD4hepLayerBuilder.cpp b/Plugins/DD4hep/src/DD4hepLayerBuilder.cpp
index 4d604fbeb42..705426c9bb3 100644
--- a/Plugins/DD4hep/src/DD4hepLayerBuilder.cpp
+++ b/Plugins/DD4hep/src/DD4hepLayerBuilder.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2017-2019 CERN for the benefit of the Acts project
+// Copyright (C) 2017-2024 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
@@ -102,7 +102,7 @@ const Acts::LayerVector Acts::DD4hepLayerBuilder::endcapLayers(
                        std::back_inserter(rvalues), [&](const auto& surface) {
                          return VectorHelpers::perp(surface->center(gctx));
                        });
-        std::sort(rvalues.begin(), rvalues.end());
+        std::ranges::sort(rvalues);
         std::vector<std::string> locs;
         std::transform(rvalues.begin(),
                        std::unique(rvalues.begin(), rvalues.end()),
@@ -275,7 +275,7 @@ const Acts::LayerVector Acts::DD4hepLayerBuilder::centralLayers(
                        std::back_inserter(zvalues), [&](const auto& surface) {
                          return surface->center(gctx)[eZ];
                        });
-        std::sort(zvalues.begin(), zvalues.end());
+        std::ranges::sort(zvalues);
         std::vector<std::string> locs;
         std::transform(zvalues.begin(),
                        std::unique(zvalues.begin(), zvalues.end()),
diff --git a/Plugins/Detray/CMakeLists.txt b/Plugins/Detray/CMakeLists.txt
index 79d56b37cf0..470315de788 100644
--- a/Plugins/Detray/CMakeLists.txt
+++ b/Plugins/Detray/CMakeLists.txt
@@ -24,7 +24,8 @@ target_link_libraries(
         detray::core
         detray::core_array
         detray::io
-        detray::utils
+        detray::detectors
+        detray::test_utils
         vecmem::core
 )
 
diff --git a/Plugins/Detray/include/Acts/Plugins/Detray/DetrayConverter.hpp b/Plugins/Detray/include/Acts/Plugins/Detray/DetrayConverter.hpp
index 24c59968ec5..b32bc05adee 100644
--- a/Plugins/Detray/include/Acts/Plugins/Detray/DetrayConverter.hpp
+++ b/Plugins/Detray/include/Acts/Plugins/Detray/DetrayConverter.hpp
@@ -22,8 +22,6 @@
 
 namespace Acts {
 
-using namespace Experimental;
-
 class DetrayConverter {
  public:
   /// Detray conversion options
@@ -49,7 +47,8 @@ class DetrayConverter {
   ///
   /// @returns a detector of requested return type
   template <typename detector_t = DetrayHostDetector>
-  detector_t convert(const GeometryContext& gctx, const Detector& detector,
+  detector_t convert(const GeometryContext& gctx,
+                     const Experimental::Detector& detector,
                      vecmem::memory_resource& mr, const Options& options) {
     // The building cache object
     DetrayConversionUtils::GeometryIdCache geoIdCache;
diff --git a/Plugins/Detray/src/DetrayGeometryConverter.cpp b/Plugins/Detray/src/DetrayGeometryConverter.cpp
index 4c1902c6b13..15996b59739 100644
--- a/Plugins/Detray/src/DetrayGeometryConverter.cpp
+++ b/Plugins/Detray/src/DetrayGeometryConverter.cpp
@@ -126,6 +126,8 @@ Acts::DetrayGeometryConverter::convertPortal(
           instance);
 
   auto [surfaceAdjusted, insidePointer] = orientedSurfaces[ip];
+  // Assign the geometry id to the surface
+  surfaceAdjusted->assignGeometryId(surface.geometryId());
 
   // Single link detected - just write it out, we use the oriented surface
   // in order to make sure the size is adjusted
@@ -225,6 +227,7 @@ Acts::DetrayGeometryConverter::convertPortal(
                     subBoundValues[CylinderBounds::BoundValues::eHalfLengthZ]));
             auto subSurface =
                 Surface::makeShared<CylinderSurface>(subTransform, subBounds);
+            subSurface->assignGeometryId(surface.geometryId());
 
             auto portalPayload = convertSurface(gctx, *subSurface, true);
             portalPayload.mask.volume_link.link = clippedIndices[ib - 1u];
@@ -246,7 +249,7 @@ Acts::DetrayGeometryConverter::convertPortal(
             auto subBounds = std::make_shared<RadialBounds>(subBoundValues);
             auto subSurface = Surface::makeShared<DiscSurface>(
                 portal.surface().transform(gctx), subBounds);
-
+            subSurface->assignGeometryId(surface.geometryId());
             auto portalPayload = convertSurface(gctx, *subSurface, true);
             portalPayload.mask.volume_link.link = clippedIndices[ib - 1u];
             portals.push_back(portalPayload);
diff --git a/Plugins/Detray/src/DetrayMaterialConverter.cpp b/Plugins/Detray/src/DetrayMaterialConverter.cpp
index 14fdd2163df..b31a1d2e81a 100644
--- a/Plugins/Detray/src/DetrayMaterialConverter.cpp
+++ b/Plugins/Detray/src/DetrayMaterialConverter.cpp
@@ -16,6 +16,7 @@
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/BinUtility.hpp"
 #include "Acts/Utilities/BinningType.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 
 #include <stdexcept>
 
@@ -26,11 +27,9 @@ struct MaterialSurfaceSelector {
 
   /// @param surface is the test surface
   void operator()(const Acts::Surface* surface) {
-    if (surface->surfaceMaterial() != nullptr) {
-      if (std::find(surfaces.begin(), surfaces.end(), surface) ==
-          surfaces.end()) {
-        surfaces.push_back(surface);
-      }
+    if (surface->surfaceMaterial() != nullptr &&
+        !rangeContainsValue(surfaces, surface)) {
+      surfaces.push_back(surface);
     }
   }
 };
diff --git a/Plugins/ExaTrkX/src/BoostTrackBuilding.cpp b/Plugins/ExaTrkX/src/BoostTrackBuilding.cpp
index 01083f50709..aa072c83994 100644
--- a/Plugins/ExaTrkX/src/BoostTrackBuilding.cpp
+++ b/Plugins/ExaTrkX/src/BoostTrackBuilding.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -10,6 +10,7 @@
 
 #include "Acts/Utilities/Zip.hpp"
 
+#include <algorithm>
 #include <map>
 
 #include <boost/beast/core/span.hpp>
@@ -82,7 +83,7 @@ std::vector<std::vector<int>> BoostTrackBuilding::operator()(
   ACTS_VERBOSE("Number of track labels: " << trackLabels.size());
   ACTS_VERBOSE("Number of unique track labels: " << [&]() {
     std::vector<vertex_t> sorted(trackLabels);
-    std::sort(sorted.begin(), sorted.end());
+    std::ranges::sort(sorted);
     sorted.erase(std::unique(sorted.begin(), sorted.end()), sorted.end());
     return sorted.size();
   }());
diff --git a/Plugins/ExaTrkX/src/TorchTruthGraphMetricsHook.cpp b/Plugins/ExaTrkX/src/TorchTruthGraphMetricsHook.cpp
index f279c5bb2cd..ce829860eb1 100644
--- a/Plugins/ExaTrkX/src/TorchTruthGraphMetricsHook.cpp
+++ b/Plugins/ExaTrkX/src/TorchTruthGraphMetricsHook.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -10,6 +10,8 @@
 
 #include "Acts/Plugins/ExaTrkX/detail/TensorVectorConversion.hpp"
 
+#include <algorithm>
+
 #include <torch/torch.h>
 
 namespace {
@@ -24,7 +26,8 @@ auto cantorize(std::vector<std::int64_t> edgeIndex,
     cantorEdgeIndex.emplace_back(*it, *std::next(it));
   }
 
-  std::sort(cantorEdgeIndex.begin(), cantorEdgeIndex.end());
+  std::ranges::sort(cantorEdgeIndex,
+                    std::less<Acts::detail::CantorEdge<std::int64_t>>{});
 
   auto new_end = std::unique(cantorEdgeIndex.begin(), cantorEdgeIndex.end());
   if (new_end != cantorEdgeIndex.end()) {
diff --git a/Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelToDetectorVolume.hpp b/Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelToDetectorVolume.hpp
index 33dfea7a7d5..b05287f1f88 100644
--- a/Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelToDetectorVolume.hpp
+++ b/Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelToDetectorVolume.hpp
@@ -15,12 +15,15 @@ class GeoShape;
 
 namespace Acts::GeoModel {
 
+// function converts GeoShape to Acts::Volume
+Volume convertVolume(const Transform3& trf, const GeoShape& shape);
+
 /// @brief Convert a GeoModel shape to a DetectorVolume
 ///
 /// @param shape the GeoModel shape
 /// @param transform the transform to be applied
 /// @return the DetectorVolume
-std::shared_ptr<Experimental::DetectorVolume> convertVolume(
+std::shared_ptr<Experimental::DetectorVolume> convertDetectorVolume(
     const GeometryContext& context, const GeoShape& shape,
     const std::string& name, const GeoTrf::Transform3D& transform,
     const std::vector<GeoModelSensitiveSurface>& sensitives);
diff --git a/Plugins/GeoModel/src/GeoModelBlueprintCreater.cpp b/Plugins/GeoModel/src/GeoModelBlueprintCreater.cpp
index 7495f8cca39..84a6476a8e4 100644
--- a/Plugins/GeoModel/src/GeoModelBlueprintCreater.cpp
+++ b/Plugins/GeoModel/src/GeoModelBlueprintCreater.cpp
@@ -17,6 +17,7 @@
 #include "Acts/Plugins/GeoModel/detail/GeoModelExtentHelper.hpp"
 #include "Acts/Utilities/BinningType.hpp"
 #include "Acts/Utilities/Enumerate.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Utilities/RangeXD.hpp"
 
 #include <boost/algorithm/string.hpp>
@@ -147,8 +148,7 @@ Acts::GeoModelBlueprintCreater::createNode(
       detail::GeoModelExentHelper::readBinningConstraints(entry.binnings);
   // Concatenate the binning constraints
   for (const auto& bc : binningConstraints) {
-    if (std::find(internalConstraints.begin(), internalConstraints.end(), bc) ==
-        internalConstraints.end()) {
+    if (!rangeContainsValue(internalConstraints, bc)) {
       internalConstraints.push_back(bc);
     }
   }
diff --git a/Plugins/GeoModel/src/GeoModelDetectorObjectFactory.cpp b/Plugins/GeoModel/src/GeoModelDetectorObjectFactory.cpp
index 762f4f93d6e..3952d93387a 100644
--- a/Plugins/GeoModel/src/GeoModelDetectorObjectFactory.cpp
+++ b/Plugins/GeoModel/src/GeoModelDetectorObjectFactory.cpp
@@ -155,37 +155,37 @@ void Acts::GeoModelDetectorObjectFactory::convertFpv(
   // get children
   std::vector<GeoChildNodeWithTrf> subvolumes =
       getChildrenWithRef(physVol, false);
-  if (!subvolumes.empty()) {
-    // vector containing all subvolumes to be converted to surfaces
-    std::vector<GeoChildNodeWithTrf> surfaces = findAllSubVolumes(physVol);
-    std::vector<GeoModelSensitiveSurface> sensitives;
-
-    for (const auto &surface : surfaces) {
-      const Transform3 &transform =
-          fpv->getAbsoluteTransform() * surface.transform;
-      convertSensitive(surface.volume, transform, sensitives);
-    }
-    cache.sensitiveSurfaces.insert(cache.sensitiveSurfaces.end(),
-                                   sensitives.begin(), sensitives.end());
-    if (convertBox(name)) {
-      const GeoLogVol *logVol =
-          physVol->getLogVol();  // get logVol for the shape of the volume
-      const GeoShape *shape = logVol->getShape();  // get shape
-      const Acts::Transform3 &fpvtransform = fpv->getAbsoluteTransform(nullptr);
-
-      // convert bounding boxes with surfaces inside
-      std::shared_ptr<Experimental::DetectorVolume> box =
-          Acts::GeoModel::convertVolume(gctx, *shape, name, fpvtransform,
-                                        sensitives);
-      cache.boundingBoxes.push_back(box);
-    }
-  } else {
+  // vector containing all subvolumes to be converted to surfaces
+  std::vector<GeoChildNodeWithTrf> surfaces = findAllSubVolumes(physVol);
+  std::vector<GeoModelSensitiveSurface> sensitives;
+
+  for (const auto &surface : surfaces) {
+    const Transform3 &transform =
+        fpv->getAbsoluteTransform() * surface.transform;
+    convertSensitive(surface.volume, transform, sensitives);
+  }
+  cache.sensitiveSurfaces.insert(cache.sensitiveSurfaces.end(),
+                                 sensitives.begin(), sensitives.end());
+  if (convertBox(name)) {
+    const GeoLogVol *logVol =
+        physVol->getLogVol();  // get logVol for the shape of the volume
+    const GeoShape *shape = logVol->getShape();  // get shape
+    const Acts::Transform3 &fpvtransform = fpv->getAbsoluteTransform(nullptr);
+
+    // convert bounding boxes with surfaces inside
+    std::shared_ptr<Experimental::DetectorVolume> box =
+        Acts::GeoModel::convertDetectorVolume(gctx, *shape, name, fpvtransform,
+                                              sensitives);
+    cache.boundingBoxes.push_back(box);
+  }
+  // If fpv has no subs and should not be converted to volume convert to surface
+  else if (subvolumes.empty()) {
     // convert fpvs to surfaces
     const Transform3 &transform = fpv->getAbsoluteTransform();
     convertSensitive(fpv, transform, cache.sensitiveSurfaces);
   }
 }
-// lambda to determine if object fits query
+// function to determine if object fits query
 bool Acts::GeoModelDetectorObjectFactory::matches(const std::string &name,
                                                   const PVConstLink &physvol) {
   if (m_cfg.nameList.empty() && m_cfg.materialList.empty()) {
diff --git a/Plugins/GeoModel/src/GeoModelToDetectorVolume.cpp b/Plugins/GeoModel/src/GeoModelToDetectorVolume.cpp
index bfe96c2c473..57961f3c4ba 100644
--- a/Plugins/GeoModel/src/GeoModelToDetectorVolume.cpp
+++ b/Plugins/GeoModel/src/GeoModelToDetectorVolume.cpp
@@ -29,61 +29,23 @@
 #include <GeoModelKernel/GeoTubs.h>
 
 namespace Acts::GeoModel {
-
-std::shared_ptr<Experimental::DetectorVolume> convertVolume(
-    const GeometryContext& context, const GeoShape& shape,
-    const std::string& name, const GeoTrf::Transform3D& transform,
-    const std::vector<GeoModelSensitiveSurface>& sensitives) {
-  // dummy volume for conversion with surfaces
-  std::vector<std::shared_ptr<Acts::Experimental::DetectorVolume>> a;
-
-  // type conversion from GeoModelSensitiveSurface to Surface
-  std::vector<std::shared_ptr<Surface>> sensSurfaces(sensitives.size());
-  std::transform(sensitives.begin(), sensitives.end(), sensSurfaces.begin(),
-                 [](const std::tuple<std::shared_ptr<GeoModelDetectorElement>,
-                                     std::shared_ptr<Surface>>& t) {
-                   return std::get<1>(t);
-                 });
-  auto portalGenerator = Experimental::defaultPortalAndSubPortalGenerator();
+Volume convertVolume(const Transform3& trf, const GeoShape& shape) {
+  std::shared_ptr<VolumeBounds> bounds;
+  GeoTrf::Transform3D newTrf = trf;
   if (shape.typeID() == GeoTube::getClassTypeID()) {
     const GeoTube* tube = dynamic_cast<const GeoTube*>(&shape);
-    std::shared_ptr<CylinderVolumeBounds> bounds =
-        std::make_shared<CylinderVolumeBounds>(tube->getRMin(), tube->getRMax(),
-                                               tube->getZHalfLength());
-    return Experimental::DetectorVolumeFactory::construct(
-        portalGenerator, context, name, transform, bounds,
-        Experimental::tryAllPortalsAndSurfaces());
+    bounds = std::make_shared<CylinderVolumeBounds>(
+        tube->getRMin(), tube->getRMax(), tube->getZHalfLength());
   } else if (shape.typeID() == GeoTubs::getClassTypeID()) {
     const GeoTubs* tubs = dynamic_cast<const GeoTubs*>(&shape);
-    std::shared_ptr<CylinderVolumeBounds> bounds =
-        std::make_shared<CylinderVolumeBounds>(tubs->getRMin(), tubs->getRMax(),
-                                               tubs->getZHalfLength(),
-                                               tubs->getDPhi() / 2);
-    GeoTrf::Transform3D newTransform =
-        transform * GeoTrf::RotateZ3D(tubs->getSPhi() + 0.5 * tubs->getDPhi());
-    return Experimental::DetectorVolumeFactory::construct(
-        portalGenerator, context, name, newTransform, bounds,
-        Experimental::tryAllPortalsAndSurfaces());
+    bounds = std::make_shared<CylinderVolumeBounds>(
+        tubs->getRMin(), tubs->getRMax(), tubs->getZHalfLength(),
+        tubs->getDPhi() / 2);
+    newTrf = trf * GeoTrf::RotateZ3D(tubs->getSPhi() + 0.5 * tubs->getDPhi());
   } else if (shape.typeID() == GeoBox::getClassTypeID()) {
     const GeoBox* box = dynamic_cast<const GeoBox*>(&shape);
-    std::shared_ptr<CuboidVolumeBounds> bounds =
-        std::make_shared<CuboidVolumeBounds>(box->getXHalfLength(),
-                                             box->getYHalfLength(),
-                                             box->getZHalfLength());
-    return Experimental::DetectorVolumeFactory::construct(
-        portalGenerator, context, name, transform, bounds, sensSurfaces, a,
-        Experimental::tryNoVolumes(), Experimental::tryAllPortalsAndSurfaces());
-  } else if (shape.typeID() == GeoSimplePolygonBrep::getClassTypeID()) {
-    const GeoSimplePolygonBrep* brep =
-        dynamic_cast<const GeoSimplePolygonBrep*>(&shape);
-    double xmin{0}, xmax{0}, ymin{0}, ymax{0}, zmin{0}, zmax{0};
-    brep->extent(xmin, ymin, zmin, xmax, ymax, zmax);
-    std::shared_ptr<CuboidVolumeBounds> bounds =
-        std::make_shared<CuboidVolumeBounds>(
-            (xmax - xmin) / 2, (ymax - ymin) / 2, (zmax - zmin) / 2);
-    return Experimental::DetectorVolumeFactory::construct(
-        portalGenerator, context, name, transform, bounds,
-        Experimental::tryAllPortalsAndSurfaces());
+    bounds = std::make_shared<CuboidVolumeBounds>(
+        box->getXHalfLength(), box->getYHalfLength(), box->getZHalfLength());
   } else if (shape.typeID() == GeoTrd::getClassTypeID()) {
     const GeoTrd* trd = dynamic_cast<const GeoTrd*>(&shape);
     double x1 = trd->getXHalfLength1();
@@ -95,93 +57,91 @@ std::shared_ptr<Experimental::DetectorVolume> convertVolume(
     if (y1 == y2) {
       if (x1 <= x2) {
         // y axis in ACTS is z axis in geomodel
-        std::shared_ptr<TrapezoidVolumeBounds> bounds =
-            std::make_shared<TrapezoidVolumeBounds>(x1, x2, z, y1);
+        bounds = std::make_shared<TrapezoidVolumeBounds>(x1, x2, z, y1);
         constexpr double rotationAngle = M_PI / 2;
-        GeoTrf::Transform3D newTransform =
-            transform * GeoTrf::RotateX3D(rotationAngle);
-        return Experimental::DetectorVolumeFactory::construct(
-            portalGenerator, context, name, newTransform, bounds, sensSurfaces,
-            a, Experimental::tryNoVolumes(),
-            Experimental::tryAllPortalsAndSurfaces());
+        newTrf = trf * GeoTrf::RotateX3D(rotationAngle);
       } else {
-        std::shared_ptr<TrapezoidVolumeBounds> bounds =
-            std::make_shared<TrapezoidVolumeBounds>(x2, x1, z, y1);
+        bounds = std::make_shared<TrapezoidVolumeBounds>(x2, x1, z, y1);
         constexpr double rotationAngle = M_PI;
-        GeoTrf::Transform3D newTransform = transform *
-                                           GeoTrf::RotateY3D(rotationAngle) *
-                                           GeoTrf::RotateZ3D(rotationAngle);
-        return Experimental::DetectorVolumeFactory::construct(
-            portalGenerator, context, name, newTransform, bounds, sensSurfaces,
-            a, Experimental::tryNoVolumes(),
-            Experimental::tryAllPortalsAndSurfaces());
+        newTrf = trf * GeoTrf::RotateY3D(rotationAngle) *
+                 GeoTrf::RotateZ3D(rotationAngle);
       }
     } else if (x1 == x2) {
       if (y1 < y2) {
-        std::shared_ptr<TrapezoidVolumeBounds> bounds =
-            std::make_shared<TrapezoidVolumeBounds>(y1, y2, z, x1);
+        bounds = std::make_shared<TrapezoidVolumeBounds>(y1, y2, z, x1);
         auto rotationAngle = M_PI / 2;
-        GeoTrf::Transform3D newTransform = transform *
-                                           GeoTrf::RotateZ3D(rotationAngle) *
-                                           GeoTrf::RotateX3D(rotationAngle);
-        return Experimental::DetectorVolumeFactory::construct(
-            portalGenerator, context, name, newTransform, bounds, sensSurfaces,
-            a, Experimental::tryNoVolumes(),
-            Experimental::tryAllPortalsAndSurfaces());
+        newTrf = trf * GeoTrf::RotateZ3D(rotationAngle) *
+                 GeoTrf::RotateX3D(rotationAngle);
       } else {
-        std::shared_ptr<TrapezoidVolumeBounds> bounds =
-            std::make_shared<TrapezoidVolumeBounds>(y2, y1, z, x1);
+        bounds = std::make_shared<TrapezoidVolumeBounds>(y2, y1, z, x1);
         auto rotationAngle = M_PI;
-        GeoTrf::Transform3D newTransform =
-            transform * GeoTrf::RotateX3D(rotationAngle) *
-            GeoTrf::RotateZ3D(rotationAngle / 2) *
-            GeoTrf::RotateX3D(rotationAngle / 2);
-        return Experimental::DetectorVolumeFactory::construct(
-            portalGenerator, context, name, newTransform, bounds, sensSurfaces,
-            a, Experimental::tryNoVolumes(),
-            Experimental::tryAllPortalsAndSurfaces());
+        newTrf = trf * GeoTrf::RotateX3D(rotationAngle) *
+                 GeoTrf::RotateZ3D(rotationAngle / 2) *
+                 GeoTrf::RotateX3D(rotationAngle / 2);
       }
     } else {
       throw std::runtime_error("FATAL: Translating GeoTrd to ACTS failed");
     }
-  } else if (shape.typeID() == GeoShapeUnion::getClassTypeID()) {
+  }
+
+  else if (shape.typeID() == GeoShapeUnion::getClassTypeID()) {
     const GeoShapeUnion* unionShape =
         dynamic_cast<const GeoShapeUnion*>(&shape);
     double xmin{0}, xmax{0}, ymin{0}, ymax{0}, zmin{0}, zmax{0};
     unionShape->extent(xmin, ymin, zmin, xmax, ymax, zmax);
-    std::shared_ptr<CuboidVolumeBounds> bounds =
-        std::make_shared<CuboidVolumeBounds>(
-            (xmax - xmin) / 2, (ymax - ymin) / 2, (zmax - zmin) / 2);
-    return Experimental::DetectorVolumeFactory::construct(
-        portalGenerator, context, name, transform, bounds,
-        Experimental::tryAllPortalsAndSurfaces());
+    bounds = std::make_shared<CuboidVolumeBounds>(
+        (xmax - xmin) / 2, (ymax - ymin) / 2, (zmax - zmin) / 2);
+  } else if (shape.typeID() == GeoShapeSubtraction::getClassTypeID()) {
+    // Go down the left side (opA) of the subtraction until we reach a normal
+    // shape
+    const GeoShapeSubtraction* subtractionShape =
+        dynamic_cast<const GeoShapeSubtraction*>(&shape);
+    const GeoShape* shapeA = subtractionShape->getOpA();
+    return convertVolume(trf, *shapeA);
   } else if (shape.typeID() == GeoShapeSubtraction::getClassTypeID()) {
     // Go down the left side (opA) of the subtraction until we reach a normal
     // shape
     const GeoShapeSubtraction* subtractionShape =
         dynamic_cast<const GeoShapeSubtraction*>(&shape);
     const GeoShape* shapeA = subtractionShape->getOpA();
-    return convertVolume(context, *shapeA, name, transform, sensitives);
+    return convertVolume(trf, *shapeA);
   } else if (shape.typeID() == GeoPcon::getClassTypeID()) {
     // Will change in future, get bounding box for now
     double xmin{0}, xmax{0}, ymin{0}, ymax{0}, zmin{0}, zmax{0};
     const GeoPcon* pcon = dynamic_cast<const GeoPcon*>(&shape);
     pcon->extent(xmin, ymin, zmin, xmax, ymax, zmax);
-    std::shared_ptr<CuboidVolumeBounds> bounds =
-        std::make_shared<CuboidVolumeBounds>(
-            (xmax - xmin) / 2, (ymax - ymin) / 2, (zmax - zmin) / 2);
-    return Experimental::DetectorVolumeFactory::construct(
-        portalGenerator, context, name, transform, bounds,
-        Experimental::tryAllPortalsAndSurfaces());
-  }
-  if (shape.typeID() == GeoShapeShift::getClassTypeID()) {
+    bounds = std::make_shared<CuboidVolumeBounds>(
+        (xmax - xmin) / 2, (ymax - ymin) / 2, (zmax - zmin) / 2);
+  } else if (shape.typeID() == GeoShapeShift::getClassTypeID()) {
     const GeoShapeShift* shiftShape =
         dynamic_cast<const GeoShapeShift*>(&shape);
     const GeoShape* shapeOp = shiftShape->getOp();
-    GeoTrf::Transform3D newTransform = transform * shiftShape->getX();
-    return convertVolume(context, *shapeOp, name, newTransform, sensitives);
+    newTrf = trf * shiftShape->getX();
+    return convertVolume(trf, *shapeOp);
+  } else {
+    throw std::runtime_error("FATAL: Unsupported GeoModel shape");
   }
-  throw std::runtime_error("FATAL: Unsupported GeoModel shape");
+  return Volume(newTrf, bounds);
+}
+
+std::shared_ptr<Experimental::DetectorVolume> convertDetectorVolume(
+    const GeometryContext& context, const GeoShape& shape,
+    const std::string& name, const GeoTrf::Transform3D& transform,
+    const std::vector<GeoModelSensitiveSurface>& sensitives) {
+  // type conversion from GeoModelSensitiveSurface to Surface
+  std::vector<std::shared_ptr<Surface>> sensSurfaces(sensitives.size());
+  std::transform(sensitives.begin(), sensitives.end(), sensSurfaces.begin(),
+                 [](const std::tuple<std::shared_ptr<GeoModelDetectorElement>,
+                                     std::shared_ptr<Surface>>& t) {
+                   return std::get<1>(t);
+                 });
+  auto portalGenerator = Experimental::defaultPortalAndSubPortalGenerator();
+  Volume vol = convertVolume(transform, shape);
+  return Experimental::DetectorVolumeFactory::construct(
+      portalGenerator, context, name, vol.transform(), vol.volumeBoundsPtr(),
+      sensSurfaces,
+      std::vector<std::shared_ptr<Acts::Experimental::DetectorVolume>>{},
+      Experimental::tryNoVolumes(), Experimental::tryAllPortalsAndSurfaces());
 }
 
 }  // namespace Acts::GeoModel
diff --git a/Plugins/GeoModel/src/detail/GeoIntersectionAnnulusConverter.cpp b/Plugins/GeoModel/src/detail/GeoIntersectionAnnulusConverter.cpp
index d3214e60bc7..4ea9e715120 100644
--- a/Plugins/GeoModel/src/detail/GeoIntersectionAnnulusConverter.cpp
+++ b/Plugins/GeoModel/src/detail/GeoIntersectionAnnulusConverter.cpp
@@ -16,6 +16,8 @@
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Surfaces/detail/AnnulusBoundsHelper.hpp"
 
+#include <algorithm>
+
 #include <GeoModelKernel/GeoFullPhysVol.h>
 #include <GeoModelKernel/GeoGenericTrap.h>
 #include <GeoModelKernel/GeoLogVol.h>
@@ -56,10 +58,9 @@ Acts::detail::GeoIntersectionAnnulusConverter::operator()(
         std::vector<Vector2> faceVertices(trapVertices.begin(),
                                           trapVertices.begin() + 4u);
         // to make sure they are in the right order
-        std::sort(faceVertices.begin(), faceVertices.end(),
-                  [](const auto& a, const auto& b) {
-                    return (VectorHelpers::phi(a) > VectorHelpers::phi(b));
-                  });
+        std::ranges::sort(faceVertices, std::greater{}, [](const auto& f) {
+          return (VectorHelpers::phi(f));
+        });
 
         // Turn them into global
         std::vector<Vector3> faceVertices3D;
diff --git a/Plugins/GeoModel/src/detail/GeoPolygonConverter.cpp b/Plugins/GeoModel/src/detail/GeoPolygonConverter.cpp
index e40d94ba1f6..a922d5f7ca4 100644
--- a/Plugins/GeoModel/src/detail/GeoPolygonConverter.cpp
+++ b/Plugins/GeoModel/src/detail/GeoPolygonConverter.cpp
@@ -17,6 +17,8 @@
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Surfaces/TrapezoidBounds.hpp"
 
+#include <algorithm>
+
 #include <GeoModelKernel/GeoBox.h>
 #include <GeoModelKernel/GeoFullPhysVol.h>
 #include <GeoModelKernel/GeoLogVol.h>
@@ -43,10 +45,7 @@ Acts::detail::GeoPolygonConverter::operator()(
     vertices.push_back({polygon.getXVertex(i), polygon.getYVertex(i)});
   }
   // sort based on the y-coordinate
-  std::sort(vertices.begin(), vertices.end(),
-            [](const std::vector<double>& a, const std::vector<double>& b) {
-              return a[1] < b[1];
-            });
+  std::ranges::sort(vertices, {}, [](const auto& v) { return v[1]; });
   if (nVertices == 4) {
     double hlxnegy = fabs(vertices[0][0] - vertices[1][0]) / 2;
     double hlxposy = fabs(vertices[2][0] - vertices[3][0]) / 2;
@@ -120,6 +119,6 @@ Acts::detail::GeoPolygonConverter::operator()(
   } else {
     throw std::runtime_error("GeoSimplePolygonBrep with " +
                              std::to_string(nVertices) +
-                             " can not be converted");
+                             " vertices can not be converted");
   }
 }
diff --git a/Plugins/Json/src/AmbiguityConfigJsonConverter.cpp b/Plugins/Json/src/AmbiguityConfigJsonConverter.cpp
index 2542a237b52..3a4c0f44a6f 100644
--- a/Plugins/Json/src/AmbiguityConfigJsonConverter.cpp
+++ b/Plugins/Json/src/AmbiguityConfigJsonConverter.cpp
@@ -35,15 +35,26 @@ void from_json(const nlohmann::json& j, ConfigPair& p) {
 
     detectorConfig.sharedHitsFlag = value["sharedHitsFlag"];
 
-    std::vector<double> factorHits = value["factorHits"];
-    std::vector<double> factorHoles = value["factorHoles"];
+    const std::vector<double>& goodHits = value["goodHits"];
+    const std::vector<double>& goodHoles = value["goodHoles"];
 
-    for (auto factor : factorHits) {
-      detectorConfig.factorHits.push_back(factor);
+    const std::vector<double>& fakeHits = value["fakeHits"];
+    const std::vector<double>& fakeHoles = value["fakeHoles"];
+
+    if (goodHits.size() != fakeHits.size()) {
+      throw std::invalid_argument("goodHits and FakeHits size mismatch");
+    }
+
+    for (std::size_t i = 0; i < goodHits.size(); i++) {
+      detectorConfig.factorHits.push_back(goodHits[i] / fakeHits[i]);
+    }
+
+    if (goodHoles.size() != fakeHoles.size()) {
+      throw std::invalid_argument("goodHoles and FakeHoles size mismatch");
     }
 
-    for (auto factor : factorHoles) {
-      detectorConfig.factorHoles.push_back(factor);
+    for (std::size_t i = 0; i < goodHoles.size(); i++) {
+      detectorConfig.factorHoles.push_back(goodHoles[i] / fakeHoles[i]);
     }
 
     detectorConfigs.push_back(detectorConfig);
diff --git a/Plugins/Json/src/DetectorJsonConverter.cpp b/Plugins/Json/src/DetectorJsonConverter.cpp
index 0dd8d7520f8..80b737b3447 100644
--- a/Plugins/Json/src/DetectorJsonConverter.cpp
+++ b/Plugins/Json/src/DetectorJsonConverter.cpp
@@ -44,7 +44,7 @@ nlohmann::json Acts::DetectorJsonConverter::toJson(
   for (const auto* volume : detector.volumes()) {
     nSurfaces += volume->surfaces().size();
     for (const auto& portal : volume->portals()) {
-      if (std::find(portals.begin(), portals.end(), portal) == portals.end()) {
+      if (!rangeContainsValue(portals, portal)) {
         portals.push_back(portal);
       }
     }
diff --git a/Plugins/Json/src/MaterialMapJsonConverter.cpp b/Plugins/Json/src/MaterialMapJsonConverter.cpp
index afa1cec1ad5..689d1d1e9ab 100644
--- a/Plugins/Json/src/MaterialMapJsonConverter.cpp
+++ b/Plugins/Json/src/MaterialMapJsonConverter.cpp
@@ -176,8 +176,8 @@ Acts::SurfaceAndMaterialWithContext defaultSurfaceMaterial(
 Acts::TrackingVolumeAndMaterial defaultVolumeMaterial(
     const Acts::TrackingVolume* volume) {
   Acts::BinUtility bUtility;
-  if (volume->volumeMaterialSharedPtr() != nullptr) {
-    return {volume, volume->volumeMaterialSharedPtr()};
+  if (volume->volumeMaterialPtr() != nullptr) {
+    return {volume, volume->volumeMaterialPtr()};
   }
   // Check which type of bound is associated to the volume
   auto cyBounds = dynamic_cast<const Acts::CylinderVolumeBounds*>(
diff --git a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp
index a4c71eb2c7c..f04cf6d7c6a 100644
--- a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp
+++ b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp
@@ -15,6 +15,7 @@
 #include "Acts/EventData/detail/DynamicColumn.hpp"
 #include "Acts/Plugins/Podio/PodioDynamicColumns.hpp"
 #include "Acts/Plugins/Podio/PodioUtil.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 #include "ActsPodioEdm/Surface.h"
 
 #pragma GCC diagnostic push
@@ -339,8 +340,7 @@ class ConstPodioTrackContainer : public PodioTrackContainerBase {
     std::string tracksKey = "tracks" + s;
 
     std::vector<std::string> available = frame.getAvailableCollections();
-    if (std::find(available.begin(), available.end(), tracksKey) ==
-        available.end()) {
+    if (!rangeContainsValue(available, tracksKey)) {
       throw std::runtime_error{"Track collection '" + tracksKey +
                                "' not found in frame"};
     }
diff --git a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp
index 60951942618..590d62a8d87 100644
--- a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp
+++ b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp
@@ -224,20 +224,17 @@ class ConstPodioTrackStateContainer final
     std::string paramsKey = "trackStateParameters" + s;
     std::string jacsKey = "trackStateJacobians" + s;
 
-    if (std::find(available.begin(), available.end(), trackStatesKey) ==
-        available.end()) {
+    if (!rangeContainsValue(available, trackStatesKey)) {
       throw std::runtime_error{"Track state collection '" + trackStatesKey +
                                "' not found in frame"};
     }
 
-    if (std::find(available.begin(), available.end(), paramsKey) ==
-        available.end()) {
+    if (!rangeContainsValue(available, paramsKey)) {
       throw std::runtime_error{"Track state parameters collection '" +
                                paramsKey + "' not found in frame"};
     }
 
-    if (std::find(available.begin(), available.end(), jacsKey) ==
-        available.end()) {
+    if (!rangeContainsValue(available, jacsKey)) {
       throw std::runtime_error{"Track state jacobian collection '" + jacsKey +
                                "' not found in frame"};
     }
diff --git a/Tests/CommonHelpers/Acts/Tests/CommonHelpers/BenchmarkTools.hpp b/Tests/CommonHelpers/Acts/Tests/CommonHelpers/BenchmarkTools.hpp
index eea10efad4c..f04979e03b8 100644
--- a/Tests/CommonHelpers/Acts/Tests/CommonHelpers/BenchmarkTools.hpp
+++ b/Tests/CommonHelpers/Acts/Tests/CommonHelpers/BenchmarkTools.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2019-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2019-2024 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
@@ -233,7 +233,7 @@ struct MicroBenchmarkResult {
   // Sorted benchmark run times, used for computing outlier-robust statistics
   std::vector<Duration> sortedRunTimes() const {
     std::vector<Duration> sorted_timings = run_timings;
-    std::sort(sorted_timings.begin(), sorted_timings.end());
+    std::ranges::sort(sorted_timings);
     return sorted_timings;
   }
 
diff --git a/Tests/IntegrationTests/Fatras/FatrasSimulationTests.cpp b/Tests/IntegrationTests/Fatras/FatrasSimulationTests.cpp
index 6355f804ce0..69dc85d9fd7 100644
--- a/Tests/IntegrationTests/Fatras/FatrasSimulationTests.cpp
+++ b/Tests/IntegrationTests/Fatras/FatrasSimulationTests.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020-2021 CERN for the benefit of the Acts project
+// Copyright (C) 2020-2024 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
@@ -123,10 +123,8 @@ const auto dataset =
 // helper functions for tests
 template <typename Container>
 void sortByParticleId(Container& container) {
-  std::sort(container.begin(), container.end(),
-            [](const auto& lhs, const auto& rhs) {
-              return lhs.particleId() < rhs.particleId();
-            });
+  std::ranges::sort(container, std::less{},
+                    [](const auto& c) { return c.particleId(); });
 }
 template <typename Container>
 bool areParticleIdsUnique(const Container& sortedByParticleId) {
diff --git a/Tests/IntegrationTests/Legacy/ATLSeedingIntegrationTest.cpp b/Tests/IntegrationTests/Legacy/ATLSeedingIntegrationTest.cpp
index 0e6c730bfac..20876537961 100644
--- a/Tests/IntegrationTests/Legacy/ATLSeedingIntegrationTest.cpp
+++ b/Tests/IntegrationTests/Legacy/ATLSeedingIntegrationTest.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018 CERN for the benefit of the Acts project
+// Copyright (C) 2018-2024 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
@@ -137,8 +137,8 @@ BOOST_AUTO_TEST_CASE(number_of_seeds_correct_) {
 
   // sorting required for set_difference call. sorting assumes space points
   // inside seed are already sorted.
-  std::sort(refVec.begin(), refVec.end(), seedComparator());
-  std::sort(seedVec.begin(), seedVec.end(), seedComparator());
+  std::ranges::sort(refVec, seedComparator());
+  std::ranges::sort(seedVec, seedComparator());
 
   // difference between reference and result shows if results exactly the same
   // (i.e. difference is 0)
diff --git a/Tests/IntegrationTests/NavigatorConsistency.cpp b/Tests/IntegrationTests/NavigatorConsistency.cpp
index c4a380a5d3f..b8de4d6b8d1 100644
--- a/Tests/IntegrationTests/NavigatorConsistency.cpp
+++ b/Tests/IntegrationTests/NavigatorConsistency.cpp
@@ -23,6 +23,8 @@
 #include "Acts/Tests/CommonHelpers/CylindricalTrackingGeometry.hpp"
 #include "Acts/Utilities/VectorHelpers.hpp"
 
+#include <algorithm>
+
 namespace bdata = boost::unit_test::data;
 using namespace Acts::UnitLiterals;
 using Acts::VectorHelpers::perp;
@@ -130,7 +132,7 @@ void runSelfConsistencyTest(const propagator_t& prop,
 
   // forward-backward compatibility test
   {
-    std::reverse(bwdSurfaces.begin(), bwdSurfaces.end());
+    std::ranges::reverse(bwdSurfaces);
     BOOST_CHECK_EQUAL_COLLECTIONS(bwdSurfaces.begin(), bwdSurfaces.end(),
                                   fwdSurfaces.begin(), fwdSurfaces.end());
   }
@@ -235,7 +237,7 @@ void runSelfConsistencyTest(const propagator_t& prop,
 
   // TODO backward-backward step compatibility test
 
-  std::reverse(bwdStepSurfaces.begin(), bwdStepSurfaces.end());
+  std::ranges::reverse(bwdStepSurfaces);
   BOOST_CHECK_EQUAL_COLLECTIONS(bwdStepSurfaces.begin(), bwdStepSurfaces.end(),
                                 fwdStepSurfaces.begin(), fwdStepSurfaces.end());
 }
diff --git a/Tests/IntegrationTests/PropagationDenseConstant.cpp b/Tests/IntegrationTests/PropagationDenseConstant.cpp
index c27e38088b4..e95b0bc01a1 100644
--- a/Tests/IntegrationTests/PropagationDenseConstant.cpp
+++ b/Tests/IntegrationTests/PropagationDenseConstant.cpp
@@ -16,7 +16,7 @@
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
 #include "Acts/Material/HomogeneousVolumeMaterial.hpp"
 #include "Acts/Propagator/EigenStepper.hpp"
-#include "Acts/Propagator/EigenStepperDenseEnvironmentExtension.hpp"
+#include "Acts/Propagator/EigenStepperDenseExtension.hpp"
 #include "Acts/Propagator/Navigator.hpp"
 #include "Acts/Propagator/Propagator.hpp"
 #include "Acts/Propagator/RiddersPropagator.hpp"
@@ -34,7 +34,7 @@ namespace ds = ActsTests::PropagationDatasets;
 using namespace Acts::UnitLiterals;
 
 using MagneticField = Acts::ConstantBField;
-using Stepper = Acts::EigenStepper<Acts::EigenStepperDenseEnvironmentExtension>;
+using Stepper = Acts::EigenStepper<Acts::EigenStepperDenseExtension>;
 using Propagator = Acts::Propagator<Stepper, Acts::Navigator>;
 using RiddersPropagator = Acts::RiddersPropagator<Propagator>;
 
diff --git a/Tests/UnitTests/Core/Clusterization/ClusterizationTests1D.cpp b/Tests/UnitTests/Core/Clusterization/ClusterizationTests1D.cpp
index 83423852791..3ab655ade8d 100644
--- a/Tests/UnitTests/Core/Clusterization/ClusterizationTests1D.cpp
+++ b/Tests/UnitTests/Core/Clusterization/ClusterizationTests1D.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -54,7 +54,7 @@ bool clHashComp(const Cluster1D& left, const Cluster1D& right) {
 }
 
 void hash(Cluster1D& cl) {
-  std::sort(cl.cells.begin(), cl.cells.end(), cellComp);
+  std::ranges::sort(cl.cells, cellComp);
   cl.hash = 0;
   for (const Cell1D& c : cl.cells) {
     boost::hash_combine(cl.hash, c.col);
@@ -117,8 +117,8 @@ BOOST_AUTO_TEST_CASE(Grid_1D_rand) {
       hash(cl);
     }
 
-    std::sort(clusters.begin(), clusters.end(), clHashComp);
-    std::sort(newCls.begin(), newCls.end(), clHashComp);
+    std::ranges::sort(clusters, clHashComp);
+    std::ranges::sort(newCls, clHashComp);
 
     BOOST_CHECK_EQUAL(clusters.size(), newCls.size());
     for (std::size_t i = 0; i < clusters.size(); i++) {
diff --git a/Tests/UnitTests/Core/Clusterization/ClusterizationTests2D.cpp b/Tests/UnitTests/Core/Clusterization/ClusterizationTests2D.cpp
index e850d213551..6a2808d90ba 100644
--- a/Tests/UnitTests/Core/Clusterization/ClusterizationTests2D.cpp
+++ b/Tests/UnitTests/Core/Clusterization/ClusterizationTests2D.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -9,6 +9,7 @@
 #include <boost/test/unit_test.hpp>
 
 #include "Acts/Clusterization/Clusterization.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 
 #include <algorithm>
 #include <array>
@@ -113,7 +114,7 @@ void clusterAddCell(Cluster2D& cl, const Cell2D& cell) {
 }
 
 void hash(Cluster2D& cl) {
-  std::sort(cl.cells.begin(), cl.cells.end(), cellComp);
+  std::ranges::sort(cl.cells, cellComp);
   cl.hash = 0;
   for (const Cell2D& c : cl.cells) {
     boost::hash_combine(cl.hash, c.col);
@@ -133,7 +134,7 @@ void genclusterw(int x, int y, int x0, int y0, int x1, int y1,
   auto maybe_add = [&](int x_, int y_) {
     Cell2D c(x_, y_);
     if (std::uniform_real_distribution<double>()(rng) < startp &&
-        std::find(cells.begin(), cells.end(), c) == cells.end()) {
+        !rangeContainsValue(cells, c)) {
       cells.push_back(c);
       add.push_back(c);
     }
@@ -236,8 +237,8 @@ BOOST_AUTO_TEST_CASE(Grid_2D_rand) {
       hash(cl);
     }
 
-    std::sort(cls.begin(), cls.end(), clHashComp);
-    std::sort(newCls.begin(), newCls.end(), clHashComp);
+    std::ranges::sort(cls, clHashComp);
+    std::ranges::sort(newCls, clHashComp);
 
     BOOST_CHECK_EQUAL(cls.size(), newCls.size());
     for (std::size_t i = 0; i < cls.size(); i++) {
diff --git a/Tests/UnitTests/Core/Detector/CuboidalDetectorFromBlueprintTests.cpp b/Tests/UnitTests/Core/Detector/CuboidalDetectorFromBlueprintTests.cpp
index aba5426de06..9a194dbef1b 100644
--- a/Tests/UnitTests/Core/Detector/CuboidalDetectorFromBlueprintTests.cpp
+++ b/Tests/UnitTests/Core/Detector/CuboidalDetectorFromBlueprintTests.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -26,6 +26,7 @@
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/BinningData.hpp"
 
+#include <algorithm>
 #include <fstream>
 
 class SurfaceBuilder : public Acts::Experimental::IInternalStructureBuilder {
@@ -363,7 +364,7 @@ BOOST_AUTO_TEST_CASE(CuboidalDetectorFromBlueprintTest) {
     portals.insert(portals.end(), volume->portals().begin(),
                    volume->portals().end());
   }
-  std::sort(portals.begin(), portals.end());
+  std::ranges::sort(portals);
   auto last = std::unique(portals.begin(), portals.end());
   portals.erase(last, portals.end());
   BOOST_CHECK_EQUAL(portals.size(), 19u);
diff --git a/Tests/UnitTests/Core/EventData/TrackTests.cpp b/Tests/UnitTests/Core/EventData/TrackTests.cpp
index 698ea737d2a..db8863e5e6b 100644
--- a/Tests/UnitTests/Core/EventData/TrackTests.cpp
+++ b/Tests/UnitTests/Core/EventData/TrackTests.cpp
@@ -24,6 +24,7 @@
 #include "Acts/Utilities/HashedString.hpp"
 #include "Acts/Utilities/Holders.hpp"
 
+#include <algorithm>
 #include <cstddef>
 #include <iterator>
 #include <memory>
@@ -441,7 +442,7 @@ BOOST_AUTO_TEST_CASE(ForwardIteration) {
     indices.push_back(ts.index());
   }
 
-  std::reverse(indices.begin(), indices.end());
+  std::ranges::reverse(indices);
 
   std::vector<IndexType> act;
   for (auto ts : t.trackStates()) {
diff --git a/Tests/UnitTests/Core/EventData/TrackTestsExtra.cpp b/Tests/UnitTests/Core/EventData/TrackTestsExtra.cpp
index 2f7df54f055..8dd12203991 100644
--- a/Tests/UnitTests/Core/EventData/TrackTestsExtra.cpp
+++ b/Tests/UnitTests/Core/EventData/TrackTestsExtra.cpp
@@ -16,6 +16,7 @@
 #include "Acts/Surfaces/PlaneSurface.hpp"
 #include "Acts/Utilities/Zip.hpp"
 
+#include <algorithm>
 #include <numeric>
 
 using namespace Acts;
@@ -421,7 +422,7 @@ BOOST_AUTO_TEST_CASE(ReverseTrackStates) {
   // reverse with jacobians
   t.reverseTrackStates(true);
 
-  std::reverse(exp.begin(), exp.end());
+  std::ranges::reverse(exp);
   std::rotate(exp.rbegin(), std::next(exp.rbegin()), exp.rend());
 
   for (const auto [e, ts] : zip(exp, t.trackStates())) {
diff --git a/Tests/UnitTests/Core/Geometry/GenericCuboidVolumeBoundsTests.cpp b/Tests/UnitTests/Core/Geometry/GenericCuboidVolumeBoundsTests.cpp
index 2fc5a25ca85..b62758ec815 100644
--- a/Tests/UnitTests/Core/Geometry/GenericCuboidVolumeBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Geometry/GenericCuboidVolumeBoundsTests.cpp
@@ -191,7 +191,7 @@ BOOST_AUTO_TEST_CASE(bounding_box_creation) {
   BOOST_CHECK_EQUAL(boundValues.size(), 24u);
 
   auto bValueArrray =
-      to_array<GenericCuboidVolumeBounds::BoundValues::eSize, ActsScalar>(
+      toArray<GenericCuboidVolumeBounds::BoundValues::eSize, ActsScalar>(
           boundValues);
   GenericCuboidVolumeBounds gcvbCopy(bValueArrray);
   BOOST_CHECK_EQUAL(gcvbCopy.values().size(), 24u);
diff --git a/Tests/UnitTests/Core/Geometry/LayerCreatorTests.cpp b/Tests/UnitTests/Core/Geometry/LayerCreatorTests.cpp
index fcf862ef126..deb72b97159 100644
--- a/Tests/UnitTests/Core/Geometry/LayerCreatorTests.cpp
+++ b/Tests/UnitTests/Core/Geometry/LayerCreatorTests.cpp
@@ -33,6 +33,7 @@
 #include <array>
 #include <cmath>
 #include <cstddef>
+#include <fstream>
 #include <iomanip>
 #include <iostream>
 #include <memory>
diff --git a/Tests/UnitTests/Core/Geometry/ProtoLayerHelperTests.cpp b/Tests/UnitTests/Core/Geometry/ProtoLayerHelperTests.cpp
index e316b2f29aa..d8ba622257e 100644
--- a/Tests/UnitTests/Core/Geometry/ProtoLayerHelperTests.cpp
+++ b/Tests/UnitTests/Core/Geometry/ProtoLayerHelperTests.cpp
@@ -62,7 +62,7 @@ BOOST_AUTO_TEST_CASE(ProtoLayerHelperTests) {
                             layerSurfaces.end());
   }
 
-  ViewConfig unsorted({252, 160, 0});
+  ViewConfig unsorted{.color = {252, 160, 0}};
   for (auto& sf : cylinderSurfaces) {
     GeometryView3D::drawSurface(objVis, *sf, tgContext, Transform3::Identity(),
                                 unsorted);
@@ -78,16 +78,16 @@ BOOST_AUTO_TEST_CASE(ProtoLayerHelperTests) {
 
   BOOST_CHECK_EQUAL(radialLayers.size(), 4);
 
-  std::vector<ColorRGB> sortedColors = {{102, 204, 255},
-                                        {102, 255, 153},
-                                        {255, 204, 102},
-                                        {204, 102, 0},
-                                        {278, 123, 55}};
+  std::vector<Color> sortedColors = {{102, 204, 255},
+                                     {102, 255, 153},
+                                     {255, 204, 102},
+                                     {204, 102, 0},
+                                     {278, 123, 55}};
 
   std::size_t il = 0;
   for (auto& layer : radialLayers) {
     for (auto& sf : layer.surfaces()) {
-      ViewConfig sorted(sortedColors[il]);
+      ViewConfig sorted{.color = sortedColors[il]};
       GeometryView3D::drawSurface(objVis, *sf, tgContext,
                                   Transform3::Identity(), sorted);
     }
@@ -136,7 +136,7 @@ BOOST_AUTO_TEST_CASE(ProtoLayerHelperTests) {
   il = 0;
   for (auto& layer : discLayersZ) {
     for (auto& sf : layer.surfaces()) {
-      ViewConfig ViewConfig(sortedColors[il]);
+      ViewConfig ViewConfig{.color = sortedColors[il]};
       GeometryView3D::drawSurface(objVis, *sf, tgContext,
                                   Transform3::Identity(), ViewConfig);
     }
@@ -184,7 +184,7 @@ BOOST_AUTO_TEST_CASE(ProtoLayerHelperTests) {
       ProtoLayerHelper::SortingConfig(BinningValue::binR, 1.));
   BOOST_CHECK_EQUAL(rSorted.size(), 3);
 
-  ColorRGB dColor = {0, 0, 0};
+  Color dColor = {0, 0, 0};
 
   int ir = 0;
   for (auto& rBatch : rSorted) {
diff --git a/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp b/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
index fc7175aaf85..bea4039ad3d 100644
--- a/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
@@ -35,7 +35,7 @@
 #include "Acts/Propagator/ConstrainedStep.hpp"
 #include "Acts/Propagator/EigenStepper.hpp"
 #include "Acts/Propagator/EigenStepperDefaultExtension.hpp"
-#include "Acts/Propagator/EigenStepperDenseEnvironmentExtension.hpp"
+#include "Acts/Propagator/EigenStepperDenseExtension.hpp"
 #include "Acts/Propagator/EigenStepperError.hpp"
 #include "Acts/Propagator/MaterialInteractor.hpp"
 #include "Acts/Propagator/Navigator.hpp"
@@ -537,7 +537,7 @@ BOOST_AUTO_TEST_CASE(eigen_stepper_test) {
 }
 
 /// @brief This function tests the EigenStepper with the EigenStepperDefaultExtension and
-/// the EigenStepperDenseEnvironmentExtension. The focus of this tests lies in
+/// the EigenStepperDenseExtension. The focus of this tests lies in
 /// the choosing of the right extension for the individual use case. This is
 /// performed with three different detectors:
 /// a) Pure vacuum -> DefaultExtension needs to act
@@ -577,7 +577,7 @@ BOOST_AUTO_TEST_CASE(step_extension_vacuum_test) {
   const CurvilinearTrackParameters sbtp(Vector4::Zero(), startDir, 1_e / 1_GeV,
                                         cov, ParticleHypothesis::pion());
 
-  using Stepper = EigenStepper<EigenStepperDenseEnvironmentExtension>;
+  using Stepper = EigenStepper<EigenStepperDenseExtension>;
   using Propagator = Propagator<Stepper, Navigator>;
   using PropagatorOptions =
       Propagator::Options<ActionList<StepCollector>, AbortList<EndOfWorld>>;
@@ -609,7 +609,7 @@ BOOST_AUTO_TEST_CASE(step_extension_vacuum_test) {
     CHECK_CLOSE_ABS(mom, startMom, 1_keV);
   }
 
-  using DefStepper = EigenStepper<EigenStepperDenseEnvironmentExtension>;
+  using DefStepper = EigenStepper<EigenStepperDenseExtension>;
   using DefPropagator = Acts::Propagator<DefStepper, Navigator>;
   using DefPropagatorOptions =
       DefPropagator::Options<ActionList<StepCollector>, AbortList<EndOfWorld>>;
@@ -672,7 +672,7 @@ BOOST_AUTO_TEST_CASE(step_extension_material_test) {
   const CurvilinearTrackParameters sbtp(Vector4::Zero(), startDir, 1_e / 5_GeV,
                                         cov, ParticleHypothesis::pion());
 
-  using Stepper = EigenStepper<EigenStepperDenseEnvironmentExtension>;
+  using Stepper = EigenStepper<EigenStepperDenseExtension>;
   using Propagator = Propagator<Stepper, Navigator>;
   using PropagatorOptions =
       Propagator::Options<ActionList<StepCollector>, AbortList<EndOfWorld>>;
@@ -713,7 +713,7 @@ BOOST_AUTO_TEST_CASE(step_extension_material_test) {
     }
   }
 
-  using DenseStepper = EigenStepper<EigenStepperDenseEnvironmentExtension>;
+  using DenseStepper = EigenStepper<EigenStepperDenseExtension>;
   using DensePropagator = Acts::Propagator<DenseStepper, Navigator>;
   using DensePropagatorOptions =
       DensePropagator::Options<ActionList<StepCollector>,
@@ -818,7 +818,7 @@ BOOST_AUTO_TEST_CASE(step_extension_vacmatvac_test) {
                                   1_e / 5_GeV, Covariance::Identity(),
                                   ParticleHypothesis::pion());
 
-  using Stepper = EigenStepper<EigenStepperDenseEnvironmentExtension>;
+  using Stepper = EigenStepper<EigenStepperDenseExtension>;
   using Propagator = Acts::Propagator<Stepper, Navigator>;
   using PropagatorOptions =
       Propagator::Options<ActionList<StepCollector>, AbortList<EndOfWorld>>;
@@ -872,7 +872,7 @@ BOOST_AUTO_TEST_CASE(step_extension_vacmatvac_test) {
   // Build launcher through vacuum
   // Set options for propagator
 
-  using DefStepper = EigenStepper<EigenStepperDenseEnvironmentExtension>;
+  using DefStepper = EigenStepper<EigenStepperDenseExtension>;
   using DefPropagator = Acts::Propagator<DefStepper, Navigator>;
   using DefPropagatorOptions =
       DefPropagator::Options<ActionList<StepCollector>, AbortList<EndOfWorld>>;
@@ -922,7 +922,7 @@ BOOST_AUTO_TEST_CASE(step_extension_vacmatvac_test) {
   // Set initial parameters for the particle track by using the result of the
   // first volume
 
-  using DenseStepper = EigenStepper<EigenStepperDenseEnvironmentExtension>;
+  using DenseStepper = EigenStepper<EigenStepperDenseExtension>;
   using DensePropagator = Acts::Propagator<DenseStepper, Navigator>;
   using DensePropagatorOptions =
       DensePropagator::Options<ActionList<StepCollector>,
@@ -1052,7 +1052,7 @@ BOOST_AUTO_TEST_CASE(step_extension_trackercalomdt_test) {
                                   1_e / 1_GeV, Covariance::Identity(),
                                   ParticleHypothesis::pion());
 
-  using Stepper = EigenStepper<EigenStepperDenseEnvironmentExtension>;
+  using Stepper = EigenStepper<EigenStepperDenseExtension>;
   using Propagator = Acts::Propagator<Stepper, Navigator>;
   using PropagatorOptions =
       Propagator::Options<ActionList<StepCollector, MaterialInteractor>,
diff --git a/Tests/UnitTests/Core/Propagator/NavigatorTests.cpp b/Tests/UnitTests/Core/Propagator/NavigatorTests.cpp
index 1e4afdf3b6c..92e7f636aae 100644
--- a/Tests/UnitTests/Core/Propagator/NavigatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/NavigatorTests.cpp
@@ -26,6 +26,7 @@
 #include "Acts/Propagator/Navigator.hpp"
 #include "Acts/Propagator/StepperConcept.hpp"
 #include "Acts/Surfaces/BoundaryTolerance.hpp"
+#include "Acts/Surfaces/PerigeeSurface.hpp"
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Tests/CommonHelpers/CylindricalTrackingGeometry.hpp"
 #include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
@@ -392,7 +393,9 @@ BOOST_AUTO_TEST_CASE(Navigator_status_methods) {
                                            nullptr, nullptr, nullptr, nullptr,
                                            nullptr));
     ACTS_INFO("        iii) Because the target surface is reached");
-    const Surface* startSurf = tGeometry->getBeamline();
+
+    auto beamline = Surface::makeShared<PerigeeSurface>(Vector3::Zero());
+    const Surface* startSurf = beamline.get();
     state.stepping.pos4.segment<3>(Acts::ePos0) =
         startSurf->center(state.geoContext);
     const Surface* targetSurf = startSurf;
diff --git a/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp b/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
index d53ae87eb96..4dbdc303771 100644
--- a/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
@@ -24,7 +24,7 @@
 #include "Acts/Propagator/ActionList.hpp"
 #include "Acts/Propagator/ConstrainedStep.hpp"
 #include "Acts/Propagator/EigenStepper.hpp"
-#include "Acts/Propagator/EigenStepperDenseEnvironmentExtension.hpp"
+#include "Acts/Propagator/EigenStepperDenseExtension.hpp"
 #include "Acts/Propagator/Navigator.hpp"
 #include "Acts/Propagator/Propagator.hpp"
 #include "Acts/Propagator/StandardAborters.hpp"
@@ -476,7 +476,7 @@ BOOST_AUTO_TEST_CASE(BasicPropagatorInterface) {
     BOOST_CHECK(resultCurv.ok());
   }
 
-  EigenStepper<EigenStepperDenseEnvironmentExtension> denseEigenStepper{field};
+  EigenStepper<EigenStepperDenseExtension> denseEigenStepper{field};
 
   {
     Propagator propagator{denseEigenStepper, navigator};
diff --git a/Tests/UnitTests/Core/Seeding/CandidatesForMiddleSpTests.cpp b/Tests/UnitTests/Core/Seeding/CandidatesForMiddleSpTests.cpp
index 3d8b672cb45..e6068ed248c 100644
--- a/Tests/UnitTests/Core/Seeding/CandidatesForMiddleSpTests.cpp
+++ b/Tests/UnitTests/Core/Seeding/CandidatesForMiddleSpTests.cpp
@@ -10,6 +10,7 @@
 
 #include "Acts/Seeding/CandidatesForMiddleSp.hpp"
 
+#include <algorithm>
 #include <limits>
 #include <vector>
 
@@ -145,16 +146,16 @@ BOOST_AUTO_TEST_CASE(CandidatesForMiddleSpObject) {
     BOOST_CHECK(storagedValues[i].weight >= storagedValues[i + 1].weight);
   }
 
-  std::sort(
-      storagedValues.begin(), storagedValues.end(),
+  std::ranges::sort(
+      storagedValues,
       Acts::CandidatesForMiddleSp<UnitTestSpacePoint>::ascendingByQuality);
   // check values are sorted properly
   for (std::size_t i(0); i < storagedValues.size() - 1; ++i) {
     BOOST_CHECK(storagedValues[i].weight <= storagedValues[i + 1].weight);
   }
 
-  std::sort(
-      storagedValues.begin(), storagedValues.end(),
+  std::ranges::sort(
+      storagedValues,
       Acts::CandidatesForMiddleSp<UnitTestSpacePoint>::descendingByQuality);
   // check values are sorted properly
   for (std::size_t i(0); i < storagedValues.size() - 1; ++i) {
diff --git a/Tests/UnitTests/Core/TrackFitting/GsfMixtureReductionTests.cpp b/Tests/UnitTests/Core/TrackFitting/GsfMixtureReductionTests.cpp
index 6a8b1ff7cd4..064874a1b75 100644
--- a/Tests/UnitTests/Core/TrackFitting/GsfMixtureReductionTests.cpp
+++ b/Tests/UnitTests/Core/TrackFitting/GsfMixtureReductionTests.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022-2023 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -146,9 +146,8 @@ BOOST_AUTO_TEST_CASE(test_mixture_reduction) {
 
   BOOST_CHECK_EQUAL(cmps.size(), 2);
 
-  std::sort(cmps.begin(), cmps.end(), [](const auto &a, const auto &b) {
-    return a.boundPars[eBoundQOverP] < b.boundPars[eBoundQOverP];
-  });
+  std::ranges::sort(cmps, {},
+                    [](const auto &c) { return c.boundPars[eBoundQOverP]; });
   BOOST_CHECK_CLOSE(cmps[0].boundPars[eBoundQOverP], 1.0_GeV, 1.e-8);
   BOOST_CHECK_CLOSE(cmps[1].boundPars[eBoundQOverP], 4.0_GeV, 1.e-8);
 
@@ -182,8 +181,7 @@ BOOST_AUTO_TEST_CASE(test_weight_cut_reduction) {
   Acts::reduceMixtureLargestWeights(cmps, 2, *dummy);
 
   BOOST_CHECK_EQUAL(cmps.size(), 2);
-  std::sort(cmps.begin(), cmps.end(),
-            [](const auto &a, const auto &b) { return a.weight < b.weight; });
+  std::ranges::sort(cmps, {}, [](const auto &c) { return c.weight; });
 
   BOOST_CHECK_EQUAL(cmps[0].weight, 3.0);
   BOOST_CHECK_EQUAL(cmps[1].weight, 4.0);
diff --git a/Tests/UnitTests/Core/TrackFitting/Gx2fTests.cpp b/Tests/UnitTests/Core/TrackFitting/Gx2fTests.cpp
index 8cc6c21074d..2d9d110ec5f 100644
--- a/Tests/UnitTests/Core/TrackFitting/Gx2fTests.cpp
+++ b/Tests/UnitTests/Core/TrackFitting/Gx2fTests.cpp
@@ -1158,15 +1158,15 @@ BOOST_AUTO_TEST_CASE(Material) {
     ObjVisualization3D obj;
 
     bool triangulate = true;
-    ViewConfig viewSensitive = ViewConfig({0, 180, 240});
+    ViewConfig viewSensitive = {.color = {0, 180, 240}};
     viewSensitive.triangulate = triangulate;
-    ViewConfig viewPassive = ViewConfig({240, 280, 0});
+    ViewConfig viewPassive = {.color = {240, 280, 0}};
     viewPassive.triangulate = triangulate;
-    ViewConfig viewVolume = ViewConfig({220, 220, 0});
+    ViewConfig viewVolume = {.color = {220, 220, 0}};
     viewVolume.triangulate = triangulate;
-    ViewConfig viewContainer = ViewConfig({220, 220, 0});
+    ViewConfig viewContainer = {.color = {220, 220, 0}};
     viewContainer.triangulate = triangulate;
-    ViewConfig viewGrid = ViewConfig({220, 0, 0});
+    ViewConfig viewGrid = {.color = {220, 0, 0}};
     viewGrid.nSegments = 8;
     viewGrid.offset = 3.;
     viewGrid.triangulate = triangulate;
@@ -1186,7 +1186,7 @@ BOOST_AUTO_TEST_CASE(Material) {
     ObjVisualization3D obj;
 
     double localErrorScale = 10000000.;
-    ViewConfig mcolor({255, 145, 48});
+    ViewConfig mcolor{.color = {255, 145, 48}};
     mcolor.offset = 2;
     //  mcolor.visible = true;
 
diff --git a/Tests/UnitTests/Core/Utilities/BoundingBoxTest.cpp b/Tests/UnitTests/Core/Utilities/BoundingBoxTest.cpp
index 6b6dcd3847d..93d6ae5766e 100644
--- a/Tests/UnitTests/Core/Utilities/BoundingBoxTest.cpp
+++ b/Tests/UnitTests/Core/Utilities/BoundingBoxTest.cpp
@@ -887,7 +887,7 @@ BOOST_AUTO_TEST_CASE(frustum_intersect) {
                 min + i * step, min + j * step, min + k * step);
             Box bb(&o, pos, size);
 
-            std::array<int, 3> color = {255, 0, 0};
+            Color color = {255, 0, 0};
 
             if (bb.intersect(fr)) {
               color = {0, 255, 0};
@@ -1150,7 +1150,7 @@ BOOST_AUTO_TEST_CASE(frustum_intersect) {
                 min + i * step, min + j * step, min + k * step);
             Box bb(&o, pos, size);
 
-            std::array<int, 3> color = {255, 0, 0};
+            Color color = {255, 0, 0};
 
             if (bb.intersect(fr)) {
               color = {0, 255, 0};
diff --git a/Tests/UnitTests/Core/Utilities/CMakeLists.txt b/Tests/UnitTests/Core/Utilities/CMakeLists.txt
index 437b5533d3c..4050ed8a907 100644
--- a/Tests/UnitTests/Core/Utilities/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Utilities/CMakeLists.txt
@@ -58,3 +58,4 @@ add_unittest(TransformRange TransformRangeTests.cpp)
 add_unittest(QuickMath QuickMathTests.cpp)
 
 add_unittest(TrackHelpers TrackHelpersTests.cpp)
+add_unittest(GraphViz GraphVizTests.cpp)
diff --git a/Tests/UnitTests/Core/Utilities/GraphVizTests.cpp b/Tests/UnitTests/Core/Utilities/GraphVizTests.cpp
new file mode 100644
index 00000000000..fd80f4d52b1
--- /dev/null
+++ b/Tests/UnitTests/Core/Utilities/GraphVizTests.cpp
@@ -0,0 +1,54 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 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 http://mozilla.org/MPL/2.0/.
+
+#include <boost/test/tools/output_test_stream.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include "Acts/Utilities/GraphViz.hpp"
+
+namespace Acts::Test {
+
+BOOST_AUTO_TEST_SUITE(GraphViz)
+
+BOOST_AUTO_TEST_CASE(ApiTest) {
+  std::stringstream ss;
+
+  using namespace Acts::GraphViz;
+
+  Node node1{.id = "node1",
+             .label = "Node 1",
+             .shape = Shape::Ellipse,
+             .style = {Style::Filled}};
+
+  ss << node1;
+
+  std::string exp = R"(node1 [label=<Node 1>, shape=ellipse, style=filled];
+)";
+
+  BOOST_CHECK_EQUAL(ss.str(), exp);
+
+  Node node2{.id = "node2",
+             .label = "Node 2",
+             .shape = Shape::Rectangle,
+             .style = {Style::Dashed}};
+
+  Edge edge = {.from = node1, .to = node2, .style = Style::Dashed};
+
+  ss.str("");
+
+  ss << edge;
+
+  exp = R"(node1 -> node2 [style=dashed];
+)";
+
+  BOOST_CHECK_EQUAL(ss.str(), exp);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}  // namespace Acts::Test
diff --git a/Tests/UnitTests/Core/Utilities/IntersectionTests.cpp b/Tests/UnitTests/Core/Utilities/IntersectionTests.cpp
index 644371c45a4..185b3457e43 100644
--- a/Tests/UnitTests/Core/Utilities/IntersectionTests.cpp
+++ b/Tests/UnitTests/Core/Utilities/IntersectionTests.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018 CERN for the benefit of the Acts project
+// Copyright (C) 2018-2024 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
@@ -51,8 +51,7 @@ BOOST_AUTO_TEST_CASE(IntersectionTest) {
   std::vector<Intersection3D> tsfpIntersections = {tIp, sIp, fIp};
 
   // let's sort the tsf intersection, it should give fst
-  std::sort(tsfpIntersections.begin(), tsfpIntersections.end(),
-            Intersection3D::pathLengthOrder);
+  std::ranges::sort(tsfpIntersections, Intersection3D::pathLengthOrder);
   BOOST_CHECK_EQUAL(fstpIntersections[0].pathLength(),
                     tsfpIntersections[0].pathLength());
   BOOST_CHECK_EQUAL(fstpIntersections[1].pathLength(),
@@ -66,8 +65,7 @@ BOOST_AUTO_TEST_CASE(IntersectionTest) {
   std::vector<Intersection3D> tfnsnpIntersections = {tIp, fIp, nIp, sIp, nIp};
 
   // shuffle the intersections
-  std::sort(ntfspIntersections.begin(), ntfspIntersections.end(),
-            Intersection3D::pathLengthOrder);
+  std::ranges::sort(ntfspIntersections, Intersection3D::pathLengthOrder);
   BOOST_CHECK_EQUAL(fstpIntersections[0].pathLength(),
                     ntfspIntersections[0].pathLength());
   BOOST_CHECK_EQUAL(fstpIntersections[1].pathLength(),
@@ -75,8 +73,7 @@ BOOST_AUTO_TEST_CASE(IntersectionTest) {
   BOOST_CHECK_EQUAL(fstpIntersections[2].pathLength(),
                     ntfspIntersections[2].pathLength());
 
-  std::sort(tfnsnpIntersections.begin(), tfnsnpIntersections.end(),
-            Intersection3D::pathLengthOrder);
+  std::ranges::sort(tfnsnpIntersections, Intersection3D::pathLengthOrder);
   BOOST_CHECK_EQUAL(fstpIntersections[0].pathLength(),
                     tfnsnpIntersections[0].pathLength());
   BOOST_CHECK_EQUAL(fstpIntersections[1].pathLength(),
@@ -96,8 +93,7 @@ BOOST_AUTO_TEST_CASE(IntersectionTest) {
   std::vector<Intersection3D> fstnIntersections = {fIn, sIn, tIn};
 
   // this time around, sort the f-s-t-n to match the t-s-f-n
-  std::sort(fstnIntersections.begin(), fstnIntersections.end(),
-            Intersection3D::pathLengthOrder);
+  std::ranges::sort(fstnIntersections, Intersection3D::pathLengthOrder);
   BOOST_CHECK_EQUAL(fstnIntersections[0].pathLength(),
                     tsfnIntersections[0].pathLength());
   BOOST_CHECK_EQUAL(fstnIntersections[1].pathLength(),
@@ -107,8 +103,7 @@ BOOST_AUTO_TEST_CASE(IntersectionTest) {
 
   // shuffle negative and positive solutions
   std::vector<Intersection3D> pnsolutions = {tIp, sIn, sIp, fIn, tIn, fIp};
-  std::sort(pnsolutions.begin(), pnsolutions.end(),
-            Intersection3D::pathLengthOrder);
+  std::ranges::sort(pnsolutions, Intersection3D::pathLengthOrder);
 
   BOOST_CHECK_EQUAL(pnsolutions[0].pathLength(), -3.);
   BOOST_CHECK_EQUAL(pnsolutions[1].pathLength(), -2.);
@@ -121,8 +116,7 @@ BOOST_AUTO_TEST_CASE(IntersectionTest) {
   Intersection3D zI(Vector3(0., 0., 0.), 0., Intersection3D::Status::onSurface);
   std::vector<Intersection3D> tszfpIntersections = {tIp, sIp, zI, fIp};
 
-  std::sort(tszfpIntersections.begin(), tszfpIntersections.end(),
-            Intersection3D::pathLengthOrder);
+  std::ranges::sort(tszfpIntersections, Intersection3D::pathLengthOrder);
   BOOST_CHECK_EQUAL(tszfpIntersections[0].pathLength(), 0.);
   BOOST_CHECK_EQUAL(tszfpIntersections[1].pathLength(), 1.);
   BOOST_CHECK_EQUAL(tszfpIntersections[2].pathLength(), 2.);
@@ -131,8 +125,7 @@ BOOST_AUTO_TEST_CASE(IntersectionTest) {
   std::vector<Intersection3D> tfsznIntersections = {tIn, fIn, sIn, zI};
   std::vector<Intersection3D> ztfsnIntersections = {zI, tIn, fIn, sIn};
 
-  std::sort(tfsznIntersections.begin(), tfsznIntersections.end(),
-            Intersection3D::pathLengthOrder);
+  std::ranges::sort(tfsznIntersections, Intersection3D::pathLengthOrder);
   BOOST_CHECK_EQUAL(tfsznIntersections[0].pathLength(), -3.);
   BOOST_CHECK_EQUAL(tfsznIntersections[1].pathLength(), -2.);
   BOOST_CHECK_EQUAL(tfsznIntersections[2].pathLength(), -1.);
diff --git a/Tests/UnitTests/Core/Utilities/KDTreeTests.cpp b/Tests/UnitTests/Core/Utilities/KDTreeTests.cpp
index 9c4a4d2fe64..d1fd310d1c5 100644
--- a/Tests/UnitTests/Core/Utilities/KDTreeTests.cpp
+++ b/Tests/UnitTests/Core/Utilities/KDTreeTests.cpp
@@ -8,6 +8,7 @@
 
 #include <boost/test/unit_test.hpp>
 
+#include "Acts/Utilities/Helpers.hpp"
 #include "Acts/Utilities/KDTree.hpp"
 #include "Acts/Utilities/RangeXD.hpp"
 
@@ -236,12 +237,12 @@ BOOST_FIXTURE_TEST_CASE(range_search_1, TreeFixture1DDoubleInt2) {
 
   std::vector<int> result = tree.rangeSearch(range);
   BOOST_CHECK_EQUAL(result.size(), 3);
-  BOOST_CHECK((std::find(result.begin(), result.end(), 5) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 6) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 10) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 7) == result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 2) == result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 9) == result.end()));
+  BOOST_CHECK(rangeContainsValue(result, 5));
+  BOOST_CHECK(rangeContainsValue(result, 6));
+  BOOST_CHECK(rangeContainsValue(result, 10));
+  BOOST_CHECK(!rangeContainsValue(result, 7));
+  BOOST_CHECK(!rangeContainsValue(result, 2));
+  BOOST_CHECK(!rangeContainsValue(result, 9));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_2, TreeFixture1DDoubleInt2) {
@@ -250,13 +251,13 @@ BOOST_FIXTURE_TEST_CASE(range_search_2, TreeFixture1DDoubleInt2) {
 
   std::vector<int> result = tree.rangeSearch(range);
   BOOST_CHECK_EQUAL(result.size(), 7);
-  BOOST_CHECK((std::find(result.begin(), result.end(), 1) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 2) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 3) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 5) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 6) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 9) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 10) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, 1));
+  BOOST_CHECK(rangeContainsValue(result, 2));
+  BOOST_CHECK(rangeContainsValue(result, 3));
+  BOOST_CHECK(rangeContainsValue(result, 5));
+  BOOST_CHECK(rangeContainsValue(result, 6));
+  BOOST_CHECK(rangeContainsValue(result, 9));
+  BOOST_CHECK(rangeContainsValue(result, 10));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_3, TreeFixture1DDoubleInt2) {
@@ -274,7 +275,7 @@ BOOST_FIXTURE_TEST_CASE(range_search_4, TreeFixture2DDoubleInt1) {
 
   std::vector<int> result = tree.rangeSearch(range);
   BOOST_CHECK_EQUAL(result.size(), 1);
-  BOOST_CHECK((std::find(result.begin(), result.end(), 5) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, 5));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_5, TreeFixture2DDoubleInt1) {
@@ -284,8 +285,8 @@ BOOST_FIXTURE_TEST_CASE(range_search_5, TreeFixture2DDoubleInt1) {
 
   std::vector<int> result = tree.rangeSearch(range);
   BOOST_CHECK_EQUAL(result.size(), 2);
-  BOOST_CHECK((std::find(result.begin(), result.end(), 5) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 6) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, 5));
+  BOOST_CHECK(rangeContainsValue(result, 6));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_6, TreeFixture10DDoubleInt1) {
@@ -294,11 +295,11 @@ BOOST_FIXTURE_TEST_CASE(range_search_6, TreeFixture10DDoubleInt1) {
 
   std::vector<int> result = tree.rangeSearch(range);
   BOOST_CHECK_EQUAL(result.size(), 5);
-  BOOST_CHECK((std::find(result.begin(), result.end(), -66) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -51) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -19) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -13) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -83) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, -66));
+  BOOST_CHECK(rangeContainsValue(result, -51));
+  BOOST_CHECK(rangeContainsValue(result, -19));
+  BOOST_CHECK(rangeContainsValue(result, -13));
+  BOOST_CHECK(rangeContainsValue(result, -83));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_7, TreeFixture10DDoubleInt1) {
@@ -307,8 +308,8 @@ BOOST_FIXTURE_TEST_CASE(range_search_7, TreeFixture10DDoubleInt1) {
 
   std::vector<int> result = tree.rangeSearch(range);
   BOOST_CHECK_EQUAL(result.size(), 2);
-  BOOST_CHECK((std::find(result.begin(), result.end(), 27) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -56) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, 27));
+  BOOST_CHECK(rangeContainsValue(result, -56));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_8, TreeFixture3DDoubleString1) {
@@ -319,8 +320,7 @@ BOOST_FIXTURE_TEST_CASE(range_search_8, TreeFixture3DDoubleString1) {
 
   std::vector<std::string> result = tree.rangeSearch(range);
   BOOST_CHECK_EQUAL(result.size(), 1);
-  BOOST_CHECK(
-      (std::find(result.begin(), result.end(), "string0") != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, "string0"));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_9, TreeFixture3DDoubleString1) {
@@ -331,14 +331,10 @@ BOOST_FIXTURE_TEST_CASE(range_search_9, TreeFixture3DDoubleString1) {
 
   std::vector<std::string> result = tree.rangeSearch(range);
   BOOST_CHECK_EQUAL(result.size(), 4);
-  BOOST_CHECK(
-      (std::find(result.begin(), result.end(), "string0") != result.end()));
-  BOOST_CHECK(
-      (std::find(result.begin(), result.end(), "string3") != result.end()));
-  BOOST_CHECK(
-      (std::find(result.begin(), result.end(), "string4") != result.end()));
-  BOOST_CHECK(
-      (std::find(result.begin(), result.end(), "string9") != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, "string0"));
+  BOOST_CHECK(rangeContainsValue(result, "string3"));
+  BOOST_CHECK(rangeContainsValue(result, "string4"));
+  BOOST_CHECK(rangeContainsValue(result, "string9"));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_10, TreeFixture1DIntInt1) {
@@ -347,8 +343,8 @@ BOOST_FIXTURE_TEST_CASE(range_search_10, TreeFixture1DIntInt1) {
 
   std::vector<int> result = tree.rangeSearch(range);
   BOOST_CHECK_EQUAL(result.size(), 2);
-  BOOST_CHECK((std::find(result.begin(), result.end(), 5) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 6) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, 5));
+  BOOST_CHECK(rangeContainsValue(result, 6));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_11, TreeFixture2DIntInt1) {
@@ -357,8 +353,8 @@ BOOST_FIXTURE_TEST_CASE(range_search_11, TreeFixture2DIntInt1) {
 
   std::vector<int> result = tree.rangeSearch(range);
   BOOST_CHECK_EQUAL(result.size(), 2);
-  BOOST_CHECK((std::find(result.begin(), result.end(), 5) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 6) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, 5));
+  BOOST_CHECK(rangeContainsValue(result, 6));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_inplace_1, TreeFixture10DDoubleInt1) {
@@ -369,11 +365,11 @@ BOOST_FIXTURE_TEST_CASE(range_search_inplace_1, TreeFixture10DDoubleInt1) {
   tree.rangeSearch(range, result);
 
   BOOST_CHECK_EQUAL(result.size(), 5);
-  BOOST_CHECK((std::find(result.begin(), result.end(), -66) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -51) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -19) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -13) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -83) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, -66));
+  BOOST_CHECK(rangeContainsValue(result, -51));
+  BOOST_CHECK(rangeContainsValue(result, -19));
+  BOOST_CHECK(rangeContainsValue(result, -13));
+  BOOST_CHECK(rangeContainsValue(result, -83));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_inserter_1, TreeFixture10DDoubleInt1) {
@@ -384,11 +380,11 @@ BOOST_FIXTURE_TEST_CASE(range_search_inserter_1, TreeFixture10DDoubleInt1) {
   tree.rangeSearchInserter(range, std::back_inserter(result));
 
   BOOST_CHECK_EQUAL(result.size(), 5);
-  BOOST_CHECK((std::find(result.begin(), result.end(), -66) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -51) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -19) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -13) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -83) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, -66));
+  BOOST_CHECK(rangeContainsValue(result, -51));
+  BOOST_CHECK(rangeContainsValue(result, -19));
+  BOOST_CHECK(rangeContainsValue(result, -13));
+  BOOST_CHECK(rangeContainsValue(result, -83));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_map_1, TreeFixture10DDoubleInt1) {
@@ -400,11 +396,11 @@ BOOST_FIXTURE_TEST_CASE(range_search_map_1, TreeFixture10DDoubleInt1) {
       [](const std::array<double, 10>&, const int& i) -> int { return 2 * i; });
 
   BOOST_CHECK_EQUAL(result.size(), 5);
-  BOOST_CHECK((std::find(result.begin(), result.end(), -132) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -102) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -38) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -26) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), -166) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, -132));
+  BOOST_CHECK(rangeContainsValue(result, -102));
+  BOOST_CHECK(rangeContainsValue(result, -38));
+  BOOST_CHECK(rangeContainsValue(result, -26));
+  BOOST_CHECK(rangeContainsValue(result, -166));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_map_inserter_1, TreeFixture10DDoubleInt1) {
@@ -421,11 +417,11 @@ BOOST_FIXTURE_TEST_CASE(range_search_map_inserter_1, TreeFixture10DDoubleInt1) {
       std::back_inserter(result));
 
   BOOST_CHECK_EQUAL(result.size(), 5);
-  BOOST_CHECK((std::find(result.begin(), result.end(), "-66") != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), "-51") != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), "-19") != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), "-13") != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), "-83") != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, "-66"));
+  BOOST_CHECK(rangeContainsValue(result, "-51"));
+  BOOST_CHECK(rangeContainsValue(result, "-19"));
+  BOOST_CHECK(rangeContainsValue(result, "-13"));
+  BOOST_CHECK(rangeContainsValue(result, "-83"));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_map_inserter_2, TreeFixture2DIntInt1) {
@@ -441,8 +437,8 @@ BOOST_FIXTURE_TEST_CASE(range_search_map_inserter_2, TreeFixture2DIntInt1) {
       std::back_inserter(result));
 
   BOOST_CHECK_EQUAL(result.size(), 2);
-  BOOST_CHECK((std::find(result.begin(), result.end(), 40) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 18) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, 40));
+  BOOST_CHECK(rangeContainsValue(result, 18));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_map_discard_1, TreeFixture2DIntInt1) {
@@ -500,8 +496,7 @@ BOOST_FIXTURE_TEST_CASE(range_search_combinatorial, TreeFixture3DDoubleInt2) {
               BOOST_CHECK_EQUAL(result.size(), valid.size());
 
               for (int j : valid) {
-                BOOST_CHECK((std::find(result.begin(), result.end(), j) !=
-                             result.end()));
+                BOOST_CHECK(rangeContainsValue(result, j));
               }
             }
           }
@@ -517,10 +512,10 @@ BOOST_FIXTURE_TEST_CASE(range_search_dominate1, TreeFixture3DDoubleInt3) {
 
   std::vector<int> result = tree.rangeSearch(range1);
   BOOST_CHECK_EQUAL(result.size(), 4);
-  BOOST_CHECK((std::find(result.begin(), result.end(), 0) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 1) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 2) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 3) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, 0));
+  BOOST_CHECK(rangeContainsValue(result, 1));
+  BOOST_CHECK(rangeContainsValue(result, 2));
+  BOOST_CHECK(rangeContainsValue(result, 3));
 }
 
 BOOST_FIXTURE_TEST_CASE(range_search_dominate2, TreeFixture3DDoubleInt3) {
@@ -529,10 +524,10 @@ BOOST_FIXTURE_TEST_CASE(range_search_dominate2, TreeFixture3DDoubleInt3) {
 
   std::vector<int> result = tree.rangeSearch(range1);
   BOOST_CHECK_EQUAL(result.size(), 4);
-  BOOST_CHECK((std::find(result.begin(), result.end(), 4) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 5) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 6) != result.end()));
-  BOOST_CHECK((std::find(result.begin(), result.end(), 7) != result.end()));
+  BOOST_CHECK(rangeContainsValue(result, 4));
+  BOOST_CHECK(rangeContainsValue(result, 5));
+  BOOST_CHECK(rangeContainsValue(result, 6));
+  BOOST_CHECK(rangeContainsValue(result, 7));
 }
 
 BOOST_AUTO_TEST_CASE(range_search_very_big) {
@@ -580,8 +575,7 @@ BOOST_AUTO_TEST_CASE(range_search_very_big) {
         BOOST_CHECK_EQUAL(result.size(), valid.size());
 
         for (int j : valid) {
-          BOOST_CHECK(
-              (std::find(result.begin(), result.end(), j) != result.end()));
+          BOOST_CHECK(rangeContainsValue(result, j));
         }
       }
     }
@@ -620,13 +614,11 @@ BOOST_AUTO_TEST_CASE(range_search_many_same) {
   BOOST_CHECK_EQUAL(result2.size(), 50);
 
   for (int i = 0; i < 50; ++i) {
-    BOOST_CHECK(
-        (std::find(result1.begin(), result1.end(), i) != result1.end()));
+    BOOST_CHECK(rangeContainsValue(result1, i));
   }
 
   for (int i = 50; i < 100; ++i) {
-    BOOST_CHECK(
-        (std::find(result2.begin(), result2.end(), i) != result2.end()));
+    BOOST_CHECK(rangeContainsValue(result2, i));
   }
 }
 
diff --git a/Tests/UnitTests/Core/Utilities/SubspaceTests.cpp b/Tests/UnitTests/Core/Utilities/SubspaceTests.cpp
index 2fbf0d2ffc4..d61c46a3d69 100644
--- a/Tests/UnitTests/Core/Utilities/SubspaceTests.cpp
+++ b/Tests/UnitTests/Core/Utilities/SubspaceTests.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2020-2024 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
@@ -78,7 +78,7 @@ std::array<std::size_t, kSize> selectFixedIndices(
   for (auto i = 0u; i < kSize; ++i) {
     indices[i] = fullIndices[i];
   }
-  std::sort(indices.begin(), indices.end());
+  std::ranges::sort(indices);
   return indices;
 }
 
diff --git a/Tests/UnitTests/Core/Visualization/EventDataView3DBase.hpp b/Tests/UnitTests/Core/Visualization/EventDataView3DBase.hpp
index b642b3a5ddc..cf6143d2015 100644
--- a/Tests/UnitTests/Core/Visualization/EventDataView3DBase.hpp
+++ b/Tests/UnitTests/Core/Visualization/EventDataView3DBase.hpp
@@ -165,8 +165,8 @@ void createDetector(GeometryContext& tgContext,
 static inline std::string testBoundTrackParameters(IVisualization3D& helper) {
   std::stringstream ss;
 
-  ViewConfig pcolor({20, 120, 20});
-  ViewConfig scolor({235, 198, 52});
+  ViewConfig pcolor{.color = {20, 120, 20}};
+  ViewConfig scolor{.color = {235, 198, 52}};
 
   auto gctx = GeometryContext();
   auto identity = Transform3::Identity();
@@ -245,7 +245,7 @@ static inline std::string testMeasurement(IVisualization3D& helper,
         eBoundLoc0, eBoundLoc1, loc, cov2D, surface->geometryId()});
   }
 
-  ViewConfig mcolor({255, 145, 48});
+  ViewConfig mcolor{.color = {255, 145, 48}};
   mcolor.offset = 0.01;
 
   // Draw the measurements
@@ -378,14 +378,14 @@ static inline std::string testMultiTrajectory(IVisualization3D& helper) {
   double localErrorScale = 100.;
   double directionErrorScale = 100000;
 
-  ViewConfig scolor({214, 214, 214});
-  ViewConfig mcolor({255, 145, 48});
+  ViewConfig scolor{.color = {214, 214, 214}};
+  ViewConfig mcolor{.color = {255, 145, 48}};
   mcolor.offset = -0.01;
-  ViewConfig ppcolor({51, 204, 51});
+  ViewConfig ppcolor{.color = {51, 204, 51}};
   ppcolor.offset = -0.02;
-  ViewConfig fpcolor({255, 255, 0});
+  ViewConfig fpcolor{.color = {255, 255, 0}};
   fpcolor.offset = -0.03;
-  ViewConfig spcolor({0, 125, 255});
+  ViewConfig spcolor{.color = {0, 125, 255}};
   spcolor.offset = -0.04;
 
   EventDataView3D::drawMultiTrajectory(
diff --git a/Tests/UnitTests/Core/Visualization/PrimitivesView3DBase.hpp b/Tests/UnitTests/Core/Visualization/PrimitivesView3DBase.hpp
index 505646cfd75..4c64929061a 100644
--- a/Tests/UnitTests/Core/Visualization/PrimitivesView3DBase.hpp
+++ b/Tests/UnitTests/Core/Visualization/PrimitivesView3DBase.hpp
@@ -40,7 +40,7 @@ GeometryContext gctx = GeometryContext();
 static inline std::string run(IVisualization3D& helper) {
   std::stringstream ss;
 
-  ViewConfig lineView({0, 0, 255});
+  ViewConfig lineView{.color = {0, 0, 255}};
   lineView.lineThickness = 0.1;
 
   // Line visualization ------------------------------------------------
@@ -71,7 +71,7 @@ static inline std::string run(IVisualization3D& helper) {
   // Error visualization: local ---------------------------------------------
   Acts::GeometryView3D::drawSurface(helper, *plane, gctx);
 
-  ViewConfig errorVis({250, 0, 0});
+  ViewConfig errorVis{.color = {250, 0, 0}};
   errorVis.lineThickness = 0.025;
 
   SquareMatrix2 cov = SquareMatrix2::Identity();
diff --git a/Tests/UnitTests/Core/Visualization/TrackingGeometryView3DBase.hpp b/Tests/UnitTests/Core/Visualization/TrackingGeometryView3DBase.hpp
index 350e08e1490..ccf5f267212 100644
--- a/Tests/UnitTests/Core/Visualization/TrackingGeometryView3DBase.hpp
+++ b/Tests/UnitTests/Core/Visualization/TrackingGeometryView3DBase.hpp
@@ -37,15 +37,15 @@ static inline std::string run(IVisualization3D& helper, bool triangulate,
                               const std::string& tag) {
   std::stringstream cStream;
 
-  ViewConfig viewSensitive = ViewConfig({0, 180, 240});
+  ViewConfig viewSensitive = {.color = {0, 180, 240}};
   viewSensitive.triangulate = triangulate;
-  ViewConfig viewPassive = ViewConfig({240, 280, 0});
+  ViewConfig viewPassive = {.color = {240, 280, 0}};
   viewPassive.triangulate = triangulate;
-  ViewConfig viewVolume = ViewConfig({220, 220, 0});
+  ViewConfig viewVolume = {.color = {220, 220, 0}};
   viewVolume.triangulate = triangulate;
-  ViewConfig viewContainer = ViewConfig({220, 220, 0});
+  ViewConfig viewContainer = {.color = {220, 220, 0}};
   viewContainer.triangulate = triangulate;
-  ViewConfig viewGrid = ViewConfig({220, 0, 0});
+  ViewConfig viewGrid = {.color = {220, 0, 0}};
   viewGrid.nSegments = 8;
   viewGrid.offset = 3.;
   viewGrid.triangulate = triangulate;
diff --git a/Tests/UnitTests/Core/Visualization/Visualization3DTests.cpp b/Tests/UnitTests/Core/Visualization/Visualization3DTests.cpp
index 09bade86ae8..e8ae4a82c46 100644
--- a/Tests/UnitTests/Core/Visualization/Visualization3DTests.cpp
+++ b/Tests/UnitTests/Core/Visualization/Visualization3DTests.cpp
@@ -298,7 +298,8 @@ BOOST_AUTO_TEST_CASE(ObjOutputTest) {
 
   output << obj;
 
-  std::string exp = R"(v 1 0 0
+  std::string exp = R"(usemtl material_120_120_120
+v 1 0 0
 )";
 
   BOOST_CHECK(output.is_equal(exp));
@@ -307,15 +308,35 @@ BOOST_AUTO_TEST_CASE(ObjOutputTest) {
   obj.face({{1, 0, 0}, {1, 1, 0}, {0, 1, 0}});
   output << obj;
 
-  exp = R"(v 1 0 0
+  exp = R"(usemtl material_120_120_120
+v 1 0 0
 v 1 1 0
 v 0 1 0
+usemtl material_120_120_120
 f 1 2 3
 )";
 
   BOOST_CHECK(output.is_equal(exp));
 }
 
+BOOST_AUTO_TEST_CASE(ColorTests) {
+  Color red{"#ff0000"};
+  BOOST_CHECK_EQUAL(red, Color(255, 0, 0));
+
+  Color green{"#00ff00"};
+  BOOST_CHECK_EQUAL(green, Color(0, 255, 0));
+
+  Color blue{"#0000ff"};
+  BOOST_CHECK_EQUAL(blue, Color(0, 0, 255));
+
+  Color grey{"#808080"};
+  BOOST_CHECK_EQUAL(grey, Color(128, 128, 128));
+  BOOST_CHECK_EQUAL(grey, Color(std::array{128, 128, 128}));
+  BOOST_CHECK_EQUAL(grey,
+                    Color(std::array{128 / 255.0, 128 / 255.0, 128 / 255.0}));
+  BOOST_CHECK_EQUAL(grey, Color(128 / 255.0, 128 / 255.0, 128 / 255.0));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }  // namespace Acts::Test
diff --git a/Tests/UnitTests/Plugins/ExaTrkX/ExaTrkXBoostTrackBuildingTests.cpp b/Tests/UnitTests/Plugins/ExaTrkX/ExaTrkXBoostTrackBuildingTests.cpp
index 7fad2d0b071..0ccbc53e999 100644
--- a/Tests/UnitTests/Plugins/ExaTrkX/ExaTrkXBoostTrackBuildingTests.cpp
+++ b/Tests/UnitTests/Plugins/ExaTrkX/ExaTrkXBoostTrackBuildingTests.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -10,6 +10,7 @@
 
 #include "Acts/Plugins/ExaTrkX/BoostTrackBuilding.hpp"
 #include "Acts/Plugins/ExaTrkX/detail/TensorVectorConversion.hpp"
+#include "Acts/Utilities/Helpers.hpp"
 
 #include <algorithm>
 
@@ -50,13 +51,12 @@ BOOST_AUTO_TEST_CASE(test_track_building) {
 
   // Sort tracks, so we can find them
   std::for_each(testTracks.begin(), testTracks.end(),
-                [](auto &t) { std::sort(t.begin(), t.end()); });
+                [](auto &t) { std::ranges::sort(t); });
   std::for_each(refTracks.begin(), refTracks.end(),
-                [](auto &t) { std::sort(t.begin(), t.end()); });
+                [](auto &t) { std::ranges::sort(t); });
 
   // Check what we have here
   for (const auto &refTrack : refTracks) {
-    auto found = std::find(testTracks.begin(), testTracks.end(), refTrack);
-    BOOST_CHECK(found != testTracks.end());
+    BOOST_CHECK(Acts::rangeContainsValue(testTracks, refTrack));
   }
 }
diff --git a/Tests/UnitTests/Plugins/ExaTrkX/ExaTrkXEdgeBuildingTest.cpp b/Tests/UnitTests/Plugins/ExaTrkX/ExaTrkXEdgeBuildingTest.cpp
index 7e75b2a8b43..3f671aeb04e 100644
--- a/Tests/UnitTests/Plugins/ExaTrkX/ExaTrkXEdgeBuildingTest.cpp
+++ b/Tests/UnitTests/Plugins/ExaTrkX/ExaTrkXEdgeBuildingTest.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -12,6 +12,7 @@
 #include "Acts/Plugins/ExaTrkX/detail/TensorVectorConversion.hpp"
 #include "Acts/Plugins/ExaTrkX/detail/buildEdges.hpp"
 
+#include <algorithm>
 #include <cassert>
 #include <iostream>
 
@@ -83,8 +84,8 @@ void test_random_graph(int emb_dim, int n_nodes, float r, int knn,
     edges_test_cantor.push_back(a < b ? CantorPair(a, b) : CantorPair(b, a));
   }
 
-  std::sort(edges_ref_cantor.begin(), edges_ref_cantor.end());
-  std::sort(edges_test_cantor.begin(), edges_test_cantor.end());
+  std::ranges::sort(edges_ref_cantor, std::less<CantorPair>{});
+  std::ranges::sort(edges_test_cantor, std::less<CantorPair>{});
 
 #if PRINT
   std::cout << "test size " << edges_test_cantor.size() << std::endl;
diff --git a/Tests/UnitTests/Plugins/Geant4/Geant4DetectorSurfaceFactoryTests.cpp b/Tests/UnitTests/Plugins/Geant4/Geant4DetectorSurfaceFactoryTests.cpp
index dc102eefaf2..6fd9606b6a1 100644
--- a/Tests/UnitTests/Plugins/Geant4/Geant4DetectorSurfaceFactoryTests.cpp
+++ b/Tests/UnitTests/Plugins/Geant4/Geant4DetectorSurfaceFactoryTests.cpp
@@ -161,27 +161,24 @@ BOOST_AUTO_TEST_CASE(Geant4DetecturSurfaceFactory_Transforms) {
   Acts::ObjVisualization3D obj;
   Acts::Vector3 origin(0, 0, 0);
   Acts::GeometryView3D::drawArrowForward(obj, origin, Acts::Vector3(100, 0, 0),
-                                         1000, 10,
-                                         Acts::ViewConfig({255, 0, 0}));
+                                         1000, 10, {.color = {255, 0, 0}});
   Acts::GeometryView3D::drawArrowForward(obj, origin, Acts::Vector3(0, 100, 0),
-                                         1000, 10,
-                                         Acts::ViewConfig({0, 255, 0}));
+                                         1000, 10, {.color = {0, 255, 0}});
   Acts::GeometryView3D::drawArrowForward(obj, origin, Acts::Vector3(0, 0, 100),
-                                         1000, 10,
-                                         Acts::ViewConfig({0, 0, 255}));
-  Acts::GeometryView3D::drawArrowForward(
-      obj, surface->center(gctx), surface->center(gctx) + 100 * normal, 1000,
-      10, Acts::ViewConfig({0, 255, 0}));
+                                         1000, 10, {.color = {0, 0, 255}});
+  Acts::GeometryView3D::drawArrowForward(obj, surface->center(gctx),
+                                         surface->center(gctx) + 100 * normal,
+                                         1000, 10, {.color = {0, 255, 0}});
   auto surfaces = cache.sensitiveSurfaces;
   for (const auto& [k, val] : Acts::enumerate(cache.sensitiveSurfaces)) {
     const auto& [el, surf] = val;
     Acts::ViewConfig vCfg;
     if (k == 0) {
-      vCfg.color = Acts::ColorRGB({0, 255, 0});
+      vCfg.color = {0, 255, 0};
     } else if (k == 1) {
-      vCfg.color = Acts::ColorRGB({255, 0, 0});
+      vCfg.color = {255, 0, 0};
     } else if (k == 2) {
-      vCfg.color = Acts::ColorRGB({0, 255, 255});
+      vCfg.color = {0, 255, 255};
     }
     Acts::GeometryView3D::drawSurface(obj, *surf, gctx,
                                       Acts::Transform3::Identity(), vCfg);
diff --git a/Tests/UnitTests/Plugins/GeoModel/CMakeLists.txt b/Tests/UnitTests/Plugins/GeoModel/CMakeLists.txt
index 61b903d515a..9847dc5b3d8 100644
--- a/Tests/UnitTests/Plugins/GeoModel/CMakeLists.txt
+++ b/Tests/UnitTests/Plugins/GeoModel/CMakeLists.txt
@@ -4,3 +4,7 @@ add_unittest(GeoModelDetectorElement GeoModelDetectorElementTests.cpp)
 add_unittest(GeoBoxConverter GeoBoxConverterTests.cpp)
 add_unittest(GeoTrdConverter GeoTrdConverterTests.cpp)
 add_unittest(GeoDetectorObjectTest GeoDetectorObjectTest.cpp)
+add_unittest(GeoPolyConverterTests GeoPolyConverterTests.cpp)
+add_unittest(GeoTrdToVolumeTest GeoTrdToVolumeTests.cpp)
+add_unittest(GeoBoxToVolumeTest GeoBoxToVolumeTest.cpp)
+add_unittest(GeoTubeToVolumeTest GeoTubeToVolumeTest.cpp)
diff --git a/Tests/UnitTests/Plugins/GeoModel/GeoBoxToVolumeTest.cpp b/Tests/UnitTests/Plugins/GeoModel/GeoBoxToVolumeTest.cpp
new file mode 100644
index 00000000000..035fe7ebc1a
--- /dev/null
+++ b/Tests/UnitTests/Plugins/GeoModel/GeoBoxToVolumeTest.cpp
@@ -0,0 +1,66 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 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 http://mozilla.org/MPL/2.0/.
+
+#include <boost/test/unit_test.hpp>
+
+// switching format off to avoid conflicting declaration in GeoModel
+// needed until Acts GeoModel bumps to 6.5
+//clang-format off
+#include "Acts/Plugins/GeoModel/GeoModelDetectorObjectFactory.hpp"
+//clang-format on
+#include "Acts/Geometry/CuboidVolumeBounds.hpp"
+#include "Acts/Geometry/GeometryContext.hpp"
+#include "Acts/Plugins/GeoModel/GeoModelConverters.hpp"
+#include "Acts/Surfaces/RectangleBounds.hpp"
+#include "Acts/Surfaces/Surface.hpp"
+#include "Acts/Surfaces/SurfaceBounds.hpp"
+#include "Acts/Surfaces/TrapezoidBounds.hpp"
+#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
+
+#include <GeoModelKernel/GeoBox.h>
+#include <GeoModelKernel/GeoFullPhysVol.h>
+#include <GeoModelKernel/GeoLogVol.h>
+#include <GeoModelKernel/GeoMaterial.h>
+#include <GeoModelKernel/GeoTrap.h>
+#include <GeoModelKernel/GeoTrd.h>
+#include <GeoModelKernel/GeoVPhysVol.h>
+
+BOOST_AUTO_TEST_SUITE(GeoModelPlugin)
+
+// GeoBox conversion test case
+BOOST_AUTO_TEST_CASE(GeoBoxToSensitiveConversion) {
+  auto material = make_intrusive<GeoMaterial>("Material", 1.0);
+  // Let's create a GeoFullPhysVol object
+
+  // (BOX object) - XY
+  std::vector<double> hls = {100, 200, 2};
+  auto box = new GeoBox(hls[0], hls[1], hls[2]);
+  auto logBox = new GeoLogVol("Box", box, material);
+  auto physBox = make_intrusive<GeoFullPhysVol>(logBox);
+
+  // create pars for conversion
+  Acts::GeoModelDetectorObjectFactory::Config gmConfig;
+  gmConfig.convertBox = {"Box"};
+  Acts::GeometryContext gContext;
+  Acts::GeoModelDetectorObjectFactory::Cache gmCache;
+
+  // create factory instance
+  Acts::GeoModelDetectorObjectFactory factory(gmConfig);
+
+  factory.convertFpv("Box", physBox, gmCache, gContext);
+  std::shared_ptr<Acts::Experimental::DetectorVolume> volumeBox =
+      gmCache.boundingBoxes[0];
+  const auto* bounds =
+      dynamic_cast<const Acts::CuboidVolumeBounds*>(&volumeBox->volumeBounds());
+  std::vector<Acts::ActsScalar> convHls = bounds->values();
+  for (long unsigned int i = 0; i < hls.size(); i++) {
+    BOOST_CHECK(hls[i] == convHls[i]);
+  }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/Tests/UnitTests/Plugins/GeoModel/GeoDetectorObjectTest.cpp b/Tests/UnitTests/Plugins/GeoModel/GeoDetectorObjectTest.cpp
index 6839b3defe2..ae155533c30 100644
--- a/Tests/UnitTests/Plugins/GeoModel/GeoDetectorObjectTest.cpp
+++ b/Tests/UnitTests/Plugins/GeoModel/GeoDetectorObjectTest.cpp
@@ -26,72 +26,127 @@
 #include <GeoModelKernel/GeoFullPhysVol.h>
 #include <GeoModelKernel/GeoLogVol.h>
 #include <GeoModelKernel/GeoMaterial.h>
-#include <GeoModelKernel/GeoSimplePolygonBrep.h>
 #include <GeoModelKernel/GeoTrd.h>
 #include <GeoModelKernel/GeoTube.h>
 
 BOOST_AUTO_TEST_SUITE(GeoModelDetObj)
 
-BOOST_AUTO_TEST_CASE(GeoModelDetectorObjectFactory) {
+struct GeoDims {
+  std::vector<double> boxO;
+  std::vector<double> boxI;
+  std::vector<double> tube;
+  std::vector<std::vector<double>> trapVerts;
+  std::vector<double> trapHls;
+  std::vector<std::vector<double>> polyVerts;
+};
+void test(const Acts::GeoModelDetectorObjectFactory::Cache& cache,
+          GeoModelDetObj::GeoDims geoDims) {
+  for (const auto& box : cache.boundingBoxes) {
+    const Acts::VolumeBounds& bounds = box->volumeBounds();
+    for (long unsigned int i = 0; i < geoDims.boxO.size(); i++) {
+      BOOST_CHECK(geoDims.boxO[i] == bounds.values()[i]);
+    }
+    std::vector<const Acts::Surface*> surfaces = box->surfaces();
+
+    for (auto surface : surfaces) {
+      const Acts::SurfaceBounds& sbounds = surface->bounds();
+      // check straws
+      if (surface->type() == Acts::Surface::SurfaceType::Straw) {
+        const auto* lineBounds =
+            dynamic_cast<const Acts::LineBounds*>(&sbounds);
+        BOOST_CHECK(geoDims.tube[1] == lineBounds->get(Acts::LineBounds::eR));
+        BOOST_CHECK(geoDims.tube[2] ==
+                    lineBounds->get(Acts::LineBounds::eHalfLengthZ));
+      }
+      // rectangle Surface check corner position without trf
+      if (sbounds.type() == Acts::SurfaceBounds::eRectangle) {
+        double csxmin = sbounds.values()[0];
+        double csymin = sbounds.values()[1];
+        double csxmax = sbounds.values()[2];
+        double csymax = sbounds.values()[3];
+        BOOST_CHECK(geoDims.boxI[0] == -csxmin);
+        BOOST_CHECK(geoDims.boxI[1] == -csymin);
+        BOOST_CHECK(geoDims.boxI[0] == csxmax);
+        BOOST_CHECK(geoDims.boxI[1] == csymax);
+      }
+      // trap Surface without trf
+      if (sbounds.type() == Acts::SurfaceBounds::eTrapezoid) {
+        const auto* trapBounds =
+            dynamic_cast<const Acts::TrapezoidBounds*>(&sbounds);
+        std::vector<Acts::Vector2> trapVerts = trapBounds->vertices();
+
+        for (long unsigned int i = 0; i < trapVerts.size(); i++) {
+          BOOST_CHECK(trapVerts[i][0] == geoDims.trapVerts[i][0]);
+          BOOST_CHECK(trapVerts[i][1] == geoDims.trapVerts[i][1]);
+        }
+      }
+    }
+  }
+}
+struct GeoGeometry {
+  std::vector<GeoIntrusivePtr<GeoFullPhysVol>> fpvs;
+  GeoDims dim;
+};
+GeoGeometry constructGeoModel() {
   // define materials
   GeoIntrusivePtr<GeoMaterial> material(new GeoMaterial("Material", 1.0));
   GeoIntrusivePtr<GeoMaterial> al(new GeoMaterial("Aluminium", 1.0));
 
   // define dimensions
-  double gmBoxHlx = 100, gmBoxHly = 200, gmBoxHlz = 2;
-  double gmTubeRmin = 5, gmTubeRmax = 6, gmTubeHlz = 100;
-  double gmRsurfHlx = 100, gmRsurfHly = 200, gmRsurfHlz = 2;
-  double gmPolyZ = 2;
-  std::vector<double> trapXVerts = {-103, 103, 183, -183};
-  std::vector<double> trapYVerts = {-50, -50, 50, 50};
-  std::vector<double> polyXVerts = {-60, 60, 153, 123, -123, -153};
-  std::vector<double> polyYVerts = {-50, -50, 0, 50, 50, 0};
+  GeoDims geoDims;
+  geoDims.boxO = {100, 200, 2};
+  geoDims.boxI = {100, 150, 1};
+  geoDims.trapVerts = {{-103, -50}, {103, -50}, {183, 50}, {-183, 50}};
+  geoDims.polyVerts = {{-60, -50}, {60, -50},  {153, 0},
+                       {123, 50},  {-123, 50}, {-153, 0}};
+  geoDims.tube = {5, 6, 100};
+  geoDims.trapHls = {
+      fabs(geoDims.trapVerts[0][0] - geoDims.trapVerts[1][0]) / 2,
+      fabs(geoDims.trapVerts[2][0] - geoDims.trapVerts[3][0]) / 2,
+      fabs(geoDims.trapVerts[0][1] - geoDims.trapVerts[2][1]) / 2};
 
   // create shapes
-  GeoIntrusivePtr<GeoBox> boxXY(new GeoBox(gmBoxHlx, gmBoxHly, gmBoxHlz));
-  GeoIntrusivePtr<GeoTube> tube(new GeoTube(gmTubeRmin, gmTubeRmax, gmTubeHlz));
+  GeoIntrusivePtr<GeoBox> boxXY(
+      new GeoBox(geoDims.boxO[0], geoDims.boxO[1], geoDims.boxO[2]));
+  GeoIntrusivePtr<GeoTube> tube(
+      new GeoTube(geoDims.tube[0], geoDims.tube[1], geoDims.tube[2]));
   GeoIntrusivePtr<GeoBox> ssurface(
-      new GeoBox(gmRsurfHlx, gmRsurfHly, gmRsurfHlz));
-  double halfX1 = fabs(trapXVerts[0] - trapXVerts[1]) / 2;
-  double halfX2 = fabs(trapXVerts[2] - trapXVerts[3]) / 2;
-  double halfY1 = fabs(trapYVerts[0] - trapYVerts[2]) / 2;
-  GeoIntrusivePtr<GeoTrd> trd(new GeoTrd(1, 1, halfX1, halfX2, halfY1));
-  GeoIntrusivePtr<GeoSimplePolygonBrep> trap(new GeoSimplePolygonBrep(gmPolyZ));
-  for (long unsigned int i = 0; i < trapXVerts.size(); i++) {
-    trap->addVertex(trapXVerts[i], trapYVerts[i]);
-  }
-  GeoIntrusivePtr<GeoSimplePolygonBrep> poly(new GeoSimplePolygonBrep(gmPolyZ));
-  for (long unsigned int i = 0; i < polyXVerts.size(); i++) {
-    poly->addVertex(polyXVerts[i], polyYVerts[i]);
-  }
+      new GeoBox(geoDims.boxI[0], geoDims.boxI[1], geoDims.boxI[2]));
+  GeoIntrusivePtr<GeoTrd> trd(new GeoTrd(
+      1, 1, geoDims.trapHls[0], geoDims.trapHls[1], geoDims.trapHls[2]));
 
   // create logvols
   GeoIntrusivePtr<GeoLogVol> logXY(
-      new GeoLogVol("LogVolumeXY", boxXY, material.get()));
+      new GeoLogVol("LogVolumeXY", boxXY, material));
   GeoIntrusivePtr<GeoLogVol> logTube(new GeoLogVol("LogTube", tube, al));
   GeoIntrusivePtr<GeoLogVol> logSurface(
       new GeoLogVol("LogSurface", ssurface, al));
-  GeoIntrusivePtr<GeoLogVol> logTrap(new GeoLogVol("LogTrap", trap, al));
   GeoIntrusivePtr<GeoLogVol> logTrd(new GeoLogVol("LogTrd", trd, al));
-  GeoIntrusivePtr<GeoLogVol> logPoly(new GeoLogVol("LogPoly", poly, al));
 
   // create physvols
-  GeoIntrusivePtr<GeoFullPhysVol> fphysXY(new GeoFullPhysVol(logXY));
-  GeoIntrusivePtr<GeoFullPhysVol> physTube(new GeoFullPhysVol(logTube));
-  GeoIntrusivePtr<GeoFullPhysVol> physSurface(new GeoFullPhysVol(logSurface));
-  GeoIntrusivePtr<GeoFullPhysVol> physTrap(new GeoFullPhysVol(logTrap));
-  GeoIntrusivePtr<GeoFullPhysVol> physTrd(new GeoFullPhysVol(logTrd));
-  GeoIntrusivePtr<GeoFullPhysVol> physPoly(new GeoFullPhysVol(logPoly));
+  std::vector<GeoIntrusivePtr<GeoFullPhysVol>> fpvs;
+  fpvs.push_back(new GeoFullPhysVol(logXY));
+  fpvs.push_back(new GeoFullPhysVol(logTube));
+  fpvs.push_back(new GeoFullPhysVol(logSurface));
+  fpvs.push_back(new GeoFullPhysVol(logTrd));
+  GeoGeometry ret;
+  ret.fpvs = fpvs;
+  ret.dim = geoDims;
+  return ret;
+}
 
-  // build hierarchy
-  fphysXY->add(physTube);
-  fphysXY->add(physSurface);
-  fphysXY->add(physTrap);
-  fphysXY->add(physTrd);
-  fphysXY->add(physPoly);
+BOOST_AUTO_TEST_CASE(GeoModelDetectorObjectFactory) {
+  GeoGeometry geom = constructGeoModel();
+  GeoDims geoDims = geom.dim;
+  std::vector<GeoIntrusivePtr<GeoFullPhysVol>> fpvs = geom.fpvs;
 
-  PVConstLink physVol{fphysXY};
-  auto rBounds = std::make_shared<Acts::RectangleBounds>(100, 200);
+  int index = 0;
+  GeoFullPhysVol* parentVol = fpvs[index];
+  fpvs.erase(fpvs.begin() + index);
+  // build hierarchy
+  for (const auto& fpv : fpvs) {
+    parentVol->add(fpv);
+  }
 
   // create pars for conversion
   Acts::GeoModelDetectorObjectFactory::Config gmConfig;
@@ -101,60 +156,11 @@ BOOST_AUTO_TEST_CASE(GeoModelDetectorObjectFactory) {
 
   // create factory instance
   Acts::GeoModelDetectorObjectFactory factory(gmConfig);
-
   // convert GeoFullPhysVol
-  factory.convertFpv("LogVolumeXY", fphysXY, gmCache, gContext);
+  factory.convertFpv("LogVolumeXY", parentVol, gmCache, gContext);
 
   // checking the dimension of the converted bounding boxes
-  for (const auto& box : gmCache.boundingBoxes) {
-    const Acts::VolumeBounds& bounds = box->volumeBounds();
-    BOOST_CHECK(gmBoxHlx == bounds.values()[0]);
-    BOOST_CHECK(gmBoxHly == bounds.values()[1]);
-    BOOST_CHECK(gmBoxHlz == bounds.values()[2]);
-    std::vector<const Acts::Surface*> surfaces = box->surfaces();
-
-    for (auto surface : surfaces) {
-      const Acts::SurfaceBounds& sbounds = surface->bounds();
-      // check straws
-      if (surface->type() == Acts::Surface::SurfaceType::Straw) {
-        const auto* lineBounds =
-            dynamic_cast<const Acts::LineBounds*>(&sbounds);
-        BOOST_CHECK(gmTubeRmax == lineBounds->get(Acts::LineBounds::eR));
-        BOOST_CHECK(gmTubeHlz ==
-                    lineBounds->get(Acts::LineBounds::eHalfLengthZ));
-      }
-      // rectangle Surface check corner position without trf
-      if (sbounds.type() == Acts::SurfaceBounds::eRectangle) {
-        double csxmin = sbounds.values()[0];
-        double csymin = sbounds.values()[1];
-        double csxmax = sbounds.values()[2];
-        double csymax = sbounds.values()[3];
-        BOOST_CHECK(gmRsurfHlx == -csxmin);
-        BOOST_CHECK(gmRsurfHly == -csymin);
-        BOOST_CHECK(gmRsurfHlx == csxmax);
-        BOOST_CHECK(gmRsurfHly == csymax);
-      }
-      // trap Surface without trf
-      if (sbounds.type() == Acts::SurfaceBounds::eTrapezoid) {
-        const auto* trapBounds =
-            dynamic_cast<const Acts::TrapezoidBounds*>(&sbounds);
-        std::vector<Acts::Vector2> trapVerts = trapBounds->vertices();
-        for (long unsigned int i = 0; i < trapVerts.size(); i++) {
-          BOOST_CHECK(trapVerts[i][0] == trapXVerts[i]);
-          BOOST_CHECK(trapVerts[i][1] == trapYVerts[i]);
-        }
-      }
-      if (sbounds.type() == Acts::SurfaceBounds::eDiamond) {
-        const auto* polyBounds =
-            dynamic_cast<const Acts::DiamondBounds*>(&sbounds);
-        std::vector<Acts::Vector2> polyVerts = polyBounds->vertices();
-        for (long unsigned int i = 0; i < polyVerts.size(); i++) {
-          BOOST_CHECK(polyVerts[i][0] == polyXVerts[i]);
-          BOOST_CHECK(polyVerts[i][1] == polyYVerts[i]);
-        }
-      }
-    }
-  }
+  test(gmCache, geoDims);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/Tests/UnitTests/Plugins/GeoModel/GeoPolyConverterTests.cpp b/Tests/UnitTests/Plugins/GeoModel/GeoPolyConverterTests.cpp
new file mode 100644
index 00000000000..ebbbd422055
--- /dev/null
+++ b/Tests/UnitTests/Plugins/GeoModel/GeoPolyConverterTests.cpp
@@ -0,0 +1,104 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 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 http://mozilla.org/MPL/2.0/.
+
+#include <boost/test/unit_test.hpp>
+
+#include "Acts/Plugins/GeoModel/GeoModelDetectorObjectFactory.hpp"
+#include "Acts/Plugins/GeoModel/GeoModelReader.hpp"
+#include "Acts/Surfaces/CylinderBounds.hpp"
+#include "Acts/Surfaces/DiamondBounds.hpp"
+#include "Acts/Surfaces/LineBounds.hpp"
+#include "Acts/Surfaces/PlaneSurface.hpp"
+#include "Acts/Surfaces/RectangleBounds.hpp"
+#include "Acts/Surfaces/StrawSurface.hpp"
+#include "Acts/Surfaces/Surface.hpp"
+#include "Acts/Surfaces/TrapezoidBounds.hpp"
+#include "Acts/Utilities/Logger.hpp"
+
+#include <typeinfo>
+
+#include <GeoModelKernel/GeoBox.h>
+#include <GeoModelKernel/GeoFullPhysVol.h>
+#include <GeoModelKernel/GeoLogVol.h>
+#include <GeoModelKernel/GeoMaterial.h>
+#include <GeoModelKernel/GeoSimplePolygonBrep.h>
+#include <GeoModelKernel/GeoTrd.h>
+#include <GeoModelKernel/GeoTube.h>
+
+BOOST_AUTO_TEST_SUITE(GeoModelPoyVol)
+
+BOOST_AUTO_TEST_CASE(GeoModelDetectorObjectFactory) {
+  auto al = new GeoMaterial("Aluminium", 1.0);
+
+  std::vector<std::vector<double>> trapVerts = {
+      {-103, -50}, {103, -50}, {183, 50}, {-183, 50}};
+  std::vector<std::vector<double>> polyVerts = {
+      {-60, -50}, {60, -50}, {153, 0}, {123, 50}, {-123, 50}, {-153, 0}};
+  std::vector<std::vector<double>> errVerts = {
+      {60, -50}, {153, 0}, {123, 50}, {-123, 50}, {-153, 0}};
+  double poly_z = 2;
+
+  auto trap = new GeoSimplePolygonBrep(poly_z);
+  for (const auto& tVert : trapVerts) {
+    trap->addVertex(tVert[0], tVert[1]);
+  }
+  auto poly = new GeoSimplePolygonBrep(poly_z);
+  for (const auto& pVert : polyVerts) {
+    poly->addVertex(pVert[0], pVert[1]);
+  }
+  auto err = new GeoSimplePolygonBrep(poly_z);
+  for (const auto& eVert : errVerts) {
+    err->addVertex(eVert[0], eVert[1]);
+  }
+  auto logTrap = new GeoLogVol("LogTrap", trap, al);
+  auto logPoly = new GeoLogVol("LogPoly", poly, al);
+  auto logErr = new GeoLogVol("LogErr", err, al);
+
+  auto physTrap = new GeoFullPhysVol(logTrap);
+  auto physPoly = new GeoFullPhysVol(logPoly);
+  auto physErr = new GeoFullPhysVol(logErr);
+  // create pars for conversion
+  Acts::GeoModelDetectorObjectFactory::Config gmConfig;
+  Acts::GeometryContext gContext;
+  Acts::GeoModelDetectorObjectFactory::Cache trapCache;
+  Acts::GeoModelDetectorObjectFactory::Cache polyCache;
+  Acts::GeoModelDetectorObjectFactory::Cache errCache;
+
+  // create factory instance
+  Acts::GeoModelDetectorObjectFactory factory(gmConfig);
+
+  // convert GeoFullPhysVol (to surfaces)
+  factory.convertFpv("Trap", physTrap, trapCache, gContext);
+  factory.convertFpv("Poly", physPoly, polyCache, gContext);
+  BOOST_CHECK_THROW(factory.convertFpv("Error", physErr, errCache, gContext),
+                    std::runtime_error);
+
+  Acts::GeoModelSensitiveSurface trapSensSurface =
+      trapCache.sensitiveSurfaces[0];
+  Acts::GeoModelSensitiveSurface polySensSurface =
+      polyCache.sensitiveSurfaces[0];
+  std::shared_ptr<Acts::Surface> polySurface = std::get<1>(polySensSurface);
+  std::shared_ptr<Acts::Surface> trapSurface = std::get<1>(trapSensSurface);
+
+  const auto* polyBounds =
+      dynamic_cast<const Acts::DiamondBounds*>(&polySurface->bounds());
+  std::vector<Acts::Vector2> convPolyVerts = polyBounds->vertices();
+  for (long unsigned int i = 0; i < polyVerts.size(); i++) {
+    BOOST_CHECK(polyVerts[i][0] == convPolyVerts[i][0]);
+    BOOST_CHECK(polyVerts[i][1] == convPolyVerts[i][1]);
+  }
+
+  const auto* trapBounds =
+      dynamic_cast<const Acts::TrapezoidBounds*>(&trapSurface->bounds());
+  std::vector<Acts::Vector2> convTrapVerts = trapBounds->vertices();
+  for (long unsigned int i = 0; i < trapVerts.size(); i++) {
+    BOOST_CHECK(trapVerts[i][0] == convTrapVerts[i][0]);
+    BOOST_CHECK(trapVerts[i][1] == convTrapVerts[i][1]);
+  }
+}
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/Tests/UnitTests/Plugins/GeoModel/GeoTrdToVolumeTests.cpp b/Tests/UnitTests/Plugins/GeoModel/GeoTrdToVolumeTests.cpp
new file mode 100644
index 00000000000..6f8794bce0e
--- /dev/null
+++ b/Tests/UnitTests/Plugins/GeoModel/GeoTrdToVolumeTests.cpp
@@ -0,0 +1,72 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 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 http://mozilla.org/MPL/2.0/.
+
+#include <boost/test/unit_test.hpp>
+
+// switching format off to avoid conflicting declaration in GeoModel
+// needed until Acts GeoModel bumps to 6.5
+//clang-format off
+#include "Acts/Plugins/GeoModel/GeoModelDetectorObjectFactory.hpp"
+//clang-format on
+#include "Acts/Geometry/GeometryContext.hpp"
+#include "Acts/Geometry/TrapezoidVolumeBounds.hpp"
+#include "Acts/Plugins/GeoModel/GeoModelConverters.hpp"
+#include "Acts/Surfaces/Surface.hpp"
+#include "Acts/Surfaces/SurfaceBounds.hpp"
+#include "Acts/Surfaces/TrapezoidBounds.hpp"
+#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
+
+#include <GeoModelKernel/GeoFullPhysVol.h>
+#include <GeoModelKernel/GeoLogVol.h>
+#include <GeoModelKernel/GeoMaterial.h>
+#include <GeoModelKernel/GeoTrd.h>
+
+BOOST_AUTO_TEST_SUITE(GeoModelPlugin)
+
+// GeoBox conversion test case
+BOOST_AUTO_TEST_CASE(GeoTrdToVolumeConversion) {
+  auto material = new GeoMaterial("Material", 1.0);
+  // Let's create a GeoFullPhysVol object
+  double geoHlX1 = 2, geoHlX2 = 2, geoHlY1 = 50, geoHlY2 = 80, geoHlZ = 60;
+  auto trd = new GeoTrd(geoHlX1, geoHlX1, geoHlY1, geoHlY2, geoHlZ);
+  auto logTrd = new GeoLogVol("Trd", trd, material);
+  auto physTrd = make_intrusive<GeoFullPhysVol>(logTrd);
+
+  // this should produce an error while converting
+  auto errTrd = new GeoTrd(2, 3, 25, 40, 30);
+  auto errLogTrd = new GeoLogVol("Trd", errTrd, material);
+  auto errPhysTrd = make_intrusive<GeoFullPhysVol>(errLogTrd);
+
+  // create pars for conversion
+  Acts::GeoModelDetectorObjectFactory::Config gmConfig;
+  gmConfig.convertBox = {"Trd"};
+  Acts::GeometryContext gContext;
+  Acts::GeoModelDetectorObjectFactory::Cache gmCache;
+  Acts::GeoModelDetectorObjectFactory::Cache errCache;
+
+  // create factory instance
+  Acts::GeoModelDetectorObjectFactory factory(gmConfig);
+
+  // test error case
+  BOOST_CHECK_THROW(factory.convertFpv("Trd", errPhysTrd, errCache, gContext),
+                    std::runtime_error);
+  factory.convertFpv("Trd", physTrd, gmCache, gContext);
+  std::shared_ptr<Acts::Experimental::DetectorVolume> volumeTrd =
+      gmCache.boundingBoxes[0];
+  const auto* bounds = dynamic_cast<const Acts::TrapezoidVolumeBounds*>(
+      &volumeTrd->volumeBounds());
+  std::vector<Acts::ActsScalar> convHls = bounds->values();
+  // note: GeoTrd and Acts use different coordinates
+  BOOST_CHECK(geoHlX1 == convHls[3]);
+  BOOST_CHECK(geoHlX2 == convHls[3]);
+  BOOST_CHECK(geoHlY1 == convHls[0]);
+  BOOST_CHECK(geoHlY2 == convHls[1]);
+  BOOST_CHECK(geoHlZ == convHls[2]);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/Tests/UnitTests/Plugins/GeoModel/GeoTubeToVolumeTest.cpp b/Tests/UnitTests/Plugins/GeoModel/GeoTubeToVolumeTest.cpp
new file mode 100644
index 00000000000..c6cd459b35a
--- /dev/null
+++ b/Tests/UnitTests/Plugins/GeoModel/GeoTubeToVolumeTest.cpp
@@ -0,0 +1,64 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 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 http://mozilla.org/MPL/2.0/.
+
+#include <boost/test/unit_test.hpp>
+
+// In order to avoid conflicts with declarations in Geomodel that is fixed in
+// v3.5
+//  clang-formal off
+#include "Acts/Plugins/GeoModel/GeoModelDetectorObjectFactory.hpp"
+// clang-formal on
+#include "Acts/Geometry/CylinderVolumeBounds.hpp"
+#include "Acts/Geometry/GeometryContext.hpp"
+#include "Acts/Plugins/GeoModel/GeoModelConverters.hpp"
+#include "Acts/Surfaces/Surface.hpp"
+#include "Acts/Surfaces/SurfaceBounds.hpp"
+#include "Acts/Surfaces/TrapezoidBounds.hpp"
+#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
+
+#include <GeoModelKernel/GeoFullPhysVol.h>
+#include <GeoModelKernel/GeoLogVol.h>
+#include <GeoModelKernel/GeoMaterial.h>
+#include <GeoModelKernel/GeoTrap.h>
+#include <GeoModelKernel/GeoTube.h>
+#include <GeoModelKernel/GeoVPhysVol.h>
+
+BOOST_AUTO_TEST_SUITE(GeoModelPlugin)
+
+// GeoBox conversion test case
+BOOST_AUTO_TEST_CASE(GeoBoxToSensitiveConversion) {
+  auto material = make_intrusive<GeoMaterial>("Material", 1.0);
+  // Let's create a GeoFullPhysVol object
+
+  // (BOX object) - XY
+  std::vector<double> dims = {5, 6, 50};
+  auto tube = new GeoTube(dims[0], dims[1], dims[2]);
+  auto logTube = new GeoLogVol("Tube", tube, material);
+  auto physTube = make_intrusive<GeoFullPhysVol>(logTube);
+
+  // create pars for conversion
+  Acts::GeoModelDetectorObjectFactory::Config gmConfig;
+  gmConfig.convertBox = {"Tube"};
+  Acts::GeometryContext gContext;
+  Acts::GeoModelDetectorObjectFactory::Cache gmCache;
+
+  // create factory instance
+  Acts::GeoModelDetectorObjectFactory factory(gmConfig);
+
+  factory.convertFpv("Tube", physTube, gmCache, gContext);
+  std::shared_ptr<Acts::Experimental::DetectorVolume> volumeTube =
+      gmCache.boundingBoxes[0];
+  const auto* bounds = dynamic_cast<const Acts::CylinderVolumeBounds*>(
+      &volumeTube->volumeBounds());
+  std::vector<Acts::ActsScalar> convDims = bounds->values();
+  for (long unsigned int i = 0; i < dims.size(); i++) {
+    BOOST_CHECK(dims[i] == convDims[i]);
+  }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/Tests/UnitTests/Plugins/TGeo/TGeoArb8ConversionTests.cpp b/Tests/UnitTests/Plugins/TGeo/TGeoArb8ConversionTests.cpp
index c632e37347f..ea21c2be64b 100644
--- a/Tests/UnitTests/Plugins/TGeo/TGeoArb8ConversionTests.cpp
+++ b/Tests/UnitTests/Plugins/TGeo/TGeoArb8ConversionTests.cpp
@@ -36,9 +36,9 @@ namespace Acts::Test {
 
 GeometryContext tgContext = GeometryContext();
 
-ViewConfig red({200, 0, 0});
-ViewConfig green({0, 200, 0});
-ViewConfig blue({0, 0, 200});
+ViewConfig red{.color = {200, 0, 0}};
+ViewConfig green{.color = {0, 200, 0}};
+ViewConfig blue{.color = {0, 0, 200}};
 
 /// @brief Unit test to convert a TGeoTrd2 into a Plane
 ///
diff --git a/Tests/UnitTests/Plugins/TGeo/TGeoBBoxConversionTests.cpp b/Tests/UnitTests/Plugins/TGeo/TGeoBBoxConversionTests.cpp
index f94428ad773..8d2fcd7e654 100644
--- a/Tests/UnitTests/Plugins/TGeo/TGeoBBoxConversionTests.cpp
+++ b/Tests/UnitTests/Plugins/TGeo/TGeoBBoxConversionTests.cpp
@@ -35,9 +35,9 @@ namespace Acts::Test {
 
 GeometryContext tgContext = GeometryContext();
 
-ViewConfig red({200, 0, 0});
-ViewConfig green({0, 200, 0});
-ViewConfig blue({0, 0, 200});
+ViewConfig red{.color = {200, 0, 0}};
+ViewConfig green{.color = {0, 200, 0}};
+ViewConfig blue{.color = {0, 0, 200}};
 
 /// @brief Unit test to convert a Bbox into a Plane
 ///
diff --git a/Tests/UnitTests/Plugins/TGeo/TGeoTrd1ConversionTests.cpp b/Tests/UnitTests/Plugins/TGeo/TGeoTrd1ConversionTests.cpp
index ebdcaf8ddf1..56392407168 100644
--- a/Tests/UnitTests/Plugins/TGeo/TGeoTrd1ConversionTests.cpp
+++ b/Tests/UnitTests/Plugins/TGeo/TGeoTrd1ConversionTests.cpp
@@ -40,9 +40,9 @@ namespace Acts::Test {
 
 GeometryContext tgContext = GeometryContext();
 
-ViewConfig red({200, 0, 0});
-ViewConfig green({0, 200, 0});
-ViewConfig blue({0, 0, 200});
+ViewConfig red{.color = {200, 0, 0}};
+ViewConfig green{.color = {0, 200, 0}};
+ViewConfig blue{.color = {0, 0, 200}};
 
 /// @brief Unit test to convert a TGeoTrd1 into a Plane
 ///
diff --git a/Tests/UnitTests/Plugins/TGeo/TGeoTrd2ConversionTests.cpp b/Tests/UnitTests/Plugins/TGeo/TGeoTrd2ConversionTests.cpp
index cf9bea4acd7..1feca6e1d99 100644
--- a/Tests/UnitTests/Plugins/TGeo/TGeoTrd2ConversionTests.cpp
+++ b/Tests/UnitTests/Plugins/TGeo/TGeoTrd2ConversionTests.cpp
@@ -40,9 +40,9 @@ namespace Acts::Test {
 
 GeometryContext tgContext = GeometryContext();
 
-ViewConfig red({200, 0, 0});
-ViewConfig green({0, 200, 0});
-ViewConfig blue({0, 0, 200});
+ViewConfig red{.color = {200, 0, 0}};
+ViewConfig green{.color = {0, 200, 0}};
+ViewConfig blue{.color = {0, 0, 200}};
 
 /// @brief Unit test to convert a TGeoTrd2 into a Plane
 ///
diff --git a/Tests/UnitTests/Plugins/TGeo/TGeoTubeConversionTests.cpp b/Tests/UnitTests/Plugins/TGeo/TGeoTubeConversionTests.cpp
index dd9340de81c..18ac5edfd18 100644
--- a/Tests/UnitTests/Plugins/TGeo/TGeoTubeConversionTests.cpp
+++ b/Tests/UnitTests/Plugins/TGeo/TGeoTubeConversionTests.cpp
@@ -40,9 +40,9 @@ namespace Acts::Test {
 
 GeometryContext tgContext = GeometryContext();
 
-ViewConfig red({200, 0, 0});
-ViewConfig green({0, 200, 0});
-ViewConfig blue({0, 0, 200});
+ViewConfig red{.color = {200, 0, 0}};
+ViewConfig green{.color = {0, 200, 0}};
+ViewConfig blue{.color = {0, 0, 200}};
 
 std::vector<std::string> allowedAxes = {"XY*", "Xy*", "xy*", "xY*",
                                         "YX*", "yx*", "yX*", "Yx*"};
diff --git a/cmake/ActsConfig.cmake.in b/cmake/ActsConfig.cmake.in
index ee68567d7d2..b66c5ae3544 100644
--- a/cmake/ActsConfig.cmake.in
+++ b/cmake/ActsConfig.cmake.in
@@ -103,6 +103,7 @@ if(PluginDetray IN_LIST Acts_COMPONENTS)
   find_dependency(vecmem @vecmem_VERSION@ CONFIG EXACT)
   find_dependency(covfie @cofvie_VERSION@ CONFIG EXACT)
   find_dependency(algebra-plugins @algebra-plugins_VERSION@ CONFIG EXACT)
+  find_dependency(actsvg @actsvg_VERSION@ CONFIG EXACT)
   find_dependency(detray @detray_VERSION@ CONFIG EXACT)
 endif()
 
diff --git a/cmake/ActsExternSources.cmake b/cmake/ActsExternSources.cmake
index 2a0cb12d33c..3352fec959a 100644
--- a/cmake/ActsExternSources.cmake
+++ b/cmake/ActsExternSources.cmake
@@ -1,40 +1,40 @@
 set(ACTS_ACTSVG_SOURCE
-    "URL;https://github.com/acts-project/actsvg/archive/refs/tags/v0.4.47.tar.gz;URL_HASH;SHA256=aeb3927f8db1c7c9b8afa76adaa720013aa03a01032c8d5f457f623e2b04a172"
+    "URL;https://github.com/acts-project/actsvg/archive/refs/tags/v${_acts_actsvg_version}.tar.gz;URL_HASH;SHA256=aeb3927f8db1c7c9b8afa76adaa720013aa03a01032c8d5f457f623e2b04a172"
     CACHE STRING
     "Source to take ACTSVG from"
 )
 mark_as_advanced(ACTS_ACTSVG_SOURCE)
 
 set(ACTS_VECMEM_SOURCE
-    "URL;https://github.com/acts-project/vecmem/archive/refs/tags/v1.4.0.tar.gz;URL_HASH;SHA256=545dfb4de4f9f3d773eef6a0e3297ebf981bb81950930d0991ad739e31ab16af"
+    "URL;https://github.com/acts-project/vecmem/archive/refs/tags/v${_acts_vecmem_version}.tar.gz;URL_HASH;SHA256=545dfb4de4f9f3d773eef6a0e3297ebf981bb81950930d0991ad739e31ab16af"
     CACHE STRING
     "Source to take VECMEM from"
 )
 mark_as_advanced(ACTS_VECMEM_SOURCE)
 
 set(ACTS_ALGEBRAPLUGINS_SOURCE
-    "URL;https://github.com/acts-project/algebra-plugins/archive/refs/tags/v0.22.0.tar.gz;URL_HASH;SHA256=6fde02181c1b856c0a17a1925f0969798eecd5e3d6f2a87ea2eb365b6c948cc1"
+    "URL;https://github.com/acts-project/algebra-plugins/archive/refs/tags/v${_acts_algebraplugins_version}.tar.gz;URL_HASH;SHA256=6fde02181c1b856c0a17a1925f0969798eecd5e3d6f2a87ea2eb365b6c948cc1"
     CACHE STRING
     "Source to take ALGEBRAPLUGINS from"
 )
 mark_as_advanced(ACTS_ALGEBRAPLUGINS_SOURCE)
 
 set(ACTS_COVFIE_SOURCE
-    "URL;https://github.com/acts-project/covfie/archive/refs/tags/v0.10.0.tar.gz;URL_HASH;SHA256=d44142b302ffc193ad2229f1d2cc6d8d720dd9da8c37989ada4f23018f86c964"
+    "URL;https://github.com/acts-project/covfie/archive/refs/tags/v${_acts_covfie_version}.tar.gz;URL_HASH;SHA256=d44142b302ffc193ad2229f1d2cc6d8d720dd9da8c37989ada4f23018f86c964"
     CACHE STRING
     "Source to take COVFIE from"
 )
 mark_as_advanced(ACTS_COVFIE_SOURCE)
 
 set(ACTS_DETRAY_SOURCE
-    "URL;https://github.com/acts-project/detray/archive/refs/tags/v0.72.1.tar.gz;URL_HASH;SHA256=6cc8d34bc0d801338e9ab142c4a9884d19d9c02555dbb56972fab86b98d0f75b"
+    "URL;https://github.com/acts-project/detray/archive/refs/tags/v${_acts_detray_version}.tar.gz;URL_HASH;SHA256=249066c138eac4114032e8d558f3a05885140a809332a347c7667978dbff54ee"
     CACHE STRING
     "Source to take DETRAY from"
 )
 mark_as_advanced(ACTS_DETRAY_SOURCE)
 
 set(ACTS_TRACCC_SOURCE
-    "URL;https://github.com/acts-project/traccc/archive/refs/tags/v0.15.0.tar.gz;URL_HASH;SHA256=1a9a1d0d2f6c4a7773eae3119b1e044fb52031ca49dfc88e6dc4ab8a11df167e"
+    "URL;https://github.com/acts-project/traccc/archive/refs/tags/v${_acts_traccc_version}.tar.gz;URL_HASH;SHA256=86e0ebe7364d3a2106301d50a89feef583470da53c9dae6d1430dcc6eda7dba9"
     CACHE STRING
     "Source to take TRACCC from"
 )
@@ -48,7 +48,7 @@ set(ACTS_FRNN_SOURCE
 mark_as_advanced(ACTS_FRNN_SOURCE)
 
 set(ACTS_NLOHMANNJSON_SOURCE
-    "URL;https://github.com/nlohmann/json/archive/refs/tags/v3.10.5.tar.gz;URL_HASH;SHA256=5daca6ca216495edf89d167f808d1d03c4a4d929cef7da5e10f135ae1540c7e4"
+    "URL;https://github.com/nlohmann/json/archive/refs/tags/v${_acts_nlohmanjson_version}.tar.gz;URL_HASH;SHA256=5daca6ca216495edf89d167f808d1d03c4a4d929cef7da5e10f135ae1540c7e4"
     CACHE STRING
     "Source to take nlohmann_json from"
 )
@@ -62,7 +62,7 @@ set(ACTS_EIGEN3_SOURCE
 mark_as_advanced(ACTS_EIGEN3_SOURCE)
 
 set(ACTS_PYBIND11_SOURCE
-    "GIT_REPOSITORY;https://github.com/pybind/pybind11.git;GIT_TAG;v2.13.1"
+    "GIT_REPOSITORY;https://github.com/pybind/pybind11.git;GIT_TAG;v${_acts_pybind11_version}"
     CACHE STRING
     "Source to take pybind11 from"
 )
diff --git a/docs/core/propagation.md b/docs/core/propagation.md
index 0c9b8259f76..dbd7b37a1b9 100644
--- a/docs/core/propagation.md
+++ b/docs/core/propagation.md
@@ -110,15 +110,15 @@ The {class}`Acts::StraightLineStepper` is a very stripped down stepper that just
 
 The {class}`Acts::EigenStepper` implements the same functionality as the ATLAS stepper, however, the stepping code is rewritten by using `Eigen` primitives. Thus, it also uses a 4th-order Runge-Kutta algorithm for the integration of the EOM. Additionally, the {class}`Acts::EigenStepper` allows to customize the concrete integration step via **extension**.
 
-The extension encapsulate the relevant equations for different environments. There exists a {struct}`Acts::EigenStepperDefaultExtension` that is suited for propagation in a vacuum, and the {struct}`Acts::EigenStepperDenseEnvironmentExtension`, that contains additional code to handle the propagation inside materials. Which extension is used is decided by the user.
+The extension encapsulate the relevant equations for different environments. There exists a {struct}`Acts::EigenStepperDefaultExtension` that is suited for propagation in a vacuum, and the {struct}`Acts::EigenStepperDenseExtension`, that contains additional code to handle the propagation inside materials. Which extension is used is decided by the user.
 
 The extension can be configured via the {class}`Acts::EigenStepper`:
 
 ```c++
-using Stepper = Acts::EigenStepper<Acts::EigenStepperDenseEnvironmentExtension>;
+using Stepper = Acts::EigenStepper<Acts::EigenStepperDenseExtension>;
 ```
 
-By default, the {class}`Acts::EigenStepper` only uses the {struct}`Acts::EigenStepperDenseEnvironmentExtension`.
+By default, the {class}`Acts::EigenStepper` only uses the {struct}`Acts::EigenStepperDenseExtension`.
 
 ### MultiEigenStepperLoop
 
diff --git a/docs/misc/spack.md b/docs/misc/spack.md
index e6706be7e9c..f71c4be762a 100644
--- a/docs/misc/spack.md
+++ b/docs/misc/spack.md
@@ -33,22 +33,30 @@ the environment every time you open a new shell.
 With the Spack environment activated, you are ready to install ACTS'
 dependencies. You can either do this manually, or you can rely on Spack's
 definition of how to do this. To use the Spack definition, execute the
-following command (tuned for ACTS version 36.1.0):
+following command (tuned for ACTS version 36.1.0; make sure you update the
+version number to match the version of ACTS you want to build):
+
+```console
+$ spack install --add --only dependencies "acts@36.1.0"
+```
+
+This specification will suffice to build the core ACTS library. If you want to
+build ACTS plugins, you will need to add additional _variants_; the following
+is a spec which can be used to build ACTS and all its plugins:
 
 ```console
 $ spack install --add --only dependencies "acts@36.1.0+tgeo+geomodel+podio+edm4hep+examples+odd+fatras+json+dd4hep+geant4+fatras_geant4+hepmc3+pythia8+python+svg+traccc"
 ```
 
-The string starting with `acts` in the command above is the so-called _spec_,
+The string starting with `acts` in the commands above is the so-called _spec_,
 and it consists of three parts. The first part is the name of the package,
 which is `acts`. The second part is the version of the package, in this case
 `36.1.0`; Spack will pull in a set of dependencies suitable for that given
 version, so it is recommended to tune the version number to match the version
 of ACTS you want to build. The final part is a series of variants, marked with
 the `+` symbol. The command above allows you to build virtually all components
-of ACTS, but it also pulls in a large number of dependencies. You can
-optionally remove variants you do not need in order to speed up the Spack
-build.
+of ACTS, but it also pulls in a large number of dependencies. You can remove
+variants you do not need in order to speed up the Spack build.
 
 Once Spack has concretized and installed the ACTS dependencies, you can build
 ACTS as normal using CMake.
diff --git a/thirdparty/detray/CMakeLists.txt b/thirdparty/detray/CMakeLists.txt
index c24b260b0ff..5b2bcee1d59 100644
--- a/thirdparty/detray/CMakeLists.txt
+++ b/thirdparty/detray/CMakeLists.txt
@@ -30,16 +30,31 @@ set(DETRAY_CUSTOM_SCALARTYPE
     "Scalar type to use in the Detray code"
 )
 
-set(DETRAY_BUILD_TESTING
+set(DETRAY_BUILD_TEST_UTILS
+    ON
+    CACHE BOOL
+    "Turn on the build of the Detray test utilities"
+)
+set(DETRAY_BUILD_UNITTESTS
     OFF
     CACHE BOOL
     "Turn off the build of the Detray unit tests"
 )
+set(DETRAY_BUILD_INTEGRATIONTESTS
+    OFF
+    CACHE BOOL
+    "Turn off the build of the Detray integration tests"
+)
 set(DETRAY_BUILD_TUTORIALS
     OFF
     CACHE BOOL
     "Turn off the build of the Detray tutorials"
 )
+set(DETRAY_BUILD_BENCHMARKS
+    OFF
+    CACHE BOOL
+    "Turn off the build of the Detray benchmarks"
+)
 set(DETRAY_EIGEN_PLUGIN
     ON
     CACHE BOOL
diff --git a/thirdparty/traccc/CMakeLists.txt b/thirdparty/traccc/CMakeLists.txt
index 6271b5ef0c3..705593f34d8 100644
--- a/thirdparty/traccc/CMakeLists.txt
+++ b/thirdparty/traccc/CMakeLists.txt
@@ -15,12 +15,7 @@ message(STATUS "Building traccc as part of the Acts project")
 set(TRACCC_VERSION "${_acts_traccc_version}")
 
 # Declare where to get traccc from.
-FetchContent_Declare(
-    traccc
-    ${ACTS_TRACCC_SOURCE}
-    # Needed until https://github.com/acts-project/traccc/pull/682 and https://github.com/acts-project/traccc/pull/683 are deployed
-    PATCH_COMMAND patch -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/warnings.diff
-)
+FetchContent_Declare(traccc ${ACTS_TRACCC_SOURCE})
 
 if(ACTS_CUSTOM_SCALARTYPE)
     set(ACTS_TRACCC_SCALARTYPE ${ACTS_CUSTOM_SCALARTYPE})
diff --git a/thirdparty/traccc/warnings.diff b/thirdparty/traccc/warnings.diff
deleted file mode 100644
index 78fa1f37118..00000000000
--- a/thirdparty/traccc/warnings.diff
+++ /dev/null
@@ -1,40 +0,0 @@
-diff --git a/core/include/traccc/seeding/spacepoint_binning_helper.hpp b/core/include/traccc/seeding/spacepoint_binning_helper.hpp
-index 56a068d4..5a4f2ff2 100644
---- a/core/include/traccc/seeding/spacepoint_binning_helper.hpp
-+++ b/core/include/traccc/seeding/spacepoint_binning_helper.hpp
-@@ -99,7 +99,8 @@ inline std::pair<detray::axis2::circular<>, detray::axis2::regular<>> get_axes(
- 
-     scalar zBinSize = grid_config.cotThetaMax * grid_config.deltaRMax;
-     detray::dindex zBins = std::max(
--        1, (int)std::floor((grid_config.zMax - grid_config.zMin) / zBinSize));
-+        1, static_cast<int>(
-+               std::floor((grid_config.zMax - grid_config.zMin) / zBinSize)));
- 
-     detray::axis2::regular m_z_axis{zBins, grid_config.zMin, grid_config.zMax,
-                                     mr};
-diff --git a/io/src/csv/read_cells.cpp b/io/src/csv/read_cells.cpp
-index a80d8f92..1451202f 100644
---- a/io/src/csv/read_cells.cpp
-+++ b/io/src/csv/read_cells.cpp
-@@ -58,7 +58,7 @@ traccc::cell_module get_module(const std::uint64_t geometry_id,
-         }
- 
-         // Set the value on the module description.
--        result.placement = (*geom)[result.surface_link.value()];
-+        result.placement = geom->at(result.surface_link.value());
-     }
- 
-     // Find/set the digitization configuration of the detector module.
-diff --git a/io/src/csv/read_spacepoints.cpp b/io/src/csv/read_spacepoints.cpp
-index b2a38aba..41922683 100644
---- a/io/src/csv/read_spacepoints.cpp
-+++ b/io/src/csv/read_spacepoints.cpp
-@@ -59,7 +59,7 @@ void read_spacepoints(spacepoint_reader_output& out, std::string_view filename,
-             m[iohit.geometry_id] = link;
-             cell_module mod;
-             mod.surface_link = detray::geometry::barcode{iohit.geometry_id};
--            mod.placement = geom[iohit.geometry_id];
-+            mod.placement = geom.at(iohit.geometry_id);
-             result_modules.push_back(mod);
-         }
-