diff --git a/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.hpp b/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.hpp
index 76490d76eae..39f967b3494 100644
--- a/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.hpp
+++ b/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.hpp
@@ -43,7 +43,7 @@ class GreedyAmbiguityResolution {
     std::uint32_t maximumIterations = 1000;
 
     /// Minimum number of measurement to form a track.
-    size_t nMeasurementsMin = 7;
+    std::size_t nMeasurementsMin = 7;
   };
 
   struct State {
diff --git a/Core/include/Acts/Clusterization/Clusterization.hpp b/Core/include/Acts/Clusterization/Clusterization.hpp
index 806b5c70e2e..39a1dc9b656 100644
--- a/Core/include/Acts/Clusterization/Clusterization.hpp
+++ b/Core/include/Acts/Clusterization/Clusterization.hpp
@@ -42,7 +42,7 @@ struct Connect1D {
 };
 
 // Default connection type based on GridDim
-template <typename Cell, size_t GridDim = 2>
+template <typename Cell, std::size_t GridDim = 2>
 struct DefaultConnect {
   static_assert(GridDim != 1 && GridDim != 2,
                 "Only grid dimensions of 1 or 2 are supported");
@@ -67,7 +67,7 @@ struct DefaultConnect<Cell, 1> : public Connect1D<Cell> {};
 ///
 /// @param [in] cells the cell collection to be labeled
 /// @param [in] connect the connection type (see DefaultConnect)
-template <typename CellCollection, size_t GridDim = 2,
+template <typename CellCollection, std::size_t GridDim = 2,
           typename Connect =
               DefaultConnect<typename CellCollection::value_type, GridDim>>
 void labelClusters(CellCollection& cells, Connect connect = Connect());
@@ -80,13 +80,14 @@ void labelClusters(CellCollection& cells, Connect connect = Connect());
 ///   void clusterAddCell(Cluster&, const Cell&)
 ///
 /// @return nothing
-template <typename CellCollection, typename ClusterCollection, size_t GridDim>
+template <typename CellCollection, typename ClusterCollection,
+          std::size_t GridDim>
 ClusterCollection mergeClusters(CellCollection& /*cells*/);
 
 /// @brief createClusters
 /// Convenience function which runs both labelClusters and createClusters.
 template <typename CellCollection, typename ClusterCollection,
-          size_t GridDim = 2,
+          std::size_t GridDim = 2,
           typename Connect =
               DefaultConnect<typename CellCollection::value_type, GridDim>>
 ClusterCollection createClusters(CellCollection& cells,
diff --git a/Core/include/Acts/Clusterization/Clusterization.ipp b/Core/include/Acts/Clusterization/Clusterization.ipp
index 13ccee6acb0..44f8abd1267 100644
--- a/Core/include/Acts/Clusterization/Clusterization.ipp
+++ b/Core/include/Acts/Clusterization/Clusterization.ipp
@@ -15,7 +15,7 @@ namespace Acts::Ccl::internal {
 
 // Machinery for validating generic Cell/Cluster types at compile-time
 
-template <typename, size_t, typename T = void>
+template <typename, std::size_t, typename T = void>
 struct cellTypeHasRequiredFunctions : std::false_type {};
 
 template <typename T>
@@ -42,14 +42,14 @@ struct clusterTypeHasRequiredFunctions<
     std::void_t<decltype(clusterAddCell(std::declval<T>(), std::declval<U>()))>>
     : std::true_type {};
 
-template <size_t GridDim>
+template <std::size_t GridDim>
 constexpr void staticCheckGridDim() {
   static_assert(
       GridDim == 1 || GridDim == 2,
       "mergeClusters is only defined for grid dimensions of 1 or 2. ");
 }
 
-template <typename T, size_t GridDim>
+template <typename T, std::size_t GridDim>
 constexpr void staticCheckCellType() {
   constexpr bool hasFns = cellTypeHasRequiredFunctions<T, GridDim>();
   static_assert(hasFns,
@@ -67,7 +67,7 @@ constexpr void staticCheckClusterType() {
                 "'void clusterAddCell(Cluster&, const Cell&)'");
 }
 
-template <typename Cell, size_t GridDim>
+template <typename Cell, std::size_t GridDim>
 struct Compare {
   static_assert(GridDim != 1 && GridDim != 2,
                 "Only grid dimensions of 1 or 2 are supported");
@@ -101,7 +101,7 @@ struct Compare<Cell, 1> {
 // wrapping, but it's way slower
 class DisjointSets {
  public:
-  explicit DisjointSets(size_t initial_size = 128)
+  explicit DisjointSets(std::size_t initial_size = 128)
       : m_size(initial_size),
         m_rank(m_size),
         m_parent(m_size),
@@ -114,31 +114,32 @@ class DisjointSets {
       m_size *= 2;
       m_rank.resize(m_size);
       m_parent.resize(m_size);
-      m_ds = boost::disjoint_sets<size_t*, size_t*>(&m_rank[0], &m_parent[0]);
+      m_ds = boost::disjoint_sets<std::size_t*, std::size_t*>(&m_rank[0],
+                                                              &m_parent[0]);
     }
     m_ds.make_set(m_globalId);
     return static_cast<Label>(m_globalId++);
   }
 
-  void unionSet(size_t x, size_t y) { m_ds.union_set(x, y); }
-  Label findSet(size_t x) { return static_cast<Label>(m_ds.find_set(x)); }
+  void unionSet(std::size_t x, std::size_t y) { m_ds.union_set(x, y); }
+  Label findSet(std::size_t x) { return static_cast<Label>(m_ds.find_set(x)); }
 
  private:
-  size_t m_globalId = 1;
-  size_t m_size;
-  std::vector<size_t> m_rank;
-  std::vector<size_t> m_parent;
-  boost::disjoint_sets<size_t*, size_t*> m_ds;
+  std::size_t m_globalId = 1;
+  std::size_t m_size;
+  std::vector<std::size_t> m_rank;
+  std::vector<std::size_t> m_parent;
+  boost::disjoint_sets<std::size_t*, std::size_t*> m_ds;
 };
 
-template <size_t BufSize>
+template <std::size_t BufSize>
 struct ConnectionsBase {
-  size_t nconn{0};
+  std::size_t nconn{0};
   std::array<Label, BufSize> buf;
   ConnectionsBase() { std::fill(buf.begin(), buf.end(), NO_LABEL); }
 };
 
-template <size_t GridDim>
+template <std::size_t GridDim>
 class Connections {};
 
 // On 1-D grid, cells have 1 backward neighbor
@@ -154,7 +155,7 @@ struct Connections<2> : public ConnectionsBase<4> {
 };
 
 // Cell collection logic
-template <typename Cell, typename Connect, size_t GridDim>
+template <typename Cell, typename Connect, std::size_t GridDim>
 Connections<GridDim> getConnections(typename std::vector<Cell>::iterator it,
                                     std::vector<Cell>& set, Connect connect) {
   Connections<GridDim> seen;
@@ -242,7 +243,7 @@ ConnectResult Connect1D<Cell>::operator()(const Cell& ref,
   return deltaCol == 1 ? ConnectResult::eConn : ConnectResult::eNoConnStop;
 }
 
-template <size_t GridDim>
+template <std::size_t GridDim>
 void recordEquivalences(const internal::Connections<GridDim> seen,
                         internal::DisjointSets& ds) {
   // Sanity check: first element should always have
@@ -250,7 +251,7 @@ void recordEquivalences(const internal::Connections<GridDim> seen,
   if (seen.nconn > 0 && seen.buf[0] == NO_LABEL) {
     throw std::logic_error("seen.nconn > 0 but seen.buf[0] == NO_LABEL");
   }
-  for (size_t i = 1; i < seen.nconn; i++) {
+  for (std::size_t i = 1; i < seen.nconn; i++) {
     // Sanity check: since connection lookup is always backward
     // while iteration is forward, all connected cells found here
     // should have a label
@@ -264,7 +265,7 @@ void recordEquivalences(const internal::Connections<GridDim> seen,
   }
 }
 
-template <typename CellCollection, size_t GridDim, typename Connect>
+template <typename CellCollection, std::size_t GridDim, typename Connect>
 void labelClusters(CellCollection& cells, Connect connect) {
   using Cell = typename CellCollection::value_type;
   internal::staticCheckCellType<Cell, GridDim>();
@@ -296,7 +297,7 @@ void labelClusters(CellCollection& cells, Connect connect) {
 }
 
 template <typename CellCollection, typename ClusterCollection,
-          size_t GridDim = 2>
+          std::size_t GridDim = 2>
 ClusterCollection mergeClusters(CellCollection& cells) {
   using Cell = typename CellCollection::value_type;
   using Cluster = typename ClusterCollection::value_type;
@@ -315,8 +316,8 @@ ClusterCollection mergeClusters(CellCollection& cells) {
   return internal::mergeClustersImpl<CellCollection, ClusterCollection>(cells);
 }
 
-template <typename CellCollection, typename ClusterCollection, size_t GridDim,
-          typename Connect>
+template <typename CellCollection, typename ClusterCollection,
+          std::size_t GridDim, typename Connect>
 ClusterCollection createClusters(CellCollection& cells, Connect connect) {
   using Cell = typename CellCollection::value_type;
   using Cluster = typename ClusterCollection::value_type;
diff --git a/Core/include/Acts/Definitions/TrackParametrization.hpp b/Core/include/Acts/Definitions/TrackParametrization.hpp
index 2405294cc92..952fe24c512 100644
--- a/Core/include/Acts/Definitions/TrackParametrization.hpp
+++ b/Core/include/Acts/Definitions/TrackParametrization.hpp
@@ -89,8 +89,8 @@ namespace Acts {
 // Ensure bound track parameters definition is valid.
 static_assert(std::is_enum_v<BoundIndices>,
               "'BoundIndices' must be an enum type");
-static_assert(std::is_convertible_v<BoundIndices, size_t>,
-              "'BoundIndices' must be convertible to size_t");
+static_assert(std::is_convertible_v<BoundIndices, std::size_t>,
+              "'BoundIndices' must be convertible to std::size_t");
 // Only the order can be user-defined
 static_assert(BoundIndices::eBoundSize == 6u,
               "Bound track parameters must have six components");
@@ -98,8 +98,8 @@ static_assert(BoundIndices::eBoundSize == 6u,
 // Ensure free track parameters definition is valid.
 static_assert(std::is_enum_v<FreeIndices>,
               "'FreeIndices' must be an enum type");
-static_assert(std::is_convertible_v<FreeIndices, size_t>,
-              "'FreeIndices' must be convertible to size_t");
+static_assert(std::is_convertible_v<FreeIndices, std::size_t>,
+              "'FreeIndices' must be convertible to std::size_t");
 // Only the order can be user-defined
 static_assert(FreeIndices::eFreeSize == 8u,
               "Free track parameters must have eight components");
diff --git a/Core/include/Acts/Detector/Detector.hpp b/Core/include/Acts/Detector/Detector.hpp
index adbccfce213..62e4605ae99 100644
--- a/Core/include/Acts/Detector/Detector.hpp
+++ b/Core/include/Acts/Detector/Detector.hpp
@@ -151,7 +151,7 @@ class Detector : public std::enable_shared_from_this<Detector> {
   DetectorVolumeUpdator m_detectorVolumeUpdator;
 
   /// Name/index map to find volumes by name and detect duplicates
-  std::unordered_map<std::string, size_t> m_volumeNameIndex;
+  std::unordered_map<std::string, std::size_t> m_volumeNameIndex;
 
   /// Geometry Id hierarchy map of all sensitive surfaces
   GeometryHierarchyMap<const Surface*> m_sensitiveHierarchyMap;
diff --git a/Core/include/Acts/Detector/DetectorVolume.hpp b/Core/include/Acts/Detector/DetectorVolume.hpp
index 1f831960520..b516a48b205 100644
--- a/Core/include/Acts/Detector/DetectorVolume.hpp
+++ b/Core/include/Acts/Detector/DetectorVolume.hpp
@@ -221,7 +221,7 @@ class DetectorVolume : public std::enable_shared_from_this<DetectorVolume> {
   /// @param nseg is the number of segments to approximate
   ///
   /// @return an Extent object
-  Extent extent(const GeometryContext& gctx, size_t nseg = 1) const;
+  Extent extent(const GeometryContext& gctx, std::size_t nseg = 1) const;
 
   /// Initialize/update the navigation status in this environment
   ///
@@ -361,7 +361,8 @@ class DetectorVolume : public std::enable_shared_from_this<DetectorVolume> {
   /// @param nseg is the number of segments to approximate
   ///
   /// @return a boolean indicating if the objects are properly contained
-  bool checkContainment(const GeometryContext& gctx, size_t nseg = 1) const;
+  bool checkContainment(const GeometryContext& gctx,
+                        std::size_t nseg = 1) const;
 
   /// build the bounding box
   ///
@@ -469,7 +470,7 @@ struct AllSurfacesExtractor {
   inline static const std::vector<const Surface*> extract(
       [[maybe_unused]] const GeometryContext& gctx,
       const NavigationState& nState,
-      [[maybe_unused]] const std::vector<size_t>& indices = {}) {
+      [[maybe_unused]] const std::vector<std::size_t>& indices = {}) {
     if (nState.currentVolume == nullptr) {
       throw std::runtime_error(
           "AllSurfacesExtractor: no detector volume given.");
@@ -491,7 +492,7 @@ struct IndexedSurfacesExtractor {
   /// @return a vector of raw Surface pointers
   inline static const std::vector<const Surface*> extract(
       [[maybe_unused]] const GeometryContext& gctx,
-      const NavigationState& nState, const std::vector<size_t>& indices) {
+      const NavigationState& nState, const std::vector<std::size_t>& indices) {
     if (nState.currentVolume == nullptr) {
       throw std::runtime_error(
           "IndexedSurfacesExtractor: no detector volume given.");
@@ -519,7 +520,7 @@ struct AllSubVolumesExtractor {
   inline static const std::vector<const DetectorVolume*> extract(
       [[maybe_unused]] const GeometryContext& gctx,
       const NavigationState& nState,
-      [[maybe_unused]] const std::vector<size_t>& indices = {}) {
+      [[maybe_unused]] const std::vector<std::size_t>& indices = {}) {
     if (nState.currentVolume == nullptr) {
       throw std::runtime_error(
           "AllSubVolumesExtractor: no detector volume given.");
@@ -539,7 +540,7 @@ struct IndexedSubVolumesExtractor {
   /// @return a vector of raw DetectorVolume pointers
   inline static const std::vector<const DetectorVolume*> extract(
       [[maybe_unused]] const GeometryContext& gctx,
-      const NavigationState& nState, const std::vector<size_t>& indices) {
+      const NavigationState& nState, const std::vector<std::size_t>& indices) {
     if (nState.currentVolume == nullptr) {
       throw std::runtime_error(
           "AllSubVolumesExtractor: no detector volume given.");
diff --git a/Core/include/Acts/Detector/KdtSurfacesProvider.hpp b/Core/include/Acts/Detector/KdtSurfacesProvider.hpp
index 0798c33aed2..906afa44ef1 100644
--- a/Core/include/Acts/Detector/KdtSurfacesProvider.hpp
+++ b/Core/include/Acts/Detector/KdtSurfacesProvider.hpp
@@ -29,7 +29,7 @@ namespace Experimental {
 /// It also deals with the conversion from global query to
 /// KDTree lookup positions
 ///
-template <size_t kDIM = 2u, size_t bSize = 100u,
+template <std::size_t kDIM = 2u, std::size_t bSize = 100u,
           typename reference_generator =
               detail::PolyhedronReferenceGenerator<1u, false>>
 class KdtSurfaces {
@@ -161,7 +161,7 @@ class KdtSurfaces {
 ///
 /// This allows to create small region based callable structs at
 /// configuration level that are then connected to an InternalStructureBuilder
-template <size_t kDIM = 2u, size_t bSize = 100u,
+template <std::size_t kDIM = 2u, std::size_t bSize = 100u,
           typename reference_generator =
               detail::PolyhedronReferenceGenerator<1u, false>>
 class KdtSurfacesProvider : public ISurfacesProvider {
diff --git a/Core/include/Acts/Detector/detail/ReferenceGenerators.hpp b/Core/include/Acts/Detector/detail/ReferenceGenerators.hpp
index 46b9d9b03b8..cdd08563f41 100644
--- a/Core/include/Acts/Detector/detail/ReferenceGenerators.hpp
+++ b/Core/include/Acts/Detector/detail/ReferenceGenerators.hpp
@@ -67,7 +67,7 @@ struct BinningValueReferenceGenerator {
 ///
 /// The grid filling then completes the empty bins in between and
 /// expands if necessary.
-template <size_t nSEGS = 1u, bool aBARY = true>
+template <std::size_t nSEGS = 1u, bool aBARY = true>
 struct PolyhedronReferenceGenerator {
   /// Helper to access the Center point of for filling the grid
   ///
diff --git a/Core/include/Acts/Detector/detail/SupportHelper.hpp b/Core/include/Acts/Detector/detail/SupportHelper.hpp
index 70f8ef895d6..176433e665c 100644
--- a/Core/include/Acts/Detector/detail/SupportHelper.hpp
+++ b/Core/include/Acts/Detector/detail/SupportHelper.hpp
@@ -62,7 +62,8 @@ std::vector<std::shared_ptr<Surface>> discSupport(
 ///
 /// @note this modifies the layerSurfaces and toAllIndices
 void addSupport(std::vector<std::shared_ptr<Surface>>& layerSurfaces,
-                std::vector<size_t>& assignToAll, const Extent& layerExtent,
+                std::vector<std::size_t>& assignToAll,
+                const Extent& layerExtent,
                 Surface::SurfaceType layerRepresentation,
                 const std::array<ActsScalar, 5u>& layerSupportValues,
                 std::optional<Transform3> layerTransform = std::nullopt,
diff --git a/Core/include/Acts/Digitization/CartesianSegmentation.hpp b/Core/include/Acts/Digitization/CartesianSegmentation.hpp
index ec5891f08d4..0ca1dfff200 100644
--- a/Core/include/Acts/Digitization/CartesianSegmentation.hpp
+++ b/Core/include/Acts/Digitization/CartesianSegmentation.hpp
@@ -50,7 +50,7 @@ class CartesianSegmentation : public Segmentation {
   /// @param numCellsX is the number of cells in X
   /// @param numCellsY is the number of cells in Y
   CartesianSegmentation(const std::shared_ptr<const PlanarBounds>& mBounds,
-                        size_t numCellsX, size_t numCellsY = 1);
+                        std::size_t numCellsX, std::size_t numCellsY = 1);
 
   /// @todo constructor from BinUtilities for more complex readouts
   ///
diff --git a/Core/include/Acts/Digitization/DigitizationCell.hpp b/Core/include/Acts/Digitization/DigitizationCell.hpp
index 13fe11d9cb5..8044b9db178 100644
--- a/Core/include/Acts/Digitization/DigitizationCell.hpp
+++ b/Core/include/Acts/Digitization/DigitizationCell.hpp
@@ -14,12 +14,12 @@ namespace Acts {
 /// @brief pair of ints for definition of a cell
 struct DigitizationCell final {
   // identification and data
-  size_t channel0 = 0;
-  size_t channel1 = 1;
+  std::size_t channel0 = 0;
+  std::size_t channel1 = 1;
   float data = 0.;
 
   // construct them
-  DigitizationCell(size_t ch0, size_t ch1, float d = 0.)
+  DigitizationCell(std::size_t ch0, std::size_t ch1, float d = 0.)
       : channel0(ch0), channel1(ch1), data(d) {}
 
   /// To merge cells in case they are at the same position
diff --git a/Core/include/Acts/EventData/Measurement.hpp b/Core/include/Acts/EventData/Measurement.hpp
index 7e9eeb9cf64..4255f70c93d 100644
--- a/Core/include/Acts/EventData/Measurement.hpp
+++ b/Core/include/Acts/EventData/Measurement.hpp
@@ -43,9 +43,9 @@ namespace Acts {
 /// on). Both variants add additional complications. Since the geometry object
 /// is not required anyway (as discussed above), not storing it removes all
 /// these complications altogether.
-template <typename indices_t, size_t kSize>
+template <typename indices_t, std::size_t kSize>
 class Measurement {
-  static constexpr size_t kFullSize = detail::kParametersSize<indices_t>;
+  static constexpr std::size_t kFullSize = detail::kParametersSize<indices_t>;
 
   using Subspace = detail::FixedSizeSubspace<kFullSize, kSize>;
 
@@ -98,7 +98,7 @@ class Measurement {
   const SourceLink& sourceLink() const { return m_source; }
 
   /// Number of measured parameters.
-  static constexpr size_t size() { return kSize; }
+  static constexpr std::size_t size() { return kSize; }
 
   /// Check if a specific parameter is part of this measurement.
   bool contains(indices_t i) const { return m_subspace.contains(i); }
@@ -107,7 +107,7 @@ class Measurement {
   constexpr std::array<indices_t, kSize> indices() const {
     std::array<uint8_t, kSize> subInds = m_subspace.indices();
     std::array<indices_t, kSize> inds{};
-    for (size_t i = 0; i < kSize; i++) {
+    for (std::size_t i = 0; i < kSize; i++) {
       inds[i] = static_cast<indices_t>(subInds[i]);
     }
     return inds;
@@ -211,10 +211,10 @@ namespace detail {
 //     -> VariantMeasurementGenerator<..., 1, 2, 3, 4>
 //     -> VariantMeasurementGenerator<..., 0, 1, 2, 3, 4>
 //
-template <typename indices_t, size_t kN, size_t... kSizes>
+template <typename indices_t, std::size_t kN, std::size_t... kSizes>
 struct VariantMeasurementGenerator
     : VariantMeasurementGenerator<indices_t, kN - 1u, kN, kSizes...> {};
-template <typename indices_t, size_t... kSizes>
+template <typename indices_t, std::size_t... kSizes>
 struct VariantMeasurementGenerator<indices_t, 0u, kSizes...> {
   using Type = std::variant<Measurement<indices_t, kSizes>...>;
 };
diff --git a/Core/include/Acts/EventData/MeasurementHelpers.hpp b/Core/include/Acts/EventData/MeasurementHelpers.hpp
index 14eec96155a..10264d22595 100644
--- a/Core/include/Acts/EventData/MeasurementHelpers.hpp
+++ b/Core/include/Acts/EventData/MeasurementHelpers.hpp
@@ -19,7 +19,7 @@ namespace detail {
 /// Helper functor for @c visit_measurement. This is the actual functor given
 /// to @c template_switch.
 /// @tparam I Compile time int value
-template <size_t I>
+template <std::size_t I>
 struct visit_measurement_callable {
   /// The invoked function. It will perform the head/top-left corner
   /// extraction, and pass thee results to the given lambda.
@@ -52,7 +52,7 @@ struct visit_measurement_callable {
 /// @param dim The actual dimension as a runtime value
 /// @param lambda The lambda to call with the statically sized subsets
 template <typename L, typename A, typename B>
-auto visit_measurement(A&& param, B&& cov, size_t dim, L&& lambda) {
+auto visit_measurement(A&& param, B&& cov, std::size_t dim, L&& lambda) {
   return template_switch<detail::visit_measurement_callable, 1, eBoundSize>(
       dim, param, cov, lambda);
 }
@@ -65,7 +65,7 @@ auto visit_measurement(A&& param, B&& cov, size_t dim, L&& lambda) {
 /// @param lambda The generic lambda instance to call
 /// @return Returns the lambda return value
 template <typename L>
-auto visit_measurement(size_t dim, L&& lambda) {
+auto visit_measurement(std::size_t dim, L&& lambda) {
   return template_switch_lambda<1, eBoundSize>(dim, lambda);
 }
 
diff --git a/Core/include/Acts/EventData/MultiTrajectory.hpp b/Core/include/Acts/EventData/MultiTrajectory.hpp
index 5aa42d8cf88..b4daebb2e1b 100644
--- a/Core/include/Acts/EventData/MultiTrajectory.hpp
+++ b/Core/include/Acts/EventData/MultiTrajectory.hpp
@@ -87,7 +87,7 @@ class TransitiveConstPointer {
 };
 
 /// Type construction helper for coefficients and associated covariances.
-template <size_t Size, bool ReadOnlyMaps = true>
+template <std::size_t Size, bool ReadOnlyMaps = true>
 struct Types {
   enum {
     Flags = Eigen::ColMajor | Eigen::AutoAlign,
@@ -111,7 +111,7 @@ struct Types {
 }  // namespace detail_lt
 
 // This is public
-template <size_t M, bool ReadOnly = true>
+template <std::size_t M, bool ReadOnly = true>
 struct TrackStateTraits {
   using Parameters =
       typename detail_lt::Types<eBoundSize, ReadOnly>::CoefficientsMap;
@@ -133,7 +133,7 @@ namespace detail_lt {
 /// @tparam SourceLink Type to link back to an original measurement
 /// @tparam M         Maximum number of measurement dimensions
 /// @tparam ReadOnly  true for read-only access to underlying storage
-template <typename trajectory_t, size_t M, bool ReadOnly = true>
+template <typename trajectory_t, std::size_t M, bool ReadOnly = true>
 class TrackStateProxy {
  public:
   using Parameters = typename TrackStateTraits<M, ReadOnly>::Parameters;
@@ -141,14 +141,14 @@ class TrackStateProxy {
   using ConstParameters = typename TrackStateTraits<M, true>::Parameters;
   using ConstCovariance = typename TrackStateTraits<M, true>::Covariance;
 
-  template <size_t N>
+  template <std::size_t N>
   using Measurement = typename TrackStateTraits<N, ReadOnly>::Measurement;
-  template <size_t N>
+  template <std::size_t N>
   using MeasurementCovariance =
       typename TrackStateTraits<N, ReadOnly>::MeasurementCovariance;
-  template <size_t N>
+  template <std::size_t N>
   using ConstMeasurement = typename TrackStateTraits<N, true>::Measurement;
-  template <size_t N>
+  template <std::size_t N>
   using ConstMeasurementCovariance =
       typename TrackStateTraits<N, true>::MeasurementCovariance;
 
@@ -758,7 +758,7 @@ class TrackStateProxy {
   /// dimensions.
   /// @return The measurement vector
   /// @note Const version
-  template <size_t measdim>
+  template <std::size_t measdim>
   ConstMeasurement<measdim> calibrated() const {
     assert(has<hashString("calibrated")>());
     return m_traj->self().template measurement<measdim>(m_istate);
@@ -768,7 +768,7 @@ class TrackStateProxy {
   /// dimensions.
   /// @return The measurement vector
   /// @note Mutable version
-  template <size_t measdim, bool RO = ReadOnly,
+  template <std::size_t measdim, bool RO = ReadOnly,
             typename = std::enable_if_t<!RO>>
   Measurement<measdim> calibrated() {
     assert(has<hashString("calibrated")>());
@@ -779,7 +779,7 @@ class TrackStateProxy {
   /// is located in the top left corner, everything else is zeroed.
   /// @return The measurement covariance matrix
   /// @note Const version
-  template <size_t measdim>
+  template <std::size_t measdim>
   ConstMeasurementCovariance<measdim> calibratedCovariance() const {
     assert(has<hashString("calibratedCov")>());
     return m_traj->self().template measurementCovariance<measdim>(m_istate);
@@ -789,7 +789,7 @@ class TrackStateProxy {
   /// is located in the top left corner, everything else is zeroed.
   /// @return The measurement covariance matrix
   /// @note Mutable version
-  template <size_t measdim, bool RO = ReadOnly,
+  template <std::size_t measdim, bool RO = ReadOnly,
             typename = std::enable_if_t<!RO>>
   MeasurementCovariance<measdim> calibratedCovariance() {
     assert(has<hashString("calibratedCov")>());
@@ -878,7 +878,7 @@ class TrackStateProxy {
   ///   be overwritten!**. Also assumes none of the calibrated components is
   ///   *invalid* (i.e. unset) for this TrackState.
   /// @note This does not set the reference surface.
-  template <size_t kMeasurementSize, bool RO = ReadOnly,
+  template <std::size_t kMeasurementSize, bool RO = ReadOnly,
             typename = std::enable_if_t<!RO>>
   void setCalibrated(
       const Acts::Measurement<BoundIndices, kMeasurementSize>& meas) {
@@ -898,7 +898,7 @@ class TrackStateProxy {
     setProjector(meas.projector());
   }
 
-  void allocateCalibrated(size_t measdim) {
+  void allocateCalibrated(std::size_t measdim) {
     m_traj->allocateCalibrated(m_istate, measdim);
   }
 
@@ -971,7 +971,7 @@ class TrackStateProxy {
 };
 
 /// Helper type that wraps two iterators
-template <bool reverse, typename trajectory_t, size_t M, bool ReadOnly>
+template <bool reverse, typename trajectory_t, std::size_t M, bool ReadOnly>
 class TrackStateRange {
   using ProxyType = TrackStateProxy<trajectory_t, M, ReadOnly>;
   using IndexType = typename ProxyType::IndexType;
@@ -1361,7 +1361,7 @@ class MultiTrajectory {
   /// @tparam measdim the measurement dimension
   /// @param measIdx Index into the measurement column
   /// @return Mutable proxy
-  template <size_t measdim, bool RO = ReadOnly,
+  template <std::size_t measdim, bool RO = ReadOnly,
             typename = std::enable_if_t<!RO>>
   constexpr typename TrackStateProxy::template Measurement<measdim> measurement(
       IndexType measIdx) {
@@ -1372,7 +1372,7 @@ class MultiTrajectory {
   /// @tparam measdim the measurement dimension
   /// @param measIdx Index into the measurement column
   /// @return Const proxy
-  template <size_t measdim>
+  template <std::size_t measdim>
   constexpr typename ConstTrackStateProxy::template Measurement<measdim>
   measurement(IndexType measIdx) const {
     return self().template measurement_impl<measdim>(measIdx);
@@ -1383,7 +1383,7 @@ class MultiTrajectory {
   /// @tparam measdim the measurement dimension
   /// @param covIdx Index into the measurement covariance column
   /// @return Mutable proxy
-  template <size_t measdim, bool RO = ReadOnly,
+  template <std::size_t measdim, bool RO = ReadOnly,
             typename = std::enable_if_t<!RO>>
   constexpr typename TrackStateProxy::template MeasurementCovariance<measdim>
   measurementCovariance(IndexType covIdx) {
@@ -1394,7 +1394,7 @@ class MultiTrajectory {
   /// given index
   /// @param covIdx Index into the measurement covariance column
   /// @return Const proxy
-  template <size_t measdim>
+  template <std::size_t measdim>
   constexpr
       typename ConstTrackStateProxy::template MeasurementCovariance<measdim>
       measurementCovariance(IndexType covIdx) const {
@@ -1483,7 +1483,7 @@ class MultiTrajectory {
   /// @param measdim the dimension of the measurement to store
   /// @note Is a noop if the track state already has an allocation
   ///       an the dimension is the same.
-  void allocateCalibrated(IndexType istate, size_t measdim) {
+  void allocateCalibrated(IndexType istate, std::size_t measdim) {
     throw_assert(measdim > 0 && measdim <= eBoundSize,
                  "Invalid measurement dimension detected");
 
diff --git a/Core/include/Acts/EventData/MultiTrajectory.ipp b/Core/include/Acts/EventData/MultiTrajectory.ipp
index 0324b3a3ad7..a2622df71a7 100644
--- a/Core/include/Acts/EventData/MultiTrajectory.ipp
+++ b/Core/include/Acts/EventData/MultiTrajectory.ipp
@@ -18,12 +18,12 @@
 
 namespace Acts {
 namespace detail_lt {
-template <typename D, size_t M, bool ReadOnly>
+template <typename D, std::size_t M, bool ReadOnly>
 inline TrackStateProxy<D, M, ReadOnly>::TrackStateProxy(
     ConstIf<MultiTrajectory<D>, ReadOnly>& trajectory, IndexType istate)
     : m_traj(&trajectory), m_istate(istate) {}
 
-template <typename D, size_t M, bool ReadOnly>
+template <typename D, std::size_t M, bool ReadOnly>
 TrackStatePropMask TrackStateProxy<D, M, ReadOnly>::getMask() const {
   using PM = TrackStatePropMask;
 
@@ -46,7 +46,7 @@ TrackStatePropMask TrackStateProxy<D, M, ReadOnly>::getMask() const {
   return mask;
 }
 
-template <typename D, size_t M, bool ReadOnly>
+template <typename D, std::size_t M, bool ReadOnly>
 inline auto TrackStateProxy<D, M, ReadOnly>::parameters() const
     -> ConstParameters {
   if (hasSmoothed()) {
@@ -58,7 +58,7 @@ inline auto TrackStateProxy<D, M, ReadOnly>::parameters() const
   }
 }
 
-template <typename D, size_t M, bool ReadOnly>
+template <typename D, std::size_t M, bool ReadOnly>
 inline auto TrackStateProxy<D, M, ReadOnly>::covariance() const
     -> ConstCovariance {
   if (hasSmoothed()) {
@@ -70,14 +70,14 @@ inline auto TrackStateProxy<D, M, ReadOnly>::covariance() const
   }
 }
 
-template <typename D, size_t M, bool ReadOnly>
+template <typename D, std::size_t M, bool ReadOnly>
 inline auto TrackStateProxy<D, M, ReadOnly>::projector() const -> Projector {
   assert(has<hashString("projector")>());
   return bitsetToMatrix<Projector>(
       component<ProjectorBitset, hashString("projector")>());
 }
 
-template <typename D, size_t M, bool ReadOnly>
+template <typename D, std::size_t M, bool ReadOnly>
 inline auto TrackStateProxy<D, M, ReadOnly>::getUncalibratedSourceLink() const
     -> SourceLink {
   assert(has<hashString("uncalibratedSourceLink")>());
diff --git a/Core/include/Acts/EventData/MultiTrajectoryBackendConcept.hpp b/Core/include/Acts/EventData/MultiTrajectoryBackendConcept.hpp
index dc4b465d985..dc2fffae8e9 100644
--- a/Core/include/Acts/EventData/MultiTrajectoryBackendConcept.hpp
+++ b/Core/include/Acts/EventData/MultiTrajectoryBackendConcept.hpp
@@ -86,7 +86,7 @@ concept ConstMultiTrajectoryBackend = CommonMultiTrajectoryBackend<T> &&
 template <typename T>
 concept MutableMultiTrajectoryBackend = CommonMultiTrajectoryBackend<T> &&
     requires(T v, HashedString key, TrackIndexType istate,
-             TrackStatePropMask mask, std::string col, size_t dim,
+             TrackStatePropMask mask, std::string col, std::size_t dim,
              SourceLink sl, std::shared_ptr<const Surface> surface) {
   { v.parameters_impl(istate) } -> std::same_as<detail::Parameters>;
 
diff --git a/Core/include/Acts/EventData/MultiTrajectoryHelpers.hpp b/Core/include/Acts/EventData/MultiTrajectoryHelpers.hpp
index 4c564fd252a..40eff303500 100644
--- a/Core/include/Acts/EventData/MultiTrajectoryHelpers.hpp
+++ b/Core/include/Acts/EventData/MultiTrajectoryHelpers.hpp
@@ -24,19 +24,19 @@ namespace MultiTrajectoryHelpers {
 /// @brief Struct for brief trajectory summary info
 ///
 struct TrajectoryState {
-  size_t nStates = 0;
-  size_t nMeasurements = 0;
-  size_t nOutliers = 0;
-  size_t nHoles = 0;
+  std::size_t nStates = 0;
+  std::size_t nMeasurements = 0;
+  std::size_t nOutliers = 0;
+  std::size_t nHoles = 0;
   double chi2Sum = 0;
   std::vector<double> measurementChi2 = {};
   std::vector<double> outlierChi2 = {};
-  size_t NDF = 0;
+  std::size_t NDF = 0;
   std::vector<unsigned int> measurementVolume = {};
   std::vector<unsigned int> measurementLayer = {};
   std::vector<unsigned int> outlierVolume = {};
   std::vector<unsigned int> outlierLayer = {};
-  size_t nSharedHits = 0;
+  std::size_t nSharedHits = 0;
 };
 
 // Container for trajectory summary info at a specific volume
@@ -50,7 +50,8 @@ using VolumeTrajectoryStateContainer =
 ///
 /// @return The trajectory summary info
 template <typename traj_t>
-TrajectoryState trajectoryState(const traj_t& multiTraj, size_t entryIndex) {
+TrajectoryState trajectoryState(const traj_t& multiTraj,
+                                std::size_t entryIndex) {
   TrajectoryState trajState;
   multiTraj.visitBackwards(entryIndex, [&](const auto& state) {
     // Get the volume Id of this surface
@@ -94,7 +95,7 @@ TrajectoryState trajectoryState(const traj_t& multiTraj, size_t entryIndex) {
 /// different volumes)
 template <typename traj_t>
 VolumeTrajectoryStateContainer trajectoryState(
-    const traj_t& multiTraj, size_t entryIndex,
+    const traj_t& multiTraj, std::size_t entryIndex,
     const std::vector<GeometryIdentifier::Value>& volumeIds) {
   VolumeTrajectoryStateContainer trajStateContainer;
   multiTraj.visitBackwards(entryIndex, [&](const auto& state) {
diff --git a/Core/include/Acts/EventData/TrackStateType.hpp b/Core/include/Acts/EventData/TrackStateType.hpp
index d259a61a1a9..4ee3ee70af0 100644
--- a/Core/include/Acts/EventData/TrackStateType.hpp
+++ b/Core/include/Acts/EventData/TrackStateType.hpp
@@ -112,7 +112,7 @@ class ConstTrackStateType {
     assert(t.m_raw != nullptr);
     std::bitset<kRawBits> bs{*t.m_raw};
     std::bitset<TrackStateFlag::NumTrackStateFlags> trunc;
-    for (size_t i = 0; i < TrackStateFlag::NumTrackStateFlags; i++) {
+    for (std::size_t i = 0; i < TrackStateFlag::NumTrackStateFlags; i++) {
       trunc[i] = bs[i];
     }
     // MeasurementParameterOutlierHoleMaterialSharedhit
diff --git a/Core/include/Acts/EventData/VectorMultiTrajectory.hpp b/Core/include/Acts/EventData/VectorMultiTrajectory.hpp
index 7cfb7684cc6..8aa7b6f32ef 100644
--- a/Core/include/Acts/EventData/VectorMultiTrajectory.hpp
+++ b/Core/include/Acts/EventData/VectorMultiTrajectory.hpp
@@ -57,7 +57,7 @@ class VectorMultiTrajectoryBase {
 
     hist_t hist;
 
-    void toStream(std::ostream& os, size_t n = 1);
+    void toStream(std::ostream& os, std::size_t n = 1);
   };
 
   template <typename T>
@@ -98,8 +98,8 @@ class VectorMultiTrajectoryBase {
       h("index", isMeas, weight(sizeof(IndexData)));
 
       using scalar = typename decltype(ts.predicted())::Scalar;
-      size_t par_size = eBoundSize * sizeof(scalar);
-      size_t cov_size = eBoundSize * eBoundSize * sizeof(scalar);
+      std::size_t par_size = eBoundSize * sizeof(scalar);
+      std::size_t cov_size = eBoundSize * eBoundSize * sizeof(scalar);
 
       const IndexData& index = m_index[i];
       if (ts.hasPredicted() &&
@@ -124,8 +124,8 @@ class VectorMultiTrajectoryBase {
         weight(sizeof(decltype(m_measCovOffset)::value_type)));
       if (ts.hasCalibrated() &&
           ACTS_CHECK_BIT(index.allocMask, TrackStatePropMask::Calibrated)) {
-        size_t meas_size = ts.calibratedSize() * sizeof(scalar);
-        size_t meas_cov_size =
+        std::size_t meas_size = ts.calibratedSize() * sizeof(scalar);
+        std::size_t meas_cov_size =
             ts.calibratedSize() * ts.calibratedSize() * sizeof(scalar);
 
         h("meas", isMeas, weight(meas_size));
@@ -384,27 +384,27 @@ class VectorMultiTrajectory final
     return ConstTrackStateProxy::Covariance{m_jac[jacIdx].data()};
   }
 
-  template <size_t measdim>
+  template <std::size_t measdim>
   TrackStateProxy::Measurement<measdim> measurement_impl(IndexType istate) {
     IndexType offset = m_measOffset[istate];
     return TrackStateProxy::Measurement<measdim>{&m_meas[offset]};
   }
 
-  template <size_t measdim>
+  template <std::size_t measdim>
   ConstTrackStateProxy::Measurement<measdim> measurement_impl(
       IndexType istate) const {
     IndexType offset = m_measOffset[istate];
     return ConstTrackStateProxy::Measurement<measdim>{&m_meas[offset]};
   }
 
-  template <size_t measdim>
+  template <std::size_t measdim>
   TrackStateProxy::MeasurementCovariance<measdim> measurementCovariance_impl(
       IndexType istate) {
     IndexType offset = m_measCovOffset[istate];
     return TrackStateProxy::MeasurementCovariance<measdim>{&m_measCov[offset]};
   }
 
-  template <size_t measdim>
+  template <std::size_t measdim>
   ConstTrackStateProxy::MeasurementCovariance<measdim>
   measurementCovariance_impl(IndexType istate) const {
     IndexType offset = m_measCovOffset[istate];
@@ -454,7 +454,7 @@ class VectorMultiTrajectory final
     return detail_vmt::VectorMultiTrajectoryBase::hasColumn_impl(*this, key);
   }
 
-  void allocateCalibrated_impl(IndexType istate, size_t measdim) {
+  void allocateCalibrated_impl(IndexType istate, std::size_t measdim) {
     throw_assert(measdim > 0 && measdim <= eBoundSize,
                  "Invalid measurement dimension detected");
 
@@ -533,14 +533,14 @@ class ConstVectorMultiTrajectory final
     return ConstTrackStateProxy::Covariance{m_jac[jacIdx].data()};
   }
 
-  template <size_t measdim>
+  template <std::size_t measdim>
   ConstTrackStateProxy::Measurement<measdim> measurement_impl(
       IndexType istate) const {
     IndexType offset = m_measOffset[istate];
     return ConstTrackStateProxy::Measurement<measdim>{&m_meas[offset]};
   }
 
-  template <size_t measdim>
+  template <std::size_t measdim>
   ConstTrackStateProxy::MeasurementCovariance<measdim>
   measurementCovariance_impl(IndexType istate) const {
     IndexType offset = m_measCovOffset[istate];
diff --git a/Core/include/Acts/EventData/VectorTrackContainer.hpp b/Core/include/Acts/EventData/VectorTrackContainer.hpp
index ae7fab530e4..c5686574048 100644
--- a/Core/include/Acts/EventData/VectorTrackContainer.hpp
+++ b/Core/include/Acts/EventData/VectorTrackContainer.hpp
@@ -109,7 +109,7 @@ class VectorTrackContainerBase {
   }
 
   bool checkConsistency() const {
-    size_t size = m_tipIndex.size();
+    std::size_t size = m_tipIndex.size();
     (void)size;
 
     bool result = true;
diff --git a/Core/include/Acts/EventData/detail/CalculateResiduals.hpp b/Core/include/Acts/EventData/detail/CalculateResiduals.hpp
index fb809f573b2..533745316b3 100644
--- a/Core/include/Acts/EventData/detail/CalculateResiduals.hpp
+++ b/Core/include/Acts/EventData/detail/CalculateResiduals.hpp
@@ -45,8 +45,8 @@ inline void calculateResiduals(BoundIndices size,
   assert((size <= measured.size()) && "Inconsistent measured size");
   assert((size <= residuals.size()) && "Inconsistent residuals size");
 
-  for (size_t i = 0; i < size; ++i) {
-    size_t fullIndex = indices[i];
+  for (std::size_t i = 0; i < size; ++i) {
+    std::size_t fullIndex = indices[i];
     // this is neither elegant nor smart but it is the simplest solution.
     //
     // only phi must be handled specially here. the theta limits can only be
@@ -88,7 +88,7 @@ inline void calculateResiduals(FreeIndices size,
   assert((size <= measured.size()) && "Inconsistent measured size");
   assert((size <= residuals.size()) && "Inconsistent residuals size");
 
-  for (size_t i = 0; i < size; ++i) {
+  for (std::size_t i = 0; i < size; ++i) {
     // all free parameters are unrestricted. no need to call parameter traits
     residuals[i] = measured[i] - reference[indices[i]];
   }
diff --git a/Core/include/Acts/EventData/detail/DynamicColumn.hpp b/Core/include/Acts/EventData/detail/DynamicColumn.hpp
index 2d86d1f53cc..9986f4a2436 100644
--- a/Core/include/Acts/EventData/detail/DynamicColumn.hpp
+++ b/Core/include/Acts/EventData/detail/DynamicColumn.hpp
@@ -18,16 +18,16 @@ namespace Acts::detail {
 struct DynamicColumnBase {
   virtual ~DynamicColumnBase() = default;
 
-  virtual std::any get(size_t i) = 0;
-  virtual std::any get(size_t i) const = 0;
+  virtual std::any get(std::size_t i) = 0;
+  virtual std::any get(std::size_t i) const = 0;
 
   virtual void add() = 0;
   virtual void clear() = 0;
-  virtual void reserve(size_t size) = 0;
-  virtual void erase(size_t i) = 0;
-  virtual size_t size() const = 0;
-  virtual void copyFrom(size_t dstIdx, const DynamicColumnBase& src,
-                        size_t srcIdx) = 0;
+  virtual void reserve(std::size_t size) = 0;
+  virtual void erase(std::size_t i) = 0;
+  virtual std::size_t size() const = 0;
+  virtual void copyFrom(std::size_t dstIdx, const DynamicColumnBase& src,
+                        std::size_t srcIdx) = 0;
 
   virtual std::unique_ptr<DynamicColumnBase> clone(
       bool empty = false) const = 0;
@@ -35,21 +35,21 @@ struct DynamicColumnBase {
 
 template <typename T>
 struct DynamicColumn : public DynamicColumnBase {
-  std::any get(size_t i) override {
+  std::any get(std::size_t i) override {
     assert(i < m_vector.size() && "DynamicColumn out of bounds");
     return &m_vector[i];
   }
 
-  std::any get(size_t i) const override {
+  std::any get(std::size_t i) const override {
     assert(i < m_vector.size() && "DynamicColumn out of bounds");
     return &m_vector[i];
   }
 
   void add() override { m_vector.emplace_back(); }
   void clear() override { m_vector.clear(); }
-  void reserve(size_t size) override { m_vector.reserve(size); }
-  void erase(size_t i) override { m_vector.erase(m_vector.begin() + i); }
-  size_t size() const override { return m_vector.size(); }
+  void reserve(std::size_t size) override { m_vector.reserve(size); }
+  void erase(std::size_t i) override { m_vector.erase(m_vector.begin() + i); }
+  std::size_t size() const override { return m_vector.size(); }
 
   std::unique_ptr<DynamicColumnBase> clone(bool empty) const override {
     if (empty) {
@@ -58,8 +58,8 @@ struct DynamicColumn : public DynamicColumnBase {
     return std::make_unique<DynamicColumn<T>>(*this);
   }
 
-  void copyFrom(size_t dstIdx, const DynamicColumnBase& src,
-                size_t srcIdx) override {
+  void copyFrom(std::size_t dstIdx, const DynamicColumnBase& src,
+                std::size_t srcIdx) override {
     const auto* other = dynamic_cast<const DynamicColumn<T>*>(&src);
     assert(other != nullptr &&
            "Source column is not of same type as destination");
@@ -75,21 +75,21 @@ struct DynamicColumn<bool> : public DynamicColumnBase {
     bool value;
   };
 
-  std::any get(size_t i) override {
+  std::any get(std::size_t i) override {
     assert(i < m_vector.size() && "DynamicColumn out of bounds");
     return &m_vector[i].value;
   }
 
-  std::any get(size_t i) const override {
+  std::any get(std::size_t i) const override {
     assert(i < m_vector.size() && "DynamicColumn out of bounds");
     return &m_vector[i].value;
   }
 
   void add() override { m_vector.emplace_back(); }
-  void reserve(size_t size) override { m_vector.reserve(size); }
+  void reserve(std::size_t size) override { m_vector.reserve(size); }
   void clear() override { m_vector.clear(); }
-  void erase(size_t i) override { m_vector.erase(m_vector.begin() + i); }
-  size_t size() const override { return m_vector.size(); }
+  void erase(std::size_t i) override { m_vector.erase(m_vector.begin() + i); }
+  std::size_t size() const override { return m_vector.size(); }
 
   std::unique_ptr<DynamicColumnBase> clone(bool empty) const override {
     if (empty) {
@@ -98,8 +98,8 @@ struct DynamicColumn<bool> : public DynamicColumnBase {
     return std::make_unique<DynamicColumn<bool>>(*this);
   }
 
-  void copyFrom(size_t dstIdx, const DynamicColumnBase& src,
-                size_t srcIdx) override {
+  void copyFrom(std::size_t dstIdx, const DynamicColumnBase& src,
+                std::size_t srcIdx) override {
     const auto* other = dynamic_cast<const DynamicColumn<bool>*>(&src);
     assert(other != nullptr &&
            "Source column is not of same type as destination");
diff --git a/Core/include/Acts/EventData/detail/ParameterTraits.hpp b/Core/include/Acts/EventData/detail/ParameterTraits.hpp
index 86cd4d5bd34..f5e116c88b6 100644
--- a/Core/include/Acts/EventData/detail/ParameterTraits.hpp
+++ b/Core/include/Acts/EventData/detail/ParameterTraits.hpp
@@ -159,16 +159,18 @@ template <typename indices_t>
 struct ParametersTraitsImpl;
 template <>
 struct ParametersTraitsImpl<BoundIndices> {
-  static constexpr size_t kSize = static_cast<size_t>(BoundIndices::eBoundSize);
+  static constexpr std::size_t kSize =
+      static_cast<std::size_t>(BoundIndices::eBoundSize);
 };
 template <>
 struct ParametersTraitsImpl<FreeIndices> {
-  static constexpr size_t kSize = static_cast<size_t>(FreeIndices::eFreeSize);
+  static constexpr std::size_t kSize =
+      static_cast<std::size_t>(FreeIndices::eFreeSize);
 };
 
 /// The maximum parameters vector size definable for an indices enum.
 template <typename indices_t>
-constexpr size_t kParametersSize = ParametersTraitsImpl<indices_t>::kSize;
+constexpr std::size_t kParametersSize = ParametersTraitsImpl<indices_t>::kSize;
 
 }  // namespace detail
 }  // namespace Acts
diff --git a/Core/include/Acts/EventData/detail/covariance_helper.hpp b/Core/include/Acts/EventData/detail/covariance_helper.hpp
index 0c27a210798..4f6dbe6440b 100644
--- a/Core/include/Acts/EventData/detail/covariance_helper.hpp
+++ b/Core/include/Acts/EventData/detail/covariance_helper.hpp
@@ -33,7 +33,7 @@ struct covariance_helper {
     if (covariance.hasNaN()) {
       return false;
     }
-    size_t nIteration = 0;
+    std::size_t nIteration = 0;
     while (nIteration < NumIter) {
       if (isSemiPositive(covariance)) {
         return true;
diff --git a/Core/include/Acts/Geometry/CuboidVolumeBuilder.hpp b/Core/include/Acts/Geometry/CuboidVolumeBuilder.hpp
index 17e1d45d1bc..2f9ba2946cd 100644
--- a/Core/include/Acts/Geometry/CuboidVolumeBuilder.hpp
+++ b/Core/include/Acts/Geometry/CuboidVolumeBuilder.hpp
@@ -70,9 +70,9 @@ class CuboidVolumeBuilder : public ITrackingVolumeBuilder {
     // Boolean flag if layer is active
     bool active = false;
     // Bins in Y direction
-    size_t binsY = 1;
+    std::size_t binsY = 1;
     // Bins in Z direction
-    size_t binsZ = 1;
+    std::size_t binsZ = 1;
     // Envelope in X
     std::array<ActsScalar, 2u> envelopeX{0, 0};
     // Envelope in Y
diff --git a/Core/include/Acts/Geometry/GenericCuboidVolumeBounds.hpp b/Core/include/Acts/Geometry/GenericCuboidVolumeBounds.hpp
index ce0e9e3d7aa..d205f51d92a 100644
--- a/Core/include/Acts/Geometry/GenericCuboidVolumeBounds.hpp
+++ b/Core/include/Acts/Geometry/GenericCuboidVolumeBounds.hpp
@@ -26,7 +26,7 @@ class GenericCuboidVolumeBounds : public VolumeBounds {
   /// @brief  This struct helps to symmetrize with the
   /// the other volume bounds classes
   struct BoundValues {
-    static constexpr size_t eSize = 24;
+    static constexpr std::size_t eSize = 24;
   };
 
   GenericCuboidVolumeBounds() = delete;
diff --git a/Core/include/Acts/Geometry/KDTreeTrackingGeometryBuilder.hpp b/Core/include/Acts/Geometry/KDTreeTrackingGeometryBuilder.hpp
index 2e650841c53..f44c51cbf74 100644
--- a/Core/include/Acts/Geometry/KDTreeTrackingGeometryBuilder.hpp
+++ b/Core/include/Acts/Geometry/KDTreeTrackingGeometryBuilder.hpp
@@ -89,7 +89,7 @@ class KDTreeTrackingGeometryBuilder : public ITrackingGeometryBuilder {
 
   /// Private construction cache
   struct Cache {
-    size_t surfaceCounter = 0;
+    std::size_t surfaceCounter = 0;
   };
 
   /// Translate a proto tracking volume into a Acts::TrackingVolume
diff --git a/Core/include/Acts/Geometry/LayerCreator.hpp b/Core/include/Acts/Geometry/LayerCreator.hpp
index 8bb579405d6..0d490732b2c 100644
--- a/Core/include/Acts/Geometry/LayerCreator.hpp
+++ b/Core/include/Acts/Geometry/LayerCreator.hpp
@@ -84,8 +84,8 @@ class LayerCreator {
   /// @return shared pointer to a newly created layer
   MutableLayerPtr cylinderLayer(
       const GeometryContext& gctx,
-      std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsPhi,
-      size_t binsZ, std::optional<ProtoLayer> _protoLayer = std::nullopt,
+      std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t binsPhi,
+      std::size_t binsZ, std::optional<ProtoLayer> _protoLayer = std::nullopt,
       const Transform3& transform = Transform3::Identity(),
       std::unique_ptr<ApproachDescriptor> ad = nullptr) const;
 
@@ -133,8 +133,8 @@ class LayerCreator {
   /// @return shared pointer to a newly created layer
   MutableLayerPtr discLayer(
       const GeometryContext& gctx,
-      std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsR,
-      size_t binsPhi, std::optional<ProtoLayer> _protoLayer = std::nullopt,
+      std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t binsR,
+      std::size_t binsPhi, std::optional<ProtoLayer> _protoLayer = std::nullopt,
       const Transform3& transform = Transform3::Identity(),
       std::unique_ptr<ApproachDescriptor> ad = nullptr) const;
 
@@ -186,8 +186,8 @@ class LayerCreator {
   /// @return shared pointer to a newly created layer
   MutableLayerPtr planeLayer(
       const GeometryContext& gctx,
-      std::vector<std::shared_ptr<const Surface>> surfaces, size_t bins1,
-      size_t bins2, BinningValue bValue,
+      std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t bins1,
+      std::size_t bins2, BinningValue bValue,
       std::optional<ProtoLayer> _protoLayer = std::nullopt,
       const Transform3& transform = Transform3::Identity(),
       std::unique_ptr<ApproachDescriptor> ad = nullptr) const;
diff --git a/Core/include/Acts/Geometry/Polyhedron.hpp b/Core/include/Acts/Geometry/Polyhedron.hpp
index 7e3de06b008..69ae109c52d 100644
--- a/Core/include/Acts/Geometry/Polyhedron.hpp
+++ b/Core/include/Acts/Geometry/Polyhedron.hpp
@@ -26,7 +26,7 @@ namespace Acts {
 /// that need to be connected to form a face.
 /// This allows the @c objString method to produce a ready-to-go obj output.
 struct Polyhedron {
-  using FaceType = std::vector<size_t>;
+  using FaceType = std::vector<std::size_t>;
 
   /// Default constructor
   Polyhedron() = default;
diff --git a/Core/include/Acts/Geometry/SurfaceArrayCreator.hpp b/Core/include/Acts/Geometry/SurfaceArrayCreator.hpp
index 403c2ae87ba..55eceab9395 100644
--- a/Core/include/Acts/Geometry/SurfaceArrayCreator.hpp
+++ b/Core/include/Acts/Geometry/SurfaceArrayCreator.hpp
@@ -59,16 +59,16 @@ class SurfaceArrayCreator {
   struct ProtoAxis {
     BinningType bType = BinningType::equidistant;
     BinningValue bValue = BinningValue::binX;
-    size_t nBins = 0;
+    std::size_t nBins = 0;
     AxisScalar min = 0;
     AxisScalar max = 0;
     std::vector<AxisScalar> binEdges;
 
-    size_t getBin(AxisScalar x) const {
+    std::size_t getBin(AxisScalar x) const {
       if (binEdges.empty()) {
         // equidistant
         AxisScalar w = (max - min) / nBins;
-        return static_cast<size_t>(std::floor((x - min) / w));
+        return static_cast<std::size_t>(std::floor((x - min) / w));
       } else {
         // variable
         const auto it =
@@ -126,8 +126,8 @@ class SurfaceArrayCreator {
   /// @return a unique pointer to a new SurfaceArray
   std::unique_ptr<SurfaceArray> surfaceArrayOnCylinder(
       const GeometryContext& gctx,
-      std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsPhi,
-      size_t binsZ, std::optional<ProtoLayer> protoLayerOpt = std::nullopt,
+      std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t binsPhi,
+      std::size_t binsZ, std::optional<ProtoLayer> protoLayerOpt = std::nullopt,
       const Transform3& transform = Transform3::Identity()) const;
 
   /// SurfaceArrayCreator interface method
@@ -172,8 +172,9 @@ class SurfaceArrayCreator {
   /// @return a unique pointer a new SurfaceArray
   std::unique_ptr<SurfaceArray> surfaceArrayOnDisc(
       const GeometryContext& gctx,
-      std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsR,
-      size_t binsPhi, std::optional<ProtoLayer> protoLayerOpt = std::nullopt,
+      std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t binsR,
+      std::size_t binsPhi,
+      std::optional<ProtoLayer> protoLayerOpt = std::nullopt,
       const Transform3& transform = Transform3::Identity()) const;
 
   /// SurfaceArrayCreator interface method
@@ -224,8 +225,8 @@ class SurfaceArrayCreator {
   /// @return a unique pointer a new SurfaceArray
   std::unique_ptr<SurfaceArray> surfaceArrayOnPlane(
       const GeometryContext& gctx,
-      std::vector<std::shared_ptr<const Surface>> surfaces, size_t bins1,
-      size_t bins2, BinningValue bValue,
+      std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t bins1,
+      std::size_t bins2, BinningValue bValue,
       std::optional<ProtoLayer> protoLayerOpt = std::nullopt,
       const Transform3& transform = Transform3::Identity()) const;
 
@@ -289,9 +290,9 @@ class SurfaceArrayCreator {
       const std::vector<const Surface*>& surfaces,
       const std::function<bool(const Surface*, const Surface*)>& equal) const;
 
-  size_t determineBinCount(const GeometryContext& gctx,
-                           const std::vector<const Surface*>& surfaces,
-                           BinningValue bValue) const;
+  std::size_t determineBinCount(const GeometryContext& gctx,
+                                const std::vector<const Surface*>& surfaces,
+                                BinningValue bValue) const;
 
   /// SurfaceArrayCreator internal method
   /// Creates a variable @c ProtoAxis from a vector of (unsorted) surfaces with
@@ -347,7 +348,7 @@ class SurfaceArrayCreator {
                                   BinningValue bValue,
                                   const ProtoLayer& protoLayer,
                                   Transform3& transform,
-                                  size_t nBins = 0) const;
+                                  std::size_t nBins = 0) const;
 
   /// SurfaceArrayCreator internal method
   /// @brief Creates a SurfaceGridLookup instance within an any
@@ -439,7 +440,7 @@ class SurfaceArrayCreator {
         "Complete binning by filling closest neighbour surfaces into "
         "empty bins.");
 
-    size_t binCompleted = sl.completeBinning(gctx, surfaces);
+    std::size_t binCompleted = sl.completeBinning(gctx, surfaces);
 
     ACTS_VERBOSE("       filled  : " << binCompleted
                                      << " (includes under/overflow)");
diff --git a/Core/include/Acts/Geometry/TrackingVolume.hpp b/Core/include/Acts/Geometry/TrackingVolume.hpp
index d344342bb2b..df88e9f065c 100644
--- a/Core/include/Acts/Geometry/TrackingVolume.hpp
+++ b/Core/include/Acts/Geometry/TrackingVolume.hpp
@@ -464,7 +464,7 @@ class TrackingVolume : public Volume {
   void closeGeometry(
       const IMaterialDecorator* materialDecorator,
       std::unordered_map<GeometryIdentifier, const TrackingVolume*>& volumeMap,
-      size_t& vol, const GeometryIdentifierHook& hook,
+      std::size_t& vol, const GeometryIdentifierHook& hook,
       const Logger& logger = getDummyLogger());
 
   /// interlink the layers in this TrackingVolume
diff --git a/Core/include/Acts/MagneticField/BFieldMapUtils.hpp b/Core/include/Acts/MagneticField/BFieldMapUtils.hpp
index 65c017a39fd..0aff68b5ca0 100644
--- a/Core/include/Acts/MagneticField/BFieldMapUtils.hpp
+++ b/Core/include/Acts/MagneticField/BFieldMapUtils.hpp
@@ -45,7 +45,7 @@ class SolenoidBField;
 ///
 /// In this case the function would look like:
 /// @code
-/// [](std::array<size_t, 2> binsRZ, std::array<size_t, 2> nBinsRZ) {
+/// [](std::array<std::size_t, 2> binsRZ, std::array<std::size_t, 2> nBinsRZ) {
 ///    return (binsRZ.at(0) * nBinsRZ.at(1) + binsRZ.at(1));
 /// }
 /// @endcode
@@ -71,8 +71,8 @@ class SolenoidBField;
 Acts::InterpolatedBFieldMap<
     Acts::Grid<Acts::Vector2, Acts::detail::EquidistantAxis,
                Acts::detail::EquidistantAxis>>
-fieldMapRZ(const std::function<size_t(std::array<size_t, 2> binsRZ,
-                                      std::array<size_t, 2> nBinsRZ)>&
+fieldMapRZ(const std::function<std::size_t(std::array<std::size_t, 2> binsRZ,
+                                           std::array<std::size_t, 2> nBinsRZ)>&
                localToGlobalBin,
            std::vector<double> rPos, std::vector<double> zPos,
            std::vector<Acts::Vector2> bField,
@@ -102,7 +102,8 @@ fieldMapRZ(const std::function<size_t(std::array<size_t, 2> binsRZ,
 ///
 /// In this case the function would look like:
 /// @code
-/// [](std::array<size_t, 3> binsXYZ, std::array<size_t, 3> nBinsXYZ) {
+/// [](std::array<std::size_t, 3> binsXYZ, std::array<std::size_t, 3> nBinsXYZ)
+/// {
 ///   return (binsXYZ.at(0) * (nBinsXYZ.at(1) * nBinsXYZ.at(2))
 ///        + binsXYZ.at(1) * nBinsXYZ.at(2)
 ///        + binsXYZ.at(2));
@@ -130,13 +131,14 @@ fieldMapRZ(const std::function<size_t(std::array<size_t, 2> binsRZ,
 Acts::InterpolatedBFieldMap<
     Acts::Grid<Acts::Vector3, Acts::detail::EquidistantAxis,
                Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis>>
-fieldMapXYZ(const std::function<size_t(std::array<size_t, 3> binsXYZ,
-                                       std::array<size_t, 3> nBinsXYZ)>&
-                localToGlobalBin,
-            std::vector<double> xPos, std::vector<double> yPos,
-            std::vector<double> zPos, std::vector<Acts::Vector3> bField,
-            double lengthUnit = UnitConstants::mm,
-            double BFieldUnit = UnitConstants::T, bool firstOctant = false);
+fieldMapXYZ(
+    const std::function<std::size_t(std::array<std::size_t, 3> binsXYZ,
+                                    std::array<std::size_t, 3> nBinsXYZ)>&
+        localToGlobalBin,
+    std::vector<double> xPos, std::vector<double> yPos,
+    std::vector<double> zPos, std::vector<Acts::Vector3> bField,
+    double lengthUnit = UnitConstants::mm, double BFieldUnit = UnitConstants::T,
+    bool firstOctant = false);
 
 /// Function which takes an existing SolenoidBField instance and
 /// creates a field mapper by sampling grid points from the analytical
@@ -152,6 +154,7 @@ Acts::InterpolatedBFieldMap<
     Acts::Grid<Acts::Vector2, Acts::detail::EquidistantAxis,
                Acts::detail::EquidistantAxis>>
 solenoidFieldMap(std::pair<double, double> rlim, std::pair<double, double> zlim,
-                 std::pair<size_t, size_t> nbins, const SolenoidBField& field);
+                 std::pair<std::size_t, std::size_t> nbins,
+                 const SolenoidBField& field);
 
 }  // namespace Acts
diff --git a/Core/include/Acts/MagneticField/InterpolatedBFieldMap.hpp b/Core/include/Acts/MagneticField/InterpolatedBFieldMap.hpp
index c0ffb3592a3..584af8e85e4 100644
--- a/Core/include/Acts/MagneticField/InterpolatedBFieldMap.hpp
+++ b/Core/include/Acts/MagneticField/InterpolatedBFieldMap.hpp
@@ -27,7 +27,7 @@ class InterpolatedMagneticField : public MagneticFieldProvider {
   /// @brief get the number of bins for all axes of the field map
   ///
   /// @return vector returning number of bins for all field map axes
-  virtual std::vector<size_t> getNBins() const = 0;
+  virtual std::vector<std::size_t> getNBins() const = 0;
 
   /// @brief get the minimum value of all axes of the field map
   ///
@@ -77,7 +77,7 @@ class InterpolatedBFieldMap : public InterpolatedMagneticField {
  public:
   using Grid = grid_t;
   using FieldType = typename Grid::value_type;
-  static constexpr size_t DIM_POS = Grid::DIM;
+  static constexpr std::size_t DIM_POS = Grid::DIM;
 
   /// @brief struct representing smallest grid unit in magnetic field grid
   ///
@@ -198,7 +198,7 @@ class InterpolatedBFieldMap : public InterpolatedMagneticField {
     const auto& upperRight = m_cfg.grid.upperRightBinEdge(indices);
 
     // loop through all corner points
-    constexpr size_t nCorners = 1 << DIM_POS;
+    constexpr std::size_t nCorners = 1 << DIM_POS;
     std::array<Vector3, nCorners> neighbors;
     const auto& cornerIndices = m_cfg.grid.closestPointsIndices(gridPosition);
 
@@ -206,8 +206,8 @@ class InterpolatedBFieldMap : public InterpolatedMagneticField {
       return MagneticFieldError::OutOfBounds;
     }
 
-    size_t i = 0;
-    for (size_t index : cornerIndices) {
+    std::size_t i = 0;
+    for (std::size_t index : cornerIndices) {
       neighbors.at(i++) = m_cfg.transformBField(m_cfg.grid.at(index), position);
     }
 
@@ -219,9 +219,9 @@ class InterpolatedBFieldMap : public InterpolatedMagneticField {
   /// @brief get the number of bins for all axes of the field map
   ///
   /// @return vector returning number of bins for all field map axes
-  std::vector<size_t> getNBins() const final {
+  std::vector<std::size_t> getNBins() const final {
     auto nBinsArray = m_cfg.grid.numLocalBins();
-    return std::vector<size_t>(nBinsArray.begin(), nBinsArray.end());
+    return std::vector<std::size_t>(nBinsArray.begin(), nBinsArray.end());
   }
 
   /// @brief get the minimum value of all axes of the field map
diff --git a/Core/include/Acts/MagneticField/SolenoidBField.hpp b/Core/include/Acts/MagneticField/SolenoidBField.hpp
index a3ac9499226..ba02eb6173c 100644
--- a/Core/include/Acts/MagneticField/SolenoidBField.hpp
+++ b/Core/include/Acts/MagneticField/SolenoidBField.hpp
@@ -84,7 +84,7 @@ class SolenoidBField final : public MagneticFieldProvider {
     /// -length/2 to +length/2 by convention
     double length;
     /// The number of coils that make up the solenoid
-    size_t nCoils;
+    std::size_t nCoils;
     /// The target magnetic field strength at the center.
     /// This will be used to scale coefficients
     double bMagCenter;
diff --git a/Core/include/Acts/Material/AccumulatedSurfaceMaterial.hpp b/Core/include/Acts/Material/AccumulatedSurfaceMaterial.hpp
index 173a84f7fa3..1524176d3c4 100644
--- a/Core/include/Acts/Material/AccumulatedSurfaceMaterial.hpp
+++ b/Core/include/Acts/Material/AccumulatedSurfaceMaterial.hpp
@@ -87,8 +87,9 @@ class AccumulatedSurfaceMaterial {
   /// @param pathCorrection Correction factor for the effective path length
   ///
   /// @return the bin triple to which the material was assigned
-  std::array<size_t, 3> accumulate(const Vector2& lp, const MaterialSlab& mp,
-                                   double pathCorrection = 1.);
+  std::array<std::size_t, 3> accumulate(const Vector2& lp,
+                                        const MaterialSlab& mp,
+                                        double pathCorrection = 1.);
 
   /// Assign a material properties object
   ///
@@ -97,8 +98,9 @@ class AccumulatedSurfaceMaterial {
   /// @param pathCorrection Correction factor for the effective path length
   ///
   /// @return the bin triple to which the material was assigned
-  std::array<size_t, 3> accumulate(const Vector3& gp, const MaterialSlab& mp,
-                                   double pathCorrection = 1.);
+  std::array<std::size_t, 3> accumulate(const Vector3& gp,
+                                        const MaterialSlab& mp,
+                                        double pathCorrection = 1.);
 
   /// Use the accumulated material to update the material variance
   ///
@@ -106,7 +108,7 @@ class AccumulatedSurfaceMaterial {
   /// @param emptyHit indicator if this is an empty assignment
   /// @param slabReference reference slab (from the map) used to compute the variance
   /// If none is given, the average runs over all bins in the surface map
-  void trackVariance(const std::vector<std::array<size_t, 3>>& trackBins,
+  void trackVariance(const std::vector<std::array<std::size_t, 3>>& trackBins,
                      MaterialSlab slabReference, bool emptyHit = false);
 
   /// Use the accumulated material to update the material variance
@@ -122,8 +124,9 @@ class AccumulatedSurfaceMaterial {
   /// @param trackBins The bins that were touched by this event
   /// @param emptyHit indicator if this is an empty assignment
   /// If none is given, the average runs over all bins in the surface map
-  void trackAverage(const std::vector<std::array<size_t, 3>>& trackBins = {},
-                    bool emptyHit = false);
+  void trackAverage(
+      const std::vector<std::array<std::size_t, 3>>& trackBins = {},
+      bool emptyHit = false);
 
   /// Average the information accumulated from one mapped track
   ///
diff --git a/Core/include/Acts/Material/BinnedSurfaceMaterial.hpp b/Core/include/Acts/Material/BinnedSurfaceMaterial.hpp
index e4911483058..942d9a888a7 100644
--- a/Core/include/Acts/Material/BinnedSurfaceMaterial.hpp
+++ b/Core/include/Acts/Material/BinnedSurfaceMaterial.hpp
@@ -100,8 +100,9 @@ class BinnedSurfaceMaterial : public ISurfaceMaterial {
   /// @copydoc ISurfaceMaterial::materialSlab(const Vector3&) const
   const MaterialSlab& materialSlab(const Vector3& gp) const final;
 
-  /// @copydoc ISurfaceMaterial::materialSlab(size_t, size_t) const
-  const MaterialSlab& materialSlab(size_t bin0, size_t bin1) const final;
+  /// @copydoc ISurfaceMaterial::materialSlab(std::size_t, std::size_t) const
+  const MaterialSlab& materialSlab(std::size_t bin0,
+                                   std::size_t bin1) const final;
 
   /// Output Method for std::ostream, to be overloaded by child classes
   std::ostream& toStream(std::ostream& sl) const final;
@@ -123,7 +124,7 @@ inline const MaterialSlabMatrix& BinnedSurfaceMaterial::fullMaterial() const {
 }
 
 inline const MaterialSlab& BinnedSurfaceMaterial::materialSlab(
-    size_t bin0, size_t bin1) const {
+    std::size_t bin0, std::size_t bin1) const {
   return m_fullMaterial[bin1][bin0];
 }
 }  // namespace Acts
diff --git a/Core/include/Acts/Material/HomogeneousSurfaceMaterial.hpp b/Core/include/Acts/Material/HomogeneousSurfaceMaterial.hpp
index 584c745685b..b49c3f3b3ad 100644
--- a/Core/include/Acts/Material/HomogeneousSurfaceMaterial.hpp
+++ b/Core/include/Acts/Material/HomogeneousSurfaceMaterial.hpp
@@ -80,10 +80,11 @@ class HomogeneousSurfaceMaterial : public ISurfaceMaterial {
   /// @note the input parameter is ignored
   const MaterialSlab& materialSlab(const Vector3& gp) const final;
 
-  /// @copydoc ISurfaceMaterial::materialSlab(size_t, size_t) const
+  /// @copydoc ISurfaceMaterial::materialSlab(std::size_t, std::size_t) const
   ///
   /// @note the input parameters are ignored
-  const MaterialSlab& materialSlab(size_t bin0, size_t bin1) const final;
+  const MaterialSlab& materialSlab(std::size_t bin0,
+                                   std::size_t bin1) const final;
 
   /// The inherited methods - for MaterialSlab access
   using ISurfaceMaterial::materialSlab;
@@ -112,7 +113,7 @@ inline const MaterialSlab& HomogeneousSurfaceMaterial::materialSlab(
 }
 
 inline const MaterialSlab& HomogeneousSurfaceMaterial::materialSlab(
-    size_t /*ib0*/, size_t /*ib1*/) const {
+    std::size_t /*ib0*/, std::size_t /*ib1*/) const {
   return (m_fullMaterial);
 }
 
diff --git a/Core/include/Acts/Material/ISurfaceMaterial.hpp b/Core/include/Acts/Material/ISurfaceMaterial.hpp
index 4aca9cd42dd..7183bb0056a 100644
--- a/Core/include/Acts/Material/ISurfaceMaterial.hpp
+++ b/Core/include/Acts/Material/ISurfaceMaterial.hpp
@@ -74,7 +74,8 @@ class ISurfaceMaterial {
   ///
   /// @param bin0 is the material bin in dimension 0
   /// @param bin1 is the material bin in dimension 1
-  virtual const MaterialSlab& materialSlab(size_t bin0, size_t bin1) const = 0;
+  virtual const MaterialSlab& materialSlab(std::size_t bin0,
+                                           std::size_t bin1) const = 0;
 
   /// Update pre factor
   ///
diff --git a/Core/include/Acts/Material/InterpolatedMaterialMap.hpp b/Core/include/Acts/Material/InterpolatedMaterialMap.hpp
index 270144b8bbe..dd9bfef8640 100644
--- a/Core/include/Acts/Material/InterpolatedMaterialMap.hpp
+++ b/Core/include/Acts/Material/InterpolatedMaterialMap.hpp
@@ -28,7 +28,7 @@ template <typename G>
 struct MaterialMapper {
  public:
   using Grid_t = G;
-  static constexpr size_t DIM_POS = Grid_t::DIM;
+  static constexpr std::size_t DIM_POS = Grid_t::DIM;
 
   /// @brief Struct representing smallest grid unit in material grid
   ///
@@ -147,18 +147,18 @@ struct MaterialMapper {
   /// map.
   MaterialCell getMaterialCell(const Vector3& position) const {
     const auto& gridPosition = m_transformPos(position);
-    size_t bin = m_grid.globalBinFromPosition(gridPosition);
+    std::size_t bin = m_grid.globalBinFromPosition(gridPosition);
     const auto& indices = m_grid.localBinsFromPosition(bin);
     const auto& lowerLeft = m_grid.lowerLeftBinEdge(indices);
     const auto& upperRight = m_grid.upperRightBinEdge(indices);
 
     // Loop through all corner points
-    constexpr size_t nCorners = 1 << DIM_POS;
+    constexpr std::size_t nCorners = 1 << DIM_POS;
     std::array<Material::ParametersVector, nCorners> neighbors;
     const auto& cornerIndices = m_grid.closestPointsIndices(gridPosition);
 
-    size_t i = 0;
-    for (size_t index : cornerIndices) {
+    std::size_t i = 0;
+    for (std::size_t index : cornerIndices) {
       neighbors.at(i++) = m_grid.at(index);
     }
 
@@ -169,9 +169,9 @@ struct MaterialMapper {
   /// @brief Get the number of bins for all axes of the map
   ///
   /// @return Vector returning number of bins for all map axes
-  std::vector<size_t> getNBins() const {
+  std::vector<std::size_t> getNBins() const {
     auto nBinsArray = m_grid.numLocalBins();
-    return std::vector<size_t>(nBinsArray.begin(), nBinsArray.end());
+    return std::vector<std::size_t>(nBinsArray.begin(), nBinsArray.end());
   }
 
   /// @brief Get the minimum value of all axes of the map
diff --git a/Core/include/Acts/Material/MaterialGridHelper.hpp b/Core/include/Acts/Material/MaterialGridHelper.hpp
index 47ddba08f02..8e596684f8c 100644
--- a/Core/include/Acts/Material/MaterialGridHelper.hpp
+++ b/Core/include/Acts/Material/MaterialGridHelper.hpp
@@ -36,7 +36,7 @@ using MaterialGrid2D =
 using MaterialGrid3D =
     Acts::Grid<Acts::Material::ParametersVector, EAxis, EAxis, EAxis>;
 
-using MaterialGridAxisData = std::tuple<double, double, size_t>;
+using MaterialGridAxisData = std::tuple<double, double, std::size_t>;
 
 /// @brief Helper method that creates the cache grid for the mapping. This
 /// grid allows the collection of material at a the anchor points.
diff --git a/Core/include/Acts/Material/MaterialMapUtils.hpp b/Core/include/Acts/Material/MaterialMapUtils.hpp
index 440ef5e13f5..264cbee428a 100644
--- a/Core/include/Acts/Material/MaterialMapUtils.hpp
+++ b/Core/include/Acts/Material/MaterialMapUtils.hpp
@@ -44,7 +44,7 @@ class Material;
 ///
 /// In this case the function would look like:
 /// @code
-/// [](std::array<size_t, 2> binsRZ, std::array<size_t, 2> nBinsRZ) {
+/// [](std::array<std::size_t, 2> binsRZ, std::array<std::size_t, 2> nBinsRZ) {
 ///    return (binsRZ.at(0) * nBinsRZ.at(1) + binsRZ.at(1));
 /// }
 /// @endcode
@@ -61,12 +61,13 @@ class Material;
 /// @param [in] lengthUnit The unit of the grid points
 MaterialMapper<Grid<Material::ParametersVector, detail::EquidistantAxis,
                     detail::EquidistantAxis>>
-materialMapperRZ(const std::function<size_t(std::array<size_t, 2> binsRZ,
-                                            std::array<size_t, 2> nBinsRZ)>&
-                     materialVectorToGridMapper,
-                 std::vector<double> rPos, std::vector<double> zPos,
-                 const std::vector<Acts::Material>& material,
-                 double lengthUnit = UnitConstants::mm);
+materialMapperRZ(
+    const std::function<std::size_t(std::array<std::size_t, 2> binsRZ,
+                                    std::array<std::size_t, 2> nBinsRZ)>&
+        materialVectorToGridMapper,
+    std::vector<double> rPos, std::vector<double> zPos,
+    const std::vector<Acts::Material>& material,
+    double lengthUnit = UnitConstants::mm);
 
 /// Method to setup the MaterialMapper
 /// @param [in] materialVectorToGridMapper Function mapping the vector of
@@ -89,7 +90,8 @@ materialMapperRZ(const std::function<size_t(std::array<size_t, 2> binsRZ,
 ///
 /// In this case the function would look like:
 /// @code
-/// [](std::array<size_t, 3> binsXYZ, std::array<size_t, 3> nBinsXYZ) {
+/// [](std::array<std::size_t, 3> binsXYZ, std::array<std::size_t, 3> nBinsXYZ)
+/// {
 ///   return (binsXYZ.at(0) * (nBinsXYZ.at(1) * nBinsXYZ.at(2))
 ///        + binsXYZ.at(1) * nBinsXYZ.at(2)
 ///        + binsXYZ.at(2));
@@ -111,12 +113,12 @@ materialMapperRZ(const std::function<size_t(std::array<size_t, 2> binsRZ,
 /// @param [in] lengthUnit The unit of the grid points
 MaterialMapper<Grid<Material::ParametersVector, detail::EquidistantAxis,
                     detail::EquidistantAxis, detail::EquidistantAxis>>
-materialMapperXYZ(const std::function<size_t(std::array<size_t, 3> binsXYZ,
-                                             std::array<size_t, 3> nBinsXYZ)>&
-                      materialVectorToGridMapper,
-                  std::vector<double> xPos, std::vector<double> yPos,
-                  std::vector<double> zPos,
-                  const std::vector<Material>& material,
-                  double lengthUnit = UnitConstants::mm);
+materialMapperXYZ(
+    const std::function<std::size_t(std::array<std::size_t, 3> binsXYZ,
+                                    std::array<std::size_t, 3> nBinsXYZ)>&
+        materialVectorToGridMapper,
+    std::vector<double> xPos, std::vector<double> yPos,
+    std::vector<double> zPos, const std::vector<Material>& material,
+    double lengthUnit = UnitConstants::mm);
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Material/ProtoSurfaceMaterial.hpp b/Core/include/Acts/Material/ProtoSurfaceMaterial.hpp
index 1f5aff89e8a..c730da51d0b 100644
--- a/Core/include/Acts/Material/ProtoSurfaceMaterial.hpp
+++ b/Core/include/Acts/Material/ProtoSurfaceMaterial.hpp
@@ -94,7 +94,8 @@ class ProtoSurfaceMaterial : public ISurfaceMaterial {
   /// @param ib1 indicates the second bin
   ///
   /// @return will return dummy material
-  const MaterialSlab& materialSlab(size_t ib0, size_t ib1) const final;
+  const MaterialSlab& materialSlab(std::size_t ib0,
+                                   std::size_t ib1) const final;
 
   /// Output Method for std::ostream, to be overloaded by child classes
   std::ostream& toStream(std::ostream& sl) const final;
@@ -121,7 +122,7 @@ inline const Acts::MaterialSlab& Acts::ProtoSurfaceMaterial::materialSlab(
 }
 
 inline const Acts::MaterialSlab& Acts::ProtoSurfaceMaterial::materialSlab(
-    size_t /*ib0*/, size_t /*ib1*/) const {
+    std::size_t /*ib0*/, std::size_t /*ib1*/) const {
   return (m_materialSlab);
 }
 
diff --git a/Core/include/Acts/Navigation/DetectorVolumeFinders.hpp b/Core/include/Acts/Navigation/DetectorVolumeFinders.hpp
index 1dc9891ba80..def3ce6ea7f 100644
--- a/Core/include/Acts/Navigation/DetectorVolumeFinders.hpp
+++ b/Core/include/Acts/Navigation/DetectorVolumeFinders.hpp
@@ -102,7 +102,7 @@ struct IndexedDetectorVolumeExtractor {
   /// @return a raw DetectorVolume pointer
   inline static const DetectorVolume* extract(
       [[maybe_unused]] const GeometryContext& gctx,
-      const NavigationState& nState, size_t index) noexcept(false) {
+      const NavigationState& nState, std::size_t index) noexcept(false) {
     if (nState.currentDetector == nullptr) {
       throw std::runtime_error("IndexedVolumeExtractor: no detector given.");
     }
diff --git a/Core/include/Acts/Propagator/AtlasStepper.hpp b/Core/include/Acts/Propagator/AtlasStepper.hpp
index c2083804c51..93083e8c244 100644
--- a/Core/include/Acts/Propagator/AtlasStepper.hpp
+++ b/Core/include/Acts/Propagator/AtlasStepper.hpp
@@ -286,8 +286,8 @@ class AtlasStepper {
     bool debug = false;
     std::string debugString = "";
     /// buffer & formatting for consistent output
-    size_t debugPfxWidth = 30;
-    size_t debugMsgWidth = 50;
+    std::size_t debugPfxWidth = 30;
+    std::size_t debugMsgWidth = 50;
   };
 
   AtlasStepper(std::shared_ptr<const MagneticFieldProvider> bField)
@@ -1155,7 +1155,7 @@ class AtlasStepper {
     bool Helix = false;
     // if (std::abs(S) < m_cfg.helixStep) Helix = true;
 
-    size_t nStepTrials = 0;
+    std::size_t nStepTrials = 0;
     while (h != 0.) {
       // PS2 is h/(2*momentum) in EigenStepper
       double S3 = (1. / 3.) * h, S4 = .25 * h, PS2 = Pi * h;
diff --git a/Core/include/Acts/Propagator/ConstrainedStep.hpp b/Core/include/Acts/Propagator/ConstrainedStep.hpp
index 6d7de1bed0e..49d82f2dce1 100644
--- a/Core/include/Acts/Propagator/ConstrainedStep.hpp
+++ b/Core/include/Acts/Propagator/ConstrainedStep.hpp
@@ -53,7 +53,7 @@ class ConstrainedStep {
 
   /// Number of iterations needed by the stepsize finder
   /// (e.g. Runge-Kutta) of the stepper.
-  size_t nStepTrials = std::numeric_limits<size_t>::max();
+  std::size_t nStepTrials = std::numeric_limits<std::size_t>::max();
 
   constexpr ConstrainedStep() = default;
 
diff --git a/Core/include/Acts/Propagator/EigenStepper.ipp b/Core/include/Acts/Propagator/EigenStepper.ipp
index 9ebaffff1e0..bf0c29dde72 100644
--- a/Core/include/Acts/Propagator/EigenStepper.ipp
+++ b/Core/include/Acts/Propagator/EigenStepper.ipp
@@ -190,7 +190,7 @@ Acts::Result<double> Acts::EigenStepper<E, A>::step(
   const double initialH =
       state.stepping.stepSize.value() * state.options.direction;
   double h = initialH;
-  size_t nStepTrials = 0;
+  std::size_t nStepTrials = 0;
   // Select and adjust the appropriate Runge-Kutta step size as given
   // ATL-SOFT-PUB-2009-001
   while (true) {
diff --git a/Core/include/Acts/Seeding/BinFinder.hpp b/Core/include/Acts/Seeding/BinFinder.hpp
index 2e366827b97..64f04868b6a 100644
--- a/Core/include/Acts/Seeding/BinFinder.hpp
+++ b/Core/include/Acts/Seeding/BinFinder.hpp
@@ -36,8 +36,8 @@ class BinFinder {
   /// @param phiBin phi index of bin with middle space points
   /// @param zBin z index of bin with middle space points
   /// @param binnedSP phi-z grid containing all bins
-  boost::container::small_vector<size_t, 9> findBins(
-      size_t phiBin, size_t zBin,
+  boost::container::small_vector<std::size_t, 9> findBins(
+      std::size_t phiBin, std::size_t zBin,
       const SpacePointGrid<external_spacepoint_t>* binnedSP) const;
 
  private:
diff --git a/Core/include/Acts/Seeding/BinFinder.ipp b/Core/include/Acts/Seeding/BinFinder.ipp
index 94ad7cef4a7..087443c7383 100644
--- a/Core/include/Acts/Seeding/BinFinder.ipp
+++ b/Core/include/Acts/Seeding/BinFinder.ipp
@@ -12,9 +12,9 @@ Acts::BinFinder<external_spacepoint_t>::BinFinder(
     : m_zBinNeighbors(zBinNeighbors), m_numPhiNeighbors(numPhiNeighbors) {}
 
 template <typename external_spacepoint_t>
-boost::container::small_vector<size_t, 9>
+boost::container::small_vector<std::size_t, 9>
 Acts::BinFinder<external_spacepoint_t>::findBins(
-    size_t phiBin, size_t zBin,
+    std::size_t phiBin, std::size_t zBin,
     const Acts::SpacePointGrid<external_spacepoint_t>* binnedSP) const {
   // if zBinNeighbors is not defined, get the indices using
   // neighborHoodIndices
diff --git a/Core/include/Acts/Seeding/BinnedSPGroup.hpp b/Core/include/Acts/Seeding/BinnedSPGroup.hpp
index af3c45204b3..b04135c202f 100644
--- a/Core/include/Acts/Seeding/BinnedSPGroup.hpp
+++ b/Core/include/Acts/Seeding/BinnedSPGroup.hpp
@@ -56,8 +56,8 @@ class BinnedSPGroupIterator {
   bool operator==(const BinnedSPGroupIterator& other) const;
   bool operator!=(const BinnedSPGroupIterator& other) const;
 
-  std::tuple<boost::container::small_vector<size_t, 9>, std::size_t,
-             boost::container::small_vector<size_t, 9>>
+  std::tuple<boost::container::small_vector<std::size_t, 9>, std::size_t,
+             boost::container::small_vector<std::size_t, 9>>
   operator*() const;
 
  private:
@@ -104,7 +104,7 @@ class BinnedSPGroup {
 
   ~BinnedSPGroup() = default;
 
-  size_t size() const;
+  std::size_t size() const;
 
   BinnedSPGroupIterator<external_spacepoint_t> begin();
   BinnedSPGroupIterator<external_spacepoint_t> end();
@@ -127,7 +127,7 @@ class BinnedSPGroup {
   std::shared_ptr<const BinFinder<external_spacepoint_t>> m_bottomBinFinder;
 
   // Order of z bins to loop over when searching for SPs
-  std::vector<size_t> m_bins;
+  std::vector<std::size_t> m_bins;
   // Number of Z bins to skip the search for middle SP
   std::size_t m_skipZMiddleBin;
 };
diff --git a/Core/include/Acts/Seeding/BinnedSPGroup.ipp b/Core/include/Acts/Seeding/BinnedSPGroup.ipp
index 99fd1700007..0f10a0b3483 100644
--- a/Core/include/Acts/Seeding/BinnedSPGroup.ipp
+++ b/Core/include/Acts/Seeding/BinnedSPGroup.ipp
@@ -55,20 +55,20 @@ inline bool Acts::BinnedSPGroupIterator<external_spacepoint_t>::operator!=(
 }
 
 template <typename external_spacepoint_t>
-std::tuple<boost::container::small_vector<size_t, 9>, std::size_t,
-           boost::container::small_vector<size_t, 9>>
+std::tuple<boost::container::small_vector<std::size_t, 9>, std::size_t,
+           boost::container::small_vector<std::size_t, 9>>
 Acts::BinnedSPGroupIterator<external_spacepoint_t>::operator*() const {
   // Global Index
   std::size_t global_index = m_group->m_grid->globalBinFromLocalBins(
       {m_current_localBins[INDEX::PHI],
        m_group->m_bins[m_current_localBins[INDEX::Z]]});
 
-  boost::container::small_vector<size_t, 9> bottoms =
+  boost::container::small_vector<std::size_t, 9> bottoms =
       m_group->m_bottomBinFinder->findBins(
           m_current_localBins[INDEX::PHI],
           m_group->m_bins[m_current_localBins[INDEX::Z]],
           m_group->m_grid.get());
-  boost::container::small_vector<size_t, 9> tops =
+  boost::container::small_vector<std::size_t, 9> tops =
       m_group->m_topBinFinder->findBins(
           m_current_localBins[INDEX::PHI],
           m_group->m_bins[m_current_localBins[INDEX::Z]],
@@ -159,11 +159,11 @@ Acts::BinnedSPGroup<external_spacepoint_t>::BinnedSPGroup(
   // create number of bins equal to number of millimeters rMax
   // (worst case minR: configured minR + 1mm)
   // binSizeR allows to increase or reduce numRBins if needed
-  size_t numRBins = static_cast<size_t>((config.rMax + options.beamPos.norm()) /
-                                        config.binSizeR);
+  std::size_t numRBins = static_cast<std::size_t>(
+      (config.rMax + options.beamPos.norm()) / config.binSizeR);
 
   // keep track of changed bins while sorting
-  boost::container::flat_set<size_t> rBinsIndex;
+  boost::container::flat_set<std::size_t> rBinsIndex;
 
   std::size_t counter = 0;
   for (spacepoint_iterator_t it = spBegin; it != spEnd; it++, ++counter) {
@@ -194,7 +194,8 @@ Acts::BinnedSPGroup<external_spacepoint_t>::BinnedSPGroup(
         counter, sp, spPosition, options.beamPos, variance);
     // calculate r-Bin index and protect against overflow (underflow not
     // possible)
-    size_t rIndex = static_cast<size_t>(isp->radius() / config.binSizeR);
+    std::size_t rIndex =
+        static_cast<std::size_t>(isp->radius() / config.binSizeR);
     // if index out of bounds, the SP is outside the region of interest
     if (rIndex >= numRBins) {
       continue;
@@ -241,7 +242,7 @@ Acts::BinnedSPGroup<external_spacepoint_t>::BinnedSPGroup(
 }
 
 template <typename external_spacepoint_t>
-inline size_t Acts::BinnedSPGroup<external_spacepoint_t>::size() const {
+inline std::size_t Acts::BinnedSPGroup<external_spacepoint_t>::size() const {
   return m_grid->size();
 }
 
diff --git a/Core/include/Acts/Seeding/EstimateTrackParamsFromSeed.hpp b/Core/include/Acts/Seeding/EstimateTrackParamsFromSeed.hpp
index 33071afad60..18bb4746425 100644
--- a/Core/include/Acts/Seeding/EstimateTrackParamsFromSeed.hpp
+++ b/Core/include/Acts/Seeding/EstimateTrackParamsFromSeed.hpp
@@ -53,7 +53,7 @@ std::optional<BoundVector> estimateTrackParamsFromSeed(
     spacepoint_iterator_t spBegin, spacepoint_iterator_t spEnd,
     const Logger& logger = getDummyLogger()) {
   // Check the number of provided space points
-  size_t numSP = std::distance(spBegin, spEnd);
+  std::size_t numSP = std::distance(spBegin, spEnd);
   if (numSP < 3) {
     ACTS_ERROR("At least three space points are required.")
     return std::nullopt;
@@ -158,7 +158,7 @@ std::optional<BoundVector> estimateTrackParamsFromSeed(
     ActsScalar bFieldMin, const Acts::Logger& logger = getDummyLogger(),
     ActsScalar mass = 139.57018 * UnitConstants::MeV) {
   // Check the number of provided space points
-  size_t numSP = std::distance(spBegin, spEnd);
+  std::size_t numSP = std::distance(spBegin, spEnd);
   if (numSP != 3) {
     ACTS_ERROR("There should be exactly three space points provided.")
     return std::nullopt;
@@ -182,7 +182,7 @@ std::optional<BoundVector> estimateTrackParamsFromSeed(
                                               Vector3::Zero()};
   // The first, second and third space point are assumed to be bottom, middle
   // and top space point, respectively
-  for (size_t isp = 0; isp < 3; ++isp) {
+  for (std::size_t isp = 0; isp < 3; ++isp) {
     spacepoint_iterator_t it = std::next(spBegin, isp);
     if (*it == nullptr) {
       ACTS_ERROR("Empty space point found. This should not happen.")
diff --git a/Core/include/Acts/Seeding/GNN_DataStorage.hpp b/Core/include/Acts/Seeding/GNN_DataStorage.hpp
index 7a6b1c3b0e8..fb630b43a3f 100644
--- a/Core/include/Acts/Seeding/GNN_DataStorage.hpp
+++ b/Core/include/Acts/Seeding/GNN_DataStorage.hpp
@@ -18,8 +18,8 @@
 
 namespace Acts {
 
-constexpr size_t MAX_SEG_PER_NODE = 1000;  // was 30
-constexpr size_t N_SEG_CONNS = 6;          // was 6
+constexpr std::size_t MAX_SEG_PER_NODE = 1000;  // was 30
+constexpr std::size_t N_SEG_CONNS = 6;          // was 6
 
 // new sp struct
 template <typename space_point_t>
diff --git a/Core/include/Acts/Seeding/SeedFilter.hpp b/Core/include/Acts/Seeding/SeedFilter.hpp
index af6e6ff4dfb..10087ed7f39 100644
--- a/Core/include/Acts/Seeding/SeedFilter.hpp
+++ b/Core/include/Acts/Seeding/SeedFilter.hpp
@@ -26,7 +26,7 @@ struct SeedFilterState {
   // longitudinal impact parameter as defined by bottom and middle space point
   float zOrigin = 0;
   // number of minimum top SPs in seed confirmation
-  size_t nTopSeedConf = 0;
+  std::size_t nTopSeedConf = 0;
   // radius of bottom component of seed that is used to define the number of
   // compatible top required
   float rMaxSeedConf =
diff --git a/Core/include/Acts/Seeding/SeedFilter.ipp b/Core/include/Acts/Seeding/SeedFilter.ipp
index ffb7db2bbf5..7dda20aea67 100644
--- a/Core/include/Acts/Seeding/SeedFilter.ipp
+++ b/Core/include/Acts/Seeding/SeedFilter.ipp
@@ -54,30 +54,31 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
             : seedConfRange.nTopForSmallR;
   }
 
-  size_t maxWeightSeedIndex = 0;
+  std::size_t maxWeightSeedIndex = 0;
   bool maxWeightSeed = false;
   float weightMax = std::numeric_limits<float>::lowest();
   float zOrigin = seedFilterState.zOrigin;
 
   // initialize original index locations
-  std::vector<size_t> topSPIndexVec(topSpVec.size());
+  std::vector<std::size_t> topSPIndexVec(topSpVec.size());
   for (std::size_t i(0); i < topSPIndexVec.size(); ++i) {
     topSPIndexVec[i] = i;
   }
 
   if (topSpVec.size() > 2) {
     // sort indexes based on comparing values in invHelixDiameterVec
-    std::sort(topSPIndexVec.begin(), topSPIndexVec.end(),
-              [&invHelixDiameterVec](const size_t i1, const size_t i2) {
-                return invHelixDiameterVec[i1] < invHelixDiameterVec[i2];
-              });
+    std::sort(
+        topSPIndexVec.begin(), topSPIndexVec.end(),
+        [&invHelixDiameterVec](const std::size_t i1, const std::size_t i2) {
+          return invHelixDiameterVec[i1] < invHelixDiameterVec[i2];
+        });
   }
 
   // vector containing the radius of all compatible seeds
   std::vector<float> compatibleSeedR;
   compatibleSeedR.reserve(m_cfg.compatSeedLimit);
 
-  size_t beginCompTopIndex = 0;
+  std::size_t beginCompTopIndex = 0;
   // loop over top SPs and other compatible top SP candidates
   for (const std::size_t topSPIndex : topSPIndexVec) {
     // if two compatible seeds with high distance in r are found, compatible
@@ -97,9 +98,9 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
     float weight = -(impact * m_cfg.impactWeightFactor);
 
     // loop over compatible top SP candidates
-    for (size_t variableCompTopIndex = beginCompTopIndex;
+    for (std::size_t variableCompTopIndex = beginCompTopIndex;
          variableCompTopIndex < topSPIndexVec.size(); variableCompTopIndex++) {
-      size_t compatibleTopSPIndex = topSPIndexVec[variableCompTopIndex];
+      std::size_t compatibleTopSPIndex = topSPIndexVec[variableCompTopIndex];
       if (compatibleTopSPIndex == topSPIndex) {
         continue;
       }
diff --git a/Core/include/Acts/Seeding/SeedFilterConfig.hpp b/Core/include/Acts/Seeding/SeedFilterConfig.hpp
index 72a8eccd57e..bd700b5a4c8 100644
--- a/Core/include/Acts/Seeding/SeedFilterConfig.hpp
+++ b/Core/include/Acts/Seeding/SeedFilterConfig.hpp
@@ -35,7 +35,7 @@ struct SeedFilterConfig {
   unsigned int maxSeedsPerSpM = 10;
   // how often do you want to increase the weight of a seed for finding a
   // compatible seed?
-  size_t compatSeedLimit = 2;
+  std::size_t compatSeedLimit = 2;
   // Tool to apply experiment specific cuts on collected middle space points
 
   // increment in seed weight if the number of compatible seeds is larger than
diff --git a/Core/include/Acts/Seeding/SeedFinder.ipp b/Core/include/Acts/Seeding/SeedFinder.ipp
index ceaf55536e3..ac782635e75 100644
--- a/Core/include/Acts/Seeding/SeedFinder.ipp
+++ b/Core/include/Acts/Seeding/SeedFinder.ipp
@@ -481,7 +481,7 @@ inline void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
   state.curvatures.reserve(numTopSP);
   state.impactParameters.reserve(numTopSP);
 
-  size_t t0 = 0;
+  std::size_t t0 = 0;
 
   // clear previous results and then loop on bottoms and tops
   state.candidates_collector.clear();
@@ -533,7 +533,7 @@ inline void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
     // minimum number of compatible top SPs to trigger the filter for a certain
     // middle bottom pair if seedConfirmation is false we always ask for at
     // least one compatible top to trigger the filter
-    size_t minCompatibleTopSPs = 2;
+    std::size_t minCompatibleTopSPs = 2;
     if (!m_config.seedConfirmation ||
         state.compatBottomSP[b]->radius() > seedFilterState.rMaxSeedConf) {
       minCompatibleTopSPs = 1;
@@ -542,7 +542,7 @@ inline void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
       minCompatibleTopSPs++;
     }
 
-    for (size_t index_t = t0; index_t < numTopSP; index_t++) {
+    for (std::size_t index_t = t0; index_t < numTopSP; index_t++) {
       const std::size_t t = sorted_tops[index_t];
 
       auto lt = state.linCircleTop[t];
diff --git a/Core/include/Acts/Seeding/SeedFinderConfig.hpp b/Core/include/Acts/Seeding/SeedFinderConfig.hpp
index 5cd6cf2820f..d74052acc62 100644
--- a/Core/include/Acts/Seeding/SeedFinderConfig.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderConfig.hpp
@@ -121,7 +121,7 @@ struct SeedFinderConfig {
   float rMin = 33 * Acts::UnitConstants::mm;
 
   // Order of z bins to loop over when searching for SPs
-  std::vector<size_t> zBinsCustomLooping = {};
+  std::vector<std::size_t> zBinsCustomLooping = {};
   // Number of Z bins to skip the search for middle SPs
   std::size_t skipZMiddleBinSearch = 0;
 
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
index 049f2a77dad..ec11c8ee926 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
@@ -313,13 +313,13 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
   std::vector<float> tanMT;
   tanMT.reserve(top.size());
 
-  size_t numTopSP = top.size();
-  for (size_t t = 0; t < numTopSP; t++) {
+  std::size_t numTopSP = top.size();
+  for (std::size_t t = 0; t < numTopSP; t++) {
     tanMT.push_back(
         std::atan2(top[t]->radius() - middle.radius(), top[t]->z() - zM));
   }
 
-  size_t t0 = 0;
+  std::size_t t0 = 0;
 
   for (const std::size_t b : sorted_bottoms) {
     // break if we reached the last top SP
@@ -346,7 +346,7 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
     // minimum number of compatible top SPs to trigger the filter for a certain
     // middle bottom pair if seedConfirmation is false we always ask for at
     // least one compatible top to trigger the filter
-    size_t minCompatibleTopSPs = 2;
+    std::size_t minCompatibleTopSPs = 2;
     if (!m_config.seedConfirmation ||
         bottom[b]->radius() > seedFilterState.rMaxSeedConf) {
       minCompatibleTopSPs = 1;
@@ -362,7 +362,7 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
 
     float tanLM = std::atan2(rM - bottom[b]->radius(), zM - bottom[b]->z());
 
-    for (size_t index_t = t0; index_t < numTopSP; index_t++) {
+    for (std::size_t index_t = t0; index_t < numTopSP; index_t++) {
       const std::size_t t = sorted_tops[index_t];
       auto lt = linCircleTop[t];
 
diff --git a/Core/include/Acts/Surfaces/ConeSurface.hpp b/Core/include/Acts/Surfaces/ConeSurface.hpp
index 919eb84e0c2..af3bff88313 100644
--- a/Core/include/Acts/Surfaces/ConeSurface.hpp
+++ b/Core/include/Acts/Surfaces/ConeSurface.hpp
@@ -208,7 +208,7 @@ class ConeSurface : public Surface {
   ///
   /// @return A list of vertices and a face/facett description of it
   Polyhedron polyhedronRepresentation(const GeometryContext& gctx,
-                                      size_t lseg) const override;
+                                      std::size_t lseg) const override;
 
   /// Return properly formatted class name for screen output
   std::string name() const override;
diff --git a/Core/include/Acts/Surfaces/ConvexPolygonBounds.hpp b/Core/include/Acts/Surfaces/ConvexPolygonBounds.hpp
index fabe59e7a65..bb4043c15c3 100644
--- a/Core/include/Acts/Surfaces/ConvexPolygonBounds.hpp
+++ b/Core/include/Acts/Surfaces/ConvexPolygonBounds.hpp
@@ -67,13 +67,13 @@ class ConvexPolygonBounds : public ConvexPolygonBoundsBase {
  public:
   /// Expose number of vertices given as template parameter.
   ///
-  static constexpr size_t num_vertices = N;
+  static constexpr std::size_t num_vertices = N;
   /// Type that's used to store the vertices, in this case a fixed size array.
   ///
   using vertex_array = std::array<Vector2, num_vertices>;
   /// Expose number of parameters as a template parameter
   ///
-  static constexpr size_t eSize = 2 * N;
+  static constexpr std::size_t eSize = 2 * N;
   /// Type that's used to store the vertices, in this case a fixed size array.
   ///
   using value_array = std::array<double, eSize>;
diff --git a/Core/include/Acts/Surfaces/ConvexPolygonBounds.ipp b/Core/include/Acts/Surfaces/ConvexPolygonBounds.ipp
index 452cdba5578..f83b7acb41b 100644
--- a/Core/include/Acts/Surfaces/ConvexPolygonBounds.ipp
+++ b/Core/include/Acts/Surfaces/ConvexPolygonBounds.ipp
@@ -14,9 +14,9 @@ void Acts::ConvexPolygonBoundsBase::convex_impl(
   static_assert(std::is_same<typename coll_t::value_type, Vector2>::value,
                 "Must be collection of Vector2");
 
-  const size_t N = vertices.size();
-  for (size_t i = 0; i < N; i++) {
-    size_t j = (i + 1) % N;
+  const std::size_t N = vertices.size();
+  for (std::size_t i = 0; i < N; i++) {
+    std::size_t j = (i + 1) % N;
     const Vector2& a = vertices[i];
     const Vector2& b = vertices[j];
 
@@ -26,7 +26,7 @@ void Acts::ConvexPolygonBoundsBase::convex_impl(
     bool first = true;
     bool ref = false;
     // loop over all other vertices
-    for (size_t k = 0; k < N; k++) {
+    for (std::size_t k = 0; k < N; k++) {
       if (k == i || k == j) {
         continue;
       }
@@ -55,7 +55,7 @@ Acts::RectangleBounds Acts::ConvexPolygonBoundsBase::makeBoundingBox(
   vmax = vertices[0];
   vmin = vertices[0];
 
-  for (size_t i = 1; i < vertices.size(); i++) {
+  for (std::size_t i = 1; i < vertices.size(); i++) {
     vmax = vmax.cwiseMax(vertices[i]);
     vmin = vmin.cwiseMin(vertices[i]);
   }
@@ -69,7 +69,7 @@ Acts::ConvexPolygonBounds<N>::ConvexPolygonBounds(
     : m_vertices(), m_boundingBox(makeBoundingBox(vertices)) {
   throw_assert(vertices.size() == N,
                "Size and number of given vertices do not match.");
-  for (size_t i = 0; i < N; i++) {
+  for (std::size_t i = 0; i < N; i++) {
     m_vertices[i] = vertices[i];
   }
   checkConsistency();
@@ -86,7 +86,7 @@ template <int N>
 Acts::ConvexPolygonBounds<N>::ConvexPolygonBounds(
     const value_array& values) noexcept(false)
     : m_vertices(), m_boundingBox(0., 0.) {
-  for (size_t i = 0; i < N; i++) {
+  for (std::size_t i = 0; i < N; i++) {
     m_vertices[i] = Vector2(values[2 * i], values[2 * i + 1]);
   }
   makeBoundingBox(m_vertices);
diff --git a/Core/include/Acts/Surfaces/CylinderBounds.hpp b/Core/include/Acts/Surfaces/CylinderBounds.hpp
index f59fce2ce39..73a2f6ad1d2 100644
--- a/Core/include/Acts/Surfaces/CylinderBounds.hpp
+++ b/Core/include/Acts/Surfaces/CylinderBounds.hpp
@@ -124,7 +124,8 @@ class CylinderBounds : public SurfaceBounds {
   ///
   /// @param trans is the global transform
   /// @param lseg  are the numbero if phi segments
-  std::vector<Vector3> createCircles(const Transform3 trans, size_t lseg) const;
+  std::vector<Vector3> createCircles(const Transform3 trans,
+                                     std::size_t lseg) const;
 
   /// Output Method for std::ostream
   std::ostream& toStream(std::ostream& sl) const final;
diff --git a/Core/include/Acts/Surfaces/CylinderSurface.hpp b/Core/include/Acts/Surfaces/CylinderSurface.hpp
index d1a58eb0854..0c73da735d0 100644
--- a/Core/include/Acts/Surfaces/CylinderSurface.hpp
+++ b/Core/include/Acts/Surfaces/CylinderSurface.hpp
@@ -220,7 +220,7 @@ class CylinderSurface : public Surface {
   ///
   /// @return A list of vertices and a face/facett description of it
   Polyhedron polyhedronRepresentation(const GeometryContext& gctx,
-                                      size_t lseg) const override;
+                                      std::size_t lseg) const override;
 
   /// Calculate the derivative of path length at the geometry constraint or
   /// point-of-closest-approach w.r.t. alignment parameters of the surface (i.e.
diff --git a/Core/include/Acts/Surfaces/DiscSurface.hpp b/Core/include/Acts/Surfaces/DiscSurface.hpp
index 1380e020280..75cdacd89b8 100644
--- a/Core/include/Acts/Surfaces/DiscSurface.hpp
+++ b/Core/include/Acts/Surfaces/DiscSurface.hpp
@@ -301,7 +301,7 @@ class DiscSurface : public Surface {
   ///
   /// @return A list of vertices and a face/facett description of it
   Polyhedron polyhedronRepresentation(const GeometryContext& gctx,
-                                      size_t lseg) const override;
+                                      std::size_t lseg) const override;
 
   /// Calculate the derivative of bound track parameters local position w.r.t.
   /// position in local 3D Cartesian coordinates
diff --git a/Core/include/Acts/Surfaces/PerigeeSurface.hpp b/Core/include/Acts/Surfaces/PerigeeSurface.hpp
index 03523b991c8..78e9cb89138 100644
--- a/Core/include/Acts/Surfaces/PerigeeSurface.hpp
+++ b/Core/include/Acts/Surfaces/PerigeeSurface.hpp
@@ -90,7 +90,7 @@ class PerigeeSurface : public LineSurface {
   ///
   /// @return A list of vertices and a face/facett description of it
   Polyhedron polyhedronRepresentation(const GeometryContext& gctx,
-                                      size_t lseg) const final;
+                                      std::size_t lseg) const final;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Surfaces/PlaneSurface.hpp b/Core/include/Acts/Surfaces/PlaneSurface.hpp
index d652b252fea..3d54eb32b68 100644
--- a/Core/include/Acts/Surfaces/PlaneSurface.hpp
+++ b/Core/include/Acts/Surfaces/PlaneSurface.hpp
@@ -202,7 +202,7 @@ class PlaneSurface : public Surface {
   ///
   /// @return A list of vertices and a face/facett description of it
   Polyhedron polyhedronRepresentation(const GeometryContext& gctx,
-                                      size_t lseg) const override;
+                                      std::size_t lseg) const override;
 
   /// Return properly formatted class name for screen output
   std::string name() const override;
diff --git a/Core/include/Acts/Surfaces/StrawSurface.hpp b/Core/include/Acts/Surfaces/StrawSurface.hpp
index 8d3201bdc6d..b0052c53194 100644
--- a/Core/include/Acts/Surfaces/StrawSurface.hpp
+++ b/Core/include/Acts/Surfaces/StrawSurface.hpp
@@ -99,7 +99,7 @@ class StrawSurface : public LineSurface {
   ///
   /// @return A list of vertices and a face/facett description of it
   Polyhedron polyhedronRepresentation(const GeometryContext& gctx,
-                                      size_t lseg) const final;
+                                      std::size_t lseg) const final;
 };
 
 inline Surface::SurfaceType StrawSurface::type() const {
diff --git a/Core/include/Acts/Surfaces/Surface.hpp b/Core/include/Acts/Surfaces/Surface.hpp
index 7841b57c862..28dfedb2df0 100644
--- a/Core/include/Acts/Surfaces/Surface.hpp
+++ b/Core/include/Acts/Surfaces/Surface.hpp
@@ -445,7 +445,7 @@ class Surface : public virtual GeometryObject,
   ///
   /// @return A list of vertices and a face/facett description of it
   virtual Polyhedron polyhedronRepresentation(const GeometryContext& gctx,
-                                              size_t lseg) const = 0;
+                                              std::size_t lseg) const = 0;
 
   /// The derivative of bound track parameters w.r.t. alignment
   /// parameters of its reference surface (i.e. local frame origin in
diff --git a/Core/include/Acts/Surfaces/SurfaceArray.hpp b/Core/include/Acts/Surfaces/SurfaceArray.hpp
index f78826794d2..bc24af364d1 100644
--- a/Core/include/Acts/Surfaces/SurfaceArray.hpp
+++ b/Core/include/Acts/Surfaces/SurfaceArray.hpp
@@ -47,8 +47,8 @@ class SurfaceArray {
 
     /// @param surfaces The surface pointers to fill
     /// @return number of bins that were filled
-    virtual size_t completeBinning(const GeometryContext& gctx,
-                                   const SurfaceVector& surfaces) = 0;
+    virtual std::size_t completeBinning(const GeometryContext& gctx,
+                                        const SurfaceVector& surfaces) = 0;
 
     /// @brief Performs lookup at @c pos and returns bin content as reference
     /// @param position Lookup position
@@ -65,13 +65,13 @@ class SurfaceArray {
     /// reference
     /// @param bin Global lookup bin
     /// @return @c SurfaceVector at given bin
-    virtual SurfaceVector& lookup(size_t bin) = 0;
+    virtual SurfaceVector& lookup(std::size_t bin) = 0;
 
     /// @brief Performs lookup at global bin and returns bin content as const
     /// reference
     /// @param bin Global lookup bin
     /// @return @c SurfaceVector at given bin
-    virtual const SurfaceVector& lookup(size_t bin) const = 0;
+    virtual const SurfaceVector& lookup(std::size_t bin) const = 0;
 
     /// @brief Performs a lookup at @c pos, but returns neighbors as well
     ///
@@ -82,12 +82,12 @@ class SurfaceArray {
     /// @brief Returns the total size of the grid (including under/overflow
     /// bins)
     /// @return Size of the grid data structure
-    virtual size_t size() const = 0;
+    virtual std::size_t size() const = 0;
 
     /// @brief Gets the center position of bin @c bin in global coordinates
     /// @param bin the global bin index
     /// @return The bin center
-    virtual Vector3 getBinCenter(size_t bin) const = 0;
+    virtual Vector3 getBinCenter(std::size_t bin) const = 0;
 
     /// @brief Returns copies of the axes used in the grid as @c AnyAxis
     /// @return The axes
@@ -96,14 +96,14 @@ class SurfaceArray {
 
     /// @brief Get the number of dimensions of the grid.
     /// @return number of dimensions
-    virtual size_t dimensions() const = 0;
+    virtual std::size_t dimensions() const = 0;
 
     /// @brief Checks if global bin is valid
     /// @param bin the global bin index
     /// @return bool if the bin is valid
     /// @note Valid means that the index points to a bin which is not a under
     ///       or overflow bin or out of range in any axis.
-    virtual bool isValidBin(size_t bin) const = 0;
+    virtual bool isValidBin(std::size_t bin) const = 0;
 
     /// @brief The binning values described by this surface grid lookup
     /// They are in order of the axes (optional) and empty for eingle lookups
@@ -117,7 +117,7 @@ class SurfaceArray {
   /// @tparam Axes The axes used for the grid
   template <class... Axes>
   struct SurfaceGridLookup : ISurfaceGridLookup {
-    static constexpr size_t DIM = sizeof...(Axes);
+    static constexpr std::size_t DIM = sizeof...(Axes);
 
    public:
     /// @brief Specifies the local coordinate type.
@@ -173,15 +173,15 @@ class SurfaceArray {
     /// @param gctx The current geometry context object, e.g. alignment
     /// @param surfaces The surface pointers to fill
     /// @return number of bins that were filled
-    size_t completeBinning(const GeometryContext& gctx,
-                           const SurfaceVector& surfaces) override {
-      size_t binCompleted = 0;
-      size_t nBins = size();
+    std::size_t completeBinning(const GeometryContext& gctx,
+                                const SurfaceVector& surfaces) override {
+      std::size_t binCompleted = 0;
+      std::size_t nBins = size();
       double minPath = 0;
       double curPath = 0;
       const Surface* minSrf = nullptr;
 
-      for (size_t b = 0; b < nBins; ++b) {
+      for (std::size_t b = 0; b < nBins; ++b) {
         if (!isValidBin(b)) {
           continue;
         }
@@ -230,13 +230,13 @@ class SurfaceArray {
     /// reference
     /// @param bin Global lookup bin
     /// @return @c SurfaceVector at given bin
-    SurfaceVector& lookup(size_t bin) override { return m_grid.at(bin); }
+    SurfaceVector& lookup(std::size_t bin) override { return m_grid.at(bin); }
 
     /// @brief Performs lookup at global bin and returns bin content as const
     /// reference
     /// @param bin Global lookup bin
     /// @return @c SurfaceVector at given bin
-    const SurfaceVector& lookup(size_t bin) const override {
+    const SurfaceVector& lookup(std::size_t bin) const override {
       return m_grid.at(bin);
     }
 
@@ -252,7 +252,7 @@ class SurfaceArray {
     /// @brief Returns the total size of the grid (including under/overflow
     /// bins)
     /// @return Size of the grid data structure
-    size_t size() const override { return m_grid.size(); }
+    std::size_t size() const override { return m_grid.size(); }
 
     /// @brief The binning values described by this surface grid lookup
     /// They are in order of the axes
@@ -263,7 +263,7 @@ class SurfaceArray {
     /// @brief Gets the center position of bin @c bin in global coordinates
     /// @param bin the global bin index
     /// @return The bin center
-    Vector3 getBinCenter(size_t bin) const override {
+    Vector3 getBinCenter(std::size_t bin) const override {
       return getBinCenterImpl(bin);
     }
 
@@ -277,18 +277,18 @@ class SurfaceArray {
 
     /// @brief Get the number of dimensions of the grid.
     /// @return number of dimensions
-    size_t dimensions() const override { return DIM; }
+    std::size_t dimensions() const override { return DIM; }
 
     /// @brief Checks if global bin is valid
     /// @param bin the global bin index
     /// @return bool if the bin is valid
     /// @note Valid means that the index points to a bin which is not a under
     ///       or overflow bin or out of range in any axis.
-    bool isValidBin(size_t bin) const override {
-      std::array<size_t, DIM> indices = m_grid.localBinsFromGlobalBin(bin);
-      std::array<size_t, DIM> nBins = m_grid.numLocalBins();
-      for (size_t i = 0; i < indices.size(); ++i) {
-        size_t idx = indices.at(i);
+    bool isValidBin(std::size_t bin) const override {
+      std::array<std::size_t, DIM> indices = m_grid.localBinsFromGlobalBin(bin);
+      std::array<std::size_t, DIM> nBins = m_grid.numLocalBins();
+      for (std::size_t i = 0; i < indices.size(); ++i) {
+        std::size_t idx = indices.at(i);
         if (idx <= 0 || idx >= nBins.at(i) + 1) {
           return false;
         }
@@ -300,7 +300,7 @@ class SurfaceArray {
    private:
     void populateNeighborCache() {
       // calculate neighbors for every bin and store in map
-      for (size_t i = 0; i < m_grid.size(); i++) {
+      for (std::size_t i = 0; i < m_grid.size(); i++) {
         if (!isValidBin(i)) {
           continue;
         }
@@ -327,16 +327,16 @@ class SurfaceArray {
     /// interface stays the same, since we don't care what happens
     /// here on the callers end
     /// This is the version for DIM>1
-    template <size_t D = DIM, std::enable_if_t<D != 1, int> = 0>
-    Vector3 getBinCenterImpl(size_t bin) const {
+    template <std::size_t D = DIM, std::enable_if_t<D != 1, int> = 0>
+    Vector3 getBinCenterImpl(std::size_t bin) const {
       return m_localToGlobal(ActsVector<DIM>(
           m_grid.binCenter(m_grid.localBinsFromGlobalBin(bin)).data()));
     }
 
     /// Internal method, see above.
     /// This is the version for DIM==1
-    template <size_t D = DIM, std::enable_if_t<D == 1, int> = 0>
-    Vector3 getBinCenterImpl(size_t bin) const {
+    template <std::size_t D = DIM, std::enable_if_t<D == 1, int> = 0>
+    Vector3 getBinCenterImpl(std::size_t bin) const {
       point_t pos = m_grid.binCenter(m_grid.localBinsFromGlobalBin(bin));
       return m_localToGlobal(pos);
     }
@@ -379,7 +379,7 @@ class SurfaceArray {
     /// @brief Lookup, always returns @c element
     /// @param bin is ignored
     /// @return reference to vector containing only @c element
-    SurfaceVector& lookup(size_t bin) override {
+    SurfaceVector& lookup(std::size_t bin) override {
       (void)bin;
       return m_element;
     }
@@ -387,7 +387,7 @@ class SurfaceArray {
     /// @brief Lookup, always returns @c element
     /// @param bin is ignored
     /// @return reference to vector containing only @c element
-    const SurfaceVector& lookup(size_t bin) const override {
+    const SurfaceVector& lookup(std::size_t bin) const override {
       (void)bin;
       return m_element;
     }
@@ -402,12 +402,12 @@ class SurfaceArray {
 
     /// @brief returns 1
     /// @return 1
-    size_t size() const override { return 1; }
+    std::size_t size() const override { return 1; }
 
     /// @brief Gets the bin center, but always returns (0, 0, 0)
     /// @param bin is ignored
     /// @return (0, 0, 0)
-    Vector3 getBinCenter(size_t bin) const override {
+    Vector3 getBinCenter(std::size_t bin) const override {
       (void)bin;
       return Vector3(0, 0, 0);
     }
@@ -418,7 +418,7 @@ class SurfaceArray {
 
     /// @brief Get the number of dimensions
     /// @return always 0
-    size_t dimensions() const override { return 0; }
+    std::size_t dimensions() const override { return 0; }
 
     /// @brief Comply with concept and provide fill method
     /// @note Does nothing
@@ -427,15 +427,15 @@ class SurfaceArray {
 
     /// @brief Comply with concept and provide completeBinning method
     /// @note Does nothing
-    size_t completeBinning(const GeometryContext& /*gctx*/,
-                           const SurfaceVector& /*surfaces*/) override {
+    std::size_t completeBinning(const GeometryContext& /*gctx*/,
+                                const SurfaceVector& /*surfaces*/) override {
       return 0;
     }
 
     /// @brief Returns if the bin is valid (it is)
     /// @param bin is ignored
     /// @return always true
-    bool isValidBin(size_t bin) const override {
+    bool isValidBin(std::size_t bin) const override {
       (void)bin;
       return true;
     }
@@ -477,12 +477,12 @@ class SurfaceArray {
   /// @brief Get all surfaces in bin given by global bin index @p bin.
   /// @param bin the global bin index
   /// @return reference to @c SurfaceVector contained in bin
-  SurfaceVector& at(size_t bin) { return p_gridLookup->lookup(bin); }
+  SurfaceVector& at(std::size_t bin) { return p_gridLookup->lookup(bin); }
 
   /// @brief Get all surfaces in bin given by global bin index.
   /// @param bin the global bin index
   /// @return const reference to @c SurfaceVector contained in bin
-  const SurfaceVector& at(size_t bin) const {
+  const SurfaceVector& at(std::size_t bin) const {
     return p_gridLookup->lookup(bin);
   }
 
@@ -499,12 +499,14 @@ class SurfaceArray {
   /// @brief Get the size of the underlying grid structure including
   /// under/overflow bins
   /// @return the size
-  size_t size() const { return p_gridLookup->size(); }
+  std::size_t size() const { return p_gridLookup->size(); }
 
   /// @brief Get the center of the bin identified by global bin index @p bin
   /// @param bin the global bin index
   /// @return Center position of the bin in global coordinates
-  Vector3 getBinCenter(size_t bin) { return p_gridLookup->getBinCenter(bin); }
+  Vector3 getBinCenter(std::size_t bin) {
+    return p_gridLookup->getBinCenter(bin);
+  }
 
   /// @brief Get all surfaces attached to this @c SurfaceArray
   /// @return Reference to @c SurfaceVector containing all surfaces
@@ -524,7 +526,9 @@ class SurfaceArray {
   /// @return bool if the bin is valid
   /// @note Valid means that the index points to a bin which is not a under
   ///       or overflow bin or out of range in any axis.
-  bool isValidBin(size_t bin) const { return p_gridLookup->isValidBin(bin); }
+  bool isValidBin(std::size_t bin) const {
+    return p_gridLookup->isValidBin(bin);
+  }
 
   const Transform3& transform() const { return m_transform; }
 
diff --git a/Core/include/Acts/Surfaces/detail/FacesHelper.hpp b/Core/include/Acts/Surfaces/detail/FacesHelper.hpp
index 0ef79e69e4d..7438020a268 100644
--- a/Core/include/Acts/Surfaces/detail/FacesHelper.hpp
+++ b/Core/include/Acts/Surfaces/detail/FacesHelper.hpp
@@ -37,7 +37,7 @@ struct FacesHelper {
     FaceVector triangularMesh;
     // Write the face
     unsigned int offset = centerLast ? 1 : 0;
-    std::vector<size_t> face(vertices.size() - offset);
+    std::vector<std::size_t> face(vertices.size() - offset);
     std::iota(face.begin(), face.end(), 0);
     faces.push_back(face);
     /// Triangular mesh construction
@@ -67,15 +67,16 @@ struct FacesHelper {
       const std::vector<Vector3>& vertices, bool fullTwoPi = true) {
     FaceVector faces;
     FaceVector triangularMesh;
-    size_t nqfaces = static_cast<size_t>(0.5 * vertices.size());
-    size_t reduce = (!fullTwoPi) ? 1 : 0;
-    for (size_t iface = 0; iface < nqfaces - reduce; ++iface) {
-      size_t p2 = (iface + 1 == nqfaces) ? 0 : iface + 1;
-      std::vector<size_t> face = {iface, p2, p2 + nqfaces, nqfaces + iface};
+    std::size_t nqfaces = static_cast<std::size_t>(0.5 * vertices.size());
+    std::size_t reduce = (!fullTwoPi) ? 1 : 0;
+    for (std::size_t iface = 0; iface < nqfaces - reduce; ++iface) {
+      std::size_t p2 = (iface + 1 == nqfaces) ? 0 : iface + 1;
+      std::vector<std::size_t> face = {iface, p2, p2 + nqfaces,
+                                       nqfaces + iface};
       faces.push_back(face);
-      std::vector<size_t> triA = {iface, p2, p2 + nqfaces};
+      std::vector<std::size_t> triA = {iface, p2, p2 + nqfaces};
       triangularMesh.push_back(triA);
-      std::vector<size_t> triB = {p2 + nqfaces, nqfaces + iface, iface};
+      std::vector<std::size_t> triB = {p2 + nqfaces, nqfaces + iface, iface};
       triangularMesh.push_back(triB);
     }
     return {faces, triangularMesh};
diff --git a/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp b/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
index 39f8832bb39..b43c7da3288 100644
--- a/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
+++ b/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
@@ -65,15 +65,15 @@ enum class CombinatorialKalmanFilterTargetSurfaceStrategy {
 /// @todo: add other useful info, e.g. chi2
 struct CombinatorialKalmanFilterTipState {
   // Number of passed sensitive surfaces
-  size_t nSensitiveSurfaces = 0;
+  std::size_t nSensitiveSurfaces = 0;
   // Number of track states
-  size_t nStates = 0;
+  std::size_t nStates = 0;
   // Number of (non-outlier) measurements
-  size_t nMeasurements = 0;
+  std::size_t nMeasurements = 0;
   // Number of outliers
-  size_t nOutliers = 0;
+  std::size_t nOutliers = 0;
   // Number of holes
-  size_t nHoles = 0;
+  std::size_t nHoles = 0;
 };
 
 /// Extension struct which holds the delegates to customize the CKF behavior
@@ -254,7 +254,8 @@ struct CombinatorialKalmanFilterResult {
 
   /// The indices of track states and corresponding source links on different
   /// surfaces
-  std::unordered_map<const Surface*, std::unordered_map<size_t, size_t>>
+  std::unordered_map<const Surface*,
+                     std::unordered_map<std::size_t, std::size_t>>
       sourcelinkTips;
 
   /// Indicator if filtering has been done
@@ -669,7 +670,7 @@ class CombinatorialKalmanFilter {
                         const stepper_t& stepper, const navigator_t& navigator,
                         result_type& result) const {
       // Initialize the number of branches on current surface
-      size_t nBranchesOnSurface = 0;
+      std::size_t nBranchesOnSurface = 0;
 
       // Count the number of source links on the surface
       auto [slBegin, slEnd] = m_sourcelinkAccessor(*surface);
@@ -695,7 +696,7 @@ class CombinatorialKalmanFilter {
 
         // Retrieve the previous tip and its state
         // The states created on this surface will have the common previous tip
-        size_t prevTip = SIZE_MAX;
+        std::size_t prevTip = SIZE_MAX;
         TipState prevTipState;
         if (!result.activeTips.empty()) {
           prevTip = result.activeTips.back().first;
@@ -763,7 +764,7 @@ class CombinatorialKalmanFilter {
         nBranchesOnSurface = 1;
 
         // Retrieve the previous tip and its state
-        size_t prevTip = SIZE_MAX;
+        std::size_t prevTip = SIZE_MAX;
         TipState tipState;
         if (!result.activeTips.empty()) {
           prevTip = result.activeTips.back().first;
@@ -802,7 +803,7 @@ class CombinatorialKalmanFilter {
 
           // Increment of number of processed states
           tipState.nStates++;
-          size_t currentTip = SIZE_MAX;
+          std::size_t currentTip = SIZE_MAX;
           if (isSensitive) {
             // Increment of number of holes
             tipState.nHoles++;
@@ -868,7 +869,7 @@ class CombinatorialKalmanFilter {
     void createSourceLinkTrackStates(const Acts::GeometryContext& gctx,
                                      result_type& result,
                                      const BoundState& boundState,
-                                     size_t prevTip,
+                                     std::size_t prevTip,
                                      source_link_iterator_t slBegin,
                                      source_link_iterator_t slEnd) const {
       const auto& [boundParams, jacobian, pathLength] = boundState;
@@ -903,7 +904,7 @@ class CombinatorialKalmanFilter {
             "Create temp track state with mask: " << std::bitset<
                 sizeof(std::underlying_type_t<TrackStatePropMask>) * 8>(
                 static_cast<std::underlying_type_t<TrackStatePropMask>>(mask)));
-        size_t tsi = result.stateBuffer->addTrackState(mask, prevTip);
+        std::size_t tsi = result.stateBuffer->addTrackState(mask, prevTip);
         // CAREFUL! This trackstate has a previous index that is not in this
         // MultiTrajectory Visiting brackwards from this track state will
         // fail!
@@ -949,7 +950,7 @@ class CombinatorialKalmanFilter {
         typename std::vector<typename traj_t::TrackStateProxy>::const_iterator
             end,
         result_type& result, bool isOutlier, const TipState& prevTipState,
-        size_t& nBranchesOnSurface) const {
+        std::size_t& nBranchesOnSurface) const {
       using PM = TrackStatePropMask;
 
       std::optional<typename traj_t::TrackStateProxy> firstTrackState{
@@ -1003,7 +1004,7 @@ class CombinatorialKalmanFilter {
         // Inherit the tip state from the previous and will be updated
         // later
         TipState tipState = prevTipState;
-        size_t currentTip = trackState.index();
+        std::size_t currentTip = trackState.index();
 
         // Increment of number of processedState and passed sensitive surfaces
         tipState.nSensitiveSurfaces++;
@@ -1058,10 +1059,10 @@ class CombinatorialKalmanFilter {
     /// @param prevTip The index of the previous state
     ///
     /// @return The tip of added state
-    size_t addNonSourcelinkState(const TrackStatePropMask& stateMask,
-                                 const BoundState& boundState,
-                                 result_type& result, bool isSensitive,
-                                 size_t prevTip) const {
+    std::size_t addNonSourcelinkState(const TrackStatePropMask& stateMask,
+                                      const BoundState& boundState,
+                                      result_type& result, bool isSensitive,
+                                      std::size_t prevTip) const {
       // Add a track state
       auto currentTip = result.fittedStates->addTrackState(stateMask, prevTip);
       ACTS_VERBOSE(
@@ -1188,9 +1189,9 @@ class CombinatorialKalmanFilter {
 
       // Get the indices of the first states (can be either a measurement or
       // material);
-      size_t firstStateIndex = lastMeasurementIndex;
+      std::size_t firstStateIndex = lastMeasurementIndex;
       // Count track states to be smoothed
-      size_t nStates = 0;
+      std::size_t nStates = 0;
       result.fittedStates->applyBackwards(lastMeasurementIndex, [&](auto st) {
         bool isMeasurement =
             st.typeFlags().test(TrackStateFlag::MeasurementFlag);
diff --git a/Core/include/Acts/TrackFinding/MeasurementSelector.hpp b/Core/include/Acts/TrackFinding/MeasurementSelector.hpp
index 4205a2c0982..423f2a6e01b 100644
--- a/Core/include/Acts/TrackFinding/MeasurementSelector.hpp
+++ b/Core/include/Acts/TrackFinding/MeasurementSelector.hpp
@@ -39,7 +39,7 @@ struct MeasurementSelectorCuts {
   /// Maximum local chi2 contribution.
   std::vector<double> chi2CutOff{std::numeric_limits<double>::max()};
   /// Maximum number of associated measurements on a single surface.
-  std::vector<size_t> numMeasurementsCutOff{1};
+  std::vector<std::size_t> numMeasurementsCutOff{1};
 };
 
 /// @brief Measurement selection struct selecting those measurements compatible
@@ -111,7 +111,7 @@ class MeasurementSelector {
     const auto& chi2CutOff = cuts->chi2CutOff;
     auto maxChi2Cut = *std::max_element(chi2CutOff.begin(), chi2CutOff.end());
     double minChi2 = std::numeric_limits<double>::max();
-    size_t minIndex = 0;
+    std::size_t minIndex = 0;
     auto trackStateIterEnd = candidates.end();
     {
       auto trackStateIter = candidates.begin();
@@ -217,7 +217,7 @@ class MeasurementSelector {
     }
     const auto eta = std::atanh(std::cos(trackState.predicted()[eBoundTheta]));
     const auto abseta = std::abs(eta);
-    size_t bin = 0;
+    std::size_t bin = 0;
     for (auto etaBin : etaBins) {
       if (etaBin >= abseta) {
         break;
diff --git a/Core/include/Acts/TrackFinding/RoiDescriptor.hpp b/Core/include/Acts/TrackFinding/RoiDescriptor.hpp
index 33f8c5d2ac5..0d7ac2e9c01 100644
--- a/Core/include/Acts/TrackFinding/RoiDescriptor.hpp
+++ b/Core/include/Acts/TrackFinding/RoiDescriptor.hpp
@@ -107,7 +107,7 @@ class RoiDescriptor {
   void clear() { m_roiDescriptors.clear(); }  // setComposite(false); }
 
   /// reserve elements in vector
-  void reserve(size_t s) { m_roiDescriptors.reserve(s); }
+  void reserve(std::size_t s) { m_roiDescriptors.reserve(s); }
 
   /// add a RoiDescriptor
   void push_back(const RoiDescriptor* roi) {
diff --git a/Core/include/Acts/TrackFinding/SourceLinkAccessorConcept.hpp b/Core/include/Acts/TrackFinding/SourceLinkAccessorConcept.hpp
index 85bef5e151f..72bffeb6f8f 100644
--- a/Core/include/Acts/TrackFinding/SourceLinkAccessorConcept.hpp
+++ b/Core/include/Acts/TrackFinding/SourceLinkAccessorConcept.hpp
@@ -49,7 +49,7 @@ METHOD_TRAIT(at_t, at);
         static_assert(container_pointer_exists, "Pointer to container not found");
 
         constexpr static bool count_exists = has_method<const S,
-          size_t, count_t, const Surface&>;
+          std::size_t, count_t, const Surface&>;
         static_assert(count_exists, "count method not found");
         constexpr static bool range_exists = has_method<const S,
           std::pair<typename S::Iterator, typename S::Iterator>,
diff --git a/Core/include/Acts/TrackFitting/GainMatrixSmoother.hpp b/Core/include/Acts/TrackFitting/GainMatrixSmoother.hpp
index 3119150641a..24052e0631e 100644
--- a/Core/include/Acts/TrackFitting/GainMatrixSmoother.hpp
+++ b/Core/include/Acts/TrackFitting/GainMatrixSmoother.hpp
@@ -37,7 +37,7 @@ class GainMatrixSmoother {
   /// @param[in] logger Where to write logging information to
   template <typename traj_t>
   Result<void> operator()(const GeometryContext& gctx, traj_t& trajectory,
-                          size_t entryIndex,
+                          std::size_t entryIndex,
                           const Logger& logger = getDummyLogger()) const {
     (void)gctx;
 
diff --git a/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp b/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
index c391f8b6b96..f079418493f 100644
--- a/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
+++ b/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
@@ -113,7 +113,8 @@ struct Gx2FitterOptions {
                    bool eLoss = false,
                    const FreeToBoundCorrection& freeToBoundCorrection_ =
                        FreeToBoundCorrection(false),
-                   const size_t nUpdateMax_ = 5, const bool zeroField_ = false)
+                   const std::size_t nUpdateMax_ = 5,
+                   const bool zeroField_ = false)
       : geoContext(gctx),
         magFieldContext(mctx),
         calibrationContext(cctx),
@@ -155,7 +156,7 @@ struct Gx2FitterOptions {
   FreeToBoundCorrection freeToBoundCorrection;
 
   /// Max number of iterations during the fit
-  size_t nUpdateMax = 5;
+  std::size_t nUpdateMax = 5;
 
   /// Disables the QoP fit in case of missing B-field
   bool zeroField = false;
@@ -170,28 +171,28 @@ struct Gx2FitterResult {
   // This corresponds to the last measurement state in the multitrajectory.
   // Since this KF only stores one trajectory, it is unambiguous.
   // SIZE_MAX is the start of a trajectory.
-  size_t lastMeasurementIndex = Acts::MultiTrajectoryTraits::kInvalid;
+  std::size_t lastMeasurementIndex = Acts::MultiTrajectoryTraits::kInvalid;
 
   // This is the index of the 'tip' of the states stored in multitrajectory.
   // This corresponds to the last state in the multitrajectory.
   // Since this KF only stores one trajectory, it is unambiguous.
   // SIZE_MAX is the start of a trajectory.
-  size_t lastTrackIndex = Acts::MultiTrajectoryTraits::kInvalid;
+  std::size_t lastTrackIndex = Acts::MultiTrajectoryTraits::kInvalid;
 
   // The optional Parameters at the provided surface
   std::optional<BoundTrackParameters> fittedParameters;
 
   // Counter for states with non-outlier measurements
-  size_t measurementStates = 0;
+  std::size_t measurementStates = 0;
 
   // Counter for measurements holes
   // A hole correspond to a surface with an associated detector element with no
   // associated measurement. Holes are only taken into account if they are
   // between the first and last measurements.
-  size_t measurementHoles = 0;
+  std::size_t measurementHoles = 0;
 
   // Counter for handled states
-  size_t processedStates = 0;
+  std::size_t processedStates = 0;
 
   // Indicator if track fitting has been done
   bool finished = false;
@@ -213,7 +214,7 @@ struct Gx2FitterResult {
   BoundMatrix jacobianFromStart = BoundMatrix::Identity();
 
   // Count how many surfaces have been hit
-  size_t surfaceCount = 0;
+  std::size_t surfaceCount = 0;
 };
 
 /// Collector for the GX2F Actor
@@ -232,7 +233,7 @@ struct Gx2FitterResult {
 /// @param trackStateProxy is the current track state
 /// @param result is the mutable result/cache object
 /// @param logger a logger instance
-template <size_t measDim, typename traj_t>
+template <std::size_t measDim, typename traj_t>
 void collector(typename traj_t::TrackStateProxy& trackStateProxy,
                Gx2FitterResult<traj_t>& result, const Logger& logger) {
   auto predicted = trackStateProxy.predicted();
@@ -257,7 +258,7 @@ void collector(typename traj_t::TrackStateProxy& trackStateProxy,
                << "\n\tCovariance Measurements:\t" << covarianceMeasurement);
 
   // Collect residuals, covariances, and projected jacobians
-  for (size_t i = 0; i < measDim; i++) {
+  for (std::size_t i = 0; i < measDim; i++) {
     if (covarianceMeasurement(i, i) < 1e-10) {
       ACTS_WARNING("Invalid covariance of measurement: cov(" << i << "," << i
                                                              << ") ~ 0")
@@ -359,7 +360,7 @@ class Gx2Fitter {
     /// The actor needs to know the current iteration for adding new
     /// trackStates. During the first iteration, each measurement surfaces will
     /// be added to the track.
-    size_t nUpdate = Acts::MultiTrajectoryTraits::kInvalid;
+    std::size_t nUpdate = Acts::MultiTrajectoryTraits::kInvalid;
 
     /// @brief Gx2f actor operation
     ///
@@ -432,7 +433,7 @@ class Gx2Fitter {
           // Checks if an existing surface is found during the gx2f-iteration.
           // If not, a new index will be generated afterwards.
           // During the first iteration, we will always create a new index.
-          size_t currentTrackIndex = Acts::MultiTrajectoryTraits::kInvalid;
+          std::size_t currentTrackIndex = Acts::MultiTrajectoryTraits::kInvalid;
           if (nUpdate == 0) {
             ACTS_VERBOSE("   processSurface: nUpdate == 0 decision");
 
@@ -628,7 +629,7 @@ class Gx2Fitter {
     // Create an index of the 'tip' of the track stored in multitrajectory. It
     // is needed outside the update loop. It will be updated with each iteration
     // and used for the final track
-    size_t tipIndex = Acts::MultiTrajectoryTraits::kInvalid;
+    std::size_t tipIndex = Acts::MultiTrajectoryTraits::kInvalid;
 
     ACTS_VERBOSE("params:\n" << params);
 
@@ -637,7 +638,7 @@ class Gx2Fitter {
 
     // Iterate the fit and improve result. Abort after n steps or after
     // convergence
-    for (size_t nUpdate = 0; nUpdate < gx2fOptions.nUpdateMax; nUpdate++) {
+    for (std::size_t nUpdate = 0; nUpdate < gx2fOptions.nUpdateMax; nUpdate++) {
       ACTS_VERBOSE("nUpdate = " << nUpdate + 1 << "/"
                                 << gx2fOptions.nUpdateMax);
 
@@ -685,7 +686,7 @@ class Gx2Fitter {
       bVector = BoundVector::Zero();
 
       // TODO generalize for non-2D measurements
-      for (size_t iMeas = 0; iMeas < gx2fResult.collectorResiduals.size();
+      for (std::size_t iMeas = 0; iMeas < gx2fResult.collectorResiduals.size();
            iMeas++) {
         const auto ri = gx2fResult.collectorResiduals[iMeas];
         const auto covi = gx2fResult.collectorCovariances[iMeas];
@@ -705,13 +706,13 @@ class Gx2Fitter {
       // calculate delta params [a] * delta = b
       deltaParams = BoundVector::Zero();
       if (gx2fOptions.zeroField) {
-        constexpr size_t reducedMatrixSize = 4;
+        constexpr std::size_t reducedMatrixSize = 4;
         deltaParams.topLeftCorner<reducedMatrixSize, 1>() =
             aMatrix.topLeftCorner<reducedMatrixSize, reducedMatrixSize>()
                 .colPivHouseholderQr()
                 .solve(bVector.topLeftCorner<reducedMatrixSize, 1>());
       } else {
-        constexpr size_t reducedMatrixSize = 5;
+        constexpr std::size_t reducedMatrixSize = 5;
         deltaParams.topLeftCorner<reducedMatrixSize, 1>() =
             aMatrix.topLeftCorner<reducedMatrixSize, reducedMatrixSize>()
                 .colPivHouseholderQr()
diff --git a/Core/include/Acts/TrackFitting/KalmanFitter.hpp b/Core/include/Acts/TrackFitting/KalmanFitter.hpp
index 1eda1002dbb..377e290e951 100644
--- a/Core/include/Acts/TrackFitting/KalmanFitter.hpp
+++ b/Core/include/Acts/TrackFitting/KalmanFitter.hpp
@@ -68,7 +68,7 @@ struct KalmanFitterExtensions {
                     const SourceLink&, TrackStateProxy)>;
 
   using Smoother = Delegate<Result<void>(const GeometryContext&, traj_t&,
-                                         size_t, const Logger&)>;
+                                         std::size_t, const Logger&)>;
 
   using Updater = Delegate<Result<void>(const GeometryContext&, TrackStateProxy,
                                         Direction, const Logger&)>;
@@ -201,28 +201,28 @@ struct KalmanFitterResult {
   // This corresponds to the last measurement state in the multitrajectory.
   // Since this KF only stores one trajectory, it is unambiguous.
   // SIZE_MAX is the start of a trajectory.
-  size_t lastMeasurementIndex = SIZE_MAX;
+  std::size_t lastMeasurementIndex = SIZE_MAX;
 
   // This is the index of the 'tip' of the states stored in multitrajectory.
   // This corresponds to the last state in the multitrajectory.
   // Since this KF only stores one trajectory, it is unambiguous.
   // SIZE_MAX is the start of a trajectory.
-  size_t lastTrackIndex = SIZE_MAX;
+  std::size_t lastTrackIndex = SIZE_MAX;
 
   // The optional Parameters at the provided surface
   std::optional<BoundTrackParameters> fittedParameters;
 
   // Counter for states with non-outlier measurements
-  size_t measurementStates = 0;
+  std::size_t measurementStates = 0;
 
   // Counter for measurements holes
   // A hole correspond to a surface with an associated detector element with no
   // associated measurement. Holes are only taken into account if they are
   // between the first and last measurements.
-  size_t measurementHoles = 0;
+  std::size_t measurementHoles = 0;
 
   // Counter for handled states
-  size_t processedStates = 0;
+  std::size_t processedStates = 0;
 
   // Indicator if smoothing has been done.
   bool smoothed = false;
@@ -739,7 +739,7 @@ class KalmanFitter {
         // Add a <mask> TrackState entry multi trajectory. This allocates
         // storage for all components, which we will set later.
         TrackStatePropMask mask = TrackStatePropMask::All;
-        const size_t currentTrackIndex = fittedStates.addTrackState(
+        const std::size_t currentTrackIndex = fittedStates.addTrackState(
             mask, Acts::MultiTrajectoryTraits::kInvalid);
 
         // now get track state proxy back
@@ -927,9 +927,9 @@ class KalmanFitter {
 
       // Get the indices of the first states (can be either a measurement or
       // material);
-      size_t firstStateIndex = result.lastMeasurementIndex;
+      std::size_t firstStateIndex = result.lastMeasurementIndex;
       // Count track states to be smoothed
-      size_t nStates = 0;
+      std::size_t nStates = 0;
       result.fittedStates->applyBackwards(
           result.lastMeasurementIndex, [&](auto st) {
             bool isMeasurement =
diff --git a/Core/include/Acts/TrackFitting/detail/KalmanGlobalCovariance.hpp b/Core/include/Acts/TrackFitting/detail/KalmanGlobalCovariance.hpp
index 289322ac398..47b6dba0fc0 100644
--- a/Core/include/Acts/TrackFitting/detail/KalmanGlobalCovariance.hpp
+++ b/Core/include/Acts/TrackFitting/detail/KalmanGlobalCovariance.hpp
@@ -34,16 +34,16 @@ namespace detail {
 /// @return The global track parameters covariance matrix and the starting
 /// row/column for smoothed states
 template <typename traj_t, typename parameters_t = BoundTrackParameters>
-std::pair<ActsDynamicMatrix, std::unordered_map<size_t, size_t>>
+std::pair<ActsDynamicMatrix, std::unordered_map<std::size_t, std::size_t>>
 globalTrackParametersCovariance(const traj_t& multiTraj,
-                                const size_t& entryIndex) {
+                                const std::size_t& entryIndex) {
   using CovMatrix = typename parameters_t::CovarianceMatrix;
   using GainMatrix = CovMatrix;
 
   // The last smoothed state index
-  size_t lastSmoothedIndex = SIZE_MAX;
+  std::size_t lastSmoothedIndex = SIZE_MAX;
   // The total number of smoothed states
-  size_t nSmoothedStates = 0;
+  std::size_t nSmoothedStates = 0;
   // Visit all the states
   multiTraj.visitBackwards(entryIndex, [&](const auto& ts) {
     if (ts.hasSmoothed()) {
@@ -60,13 +60,13 @@ globalTrackParametersCovariance(const traj_t& multiTraj,
   fullGlobalTrackParamsCov.setZero();
   // The index of state within the trajectory and the starting row/column for
   // this state in the global covariance matrix
-  std::unordered_map<size_t, size_t> stateRowIndices;
+  std::unordered_map<std::size_t, std::size_t> stateRowIndices;
   // Visit the smoothed states to calculate the full global track parameters
   // covariance
-  size_t nProcessed = 0;
+  std::size_t nProcessed = 0;
   auto prev_ts = multiTraj.getTrackState(lastSmoothedIndex);
   multiTraj.visitBackwards(lastSmoothedIndex, [&](const auto& ts) {
-    const size_t iRow =
+    const std::size_t iRow =
         fullGlobalTrackParamsCov.rows() - eBoundSize * (nProcessed + 1);
     // Fill the covariance of this state
     fullGlobalTrackParamsCov.block<eBoundSize, eBoundSize>(iRow, iRow) =
@@ -79,8 +79,8 @@ globalTrackParametersCovariance(const traj_t& multiTraj,
       GainMatrix G = ts.filteredCovariance() * prev_ts.jacobian().transpose() *
                      prev_ts.predictedCovariance().inverse();
       // Loop over the beforehand smoothed states
-      for (size_t iProcessed = 1; iProcessed <= nProcessed; iProcessed++) {
-        const size_t iCol = iRow + eBoundSize * iProcessed;
+      for (std::size_t iProcessed = 1; iProcessed <= nProcessed; iProcessed++) {
+        const std::size_t iCol = iRow + eBoundSize * iProcessed;
         CovMatrix prev_correlation =
             fullGlobalTrackParamsCov.block<eBoundSize, eBoundSize>(
                 iRow + eBoundSize, iCol);
diff --git a/Core/include/Acts/TrackFitting/detail/KalmanUpdateHelpers.hpp b/Core/include/Acts/TrackFitting/detail/KalmanUpdateHelpers.hpp
index 26a8ebabc1b..9445b1db268 100644
--- a/Core/include/Acts/TrackFitting/detail/KalmanUpdateHelpers.hpp
+++ b/Core/include/Acts/TrackFitting/detail/KalmanUpdateHelpers.hpp
@@ -39,13 +39,13 @@ auto kalmanHandleMeasurement(
     const CalibrationContext &calibrationContext, propagator_state_t &state,
     const stepper_t &stepper, const extensions_t &extensions,
     const Surface &surface, const SourceLink &source_link, traj_t &fittedStates,
-    const size_t lastTrackIndex, bool doCovTransport, const Logger &logger,
+    const std::size_t lastTrackIndex, bool doCovTransport, const Logger &logger,
     const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(
         false)) -> Result<typename traj_t::TrackStateProxy> {
   // Add a <mask> TrackState entry multi trajectory. This allocates storage for
   // all components, which we will set later.
   TrackStatePropMask mask = TrackStatePropMask::All;
-  const size_t currentTrackIndex =
+  const std::size_t currentTrackIndex =
       fittedStates.addTrackState(mask, lastTrackIndex);
 
   // now get track state proxy back
@@ -138,7 +138,7 @@ auto kalmanHandleMeasurement(
 template <typename propagator_state_t, typename stepper_t, typename traj_t>
 auto kalmanHandleNoMeasurement(
     propagator_state_t &state, const stepper_t &stepper, const Surface &surface,
-    traj_t &fittedStates, const size_t lastTrackIndex, bool doCovTransport,
+    traj_t &fittedStates, const std::size_t lastTrackIndex, bool doCovTransport,
     const Logger &logger,
     const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(
         false)) -> Result<typename traj_t::TrackStateProxy> {
@@ -146,7 +146,7 @@ auto kalmanHandleNoMeasurement(
   // all components, which we will set later.
   TrackStatePropMask mask =
       ~(TrackStatePropMask::Calibrated | TrackStatePropMask::Filtered);
-  const size_t currentTrackIndex =
+  const std::size_t currentTrackIndex =
       fittedStates.addTrackState(mask, lastTrackIndex);
 
   // now get track state proxy back
diff --git a/Core/include/Acts/TrackFitting/detail/VoidFitterComponents.hpp b/Core/include/Acts/TrackFitting/detail/VoidFitterComponents.hpp
index 59d2f9025d5..1aab73ac81b 100644
--- a/Core/include/Acts/TrackFitting/detail/VoidFitterComponents.hpp
+++ b/Core/include/Acts/TrackFitting/detail/VoidFitterComponents.hpp
@@ -39,7 +39,7 @@ Result<void> voidFitterUpdater(const GeometryContext& /*gctx*/,
 
 template <typename traj_t>
 Result<void> voidFitterSmoother(const GeometryContext& /*gctx*/,
-                                traj_t& trackStates, size_t entry,
+                                traj_t& trackStates, std::size_t entry,
                                 const Logger& /*logger*/) {
   trackStates.applyBackwards(entry, [](auto trackState) {
     trackState.smoothed() = trackState.filtered();
diff --git a/Core/include/Acts/Utilities/AlgebraHelpers.hpp b/Core/include/Acts/Utilities/AlgebraHelpers.hpp
index ecfc8541023..ea5767f865b 100644
--- a/Core/include/Acts/Utilities/AlgebraHelpers.hpp
+++ b/Core/include/Acts/Utilities/AlgebraHelpers.hpp
@@ -36,7 +36,7 @@ MatrixType bitsetToMatrix(const std::bitset<MatrixType::RowsAtCompileTime *
 
   MatrixType m;
   auto* p = m.data();
-  for (size_t i = 0; i < rows * cols; i++) {
+  for (std::size_t i = 0; i < rows * cols; i++) {
     p[i] = bs[rows * cols - 1 - i];
   }
   return m;
@@ -51,13 +51,13 @@ MatrixType bitsetToMatrix(const std::bitset<MatrixType::RowsAtCompileTime *
 template <typename Derived>
 auto matrixToBitset(const Eigen::PlainObjectBase<Derived>& m) {
   using MatrixType = Eigen::PlainObjectBase<Derived>;
-  constexpr size_t rows = MatrixType::RowsAtCompileTime;
-  constexpr size_t cols = MatrixType::ColsAtCompileTime;
+  constexpr std::size_t rows = MatrixType::RowsAtCompileTime;
+  constexpr std::size_t cols = MatrixType::ColsAtCompileTime;
 
   std::bitset<rows * cols> res;
 
   auto* p = m.data();
-  for (size_t i = 0; i < rows * cols; i++) {
+  for (std::size_t i = 0; i < rows * cols; i++) {
     res[rows * cols - 1 - i] = static_cast<bool>(p[i]);
   }
 
diff --git a/Core/include/Acts/Utilities/Any.hpp b/Core/include/Acts/Utilities/Any.hpp
index ac503f86238..f4744adb440 100644
--- a/Core/include/Acts/Utilities/Any.hpp
+++ b/Core/include/Acts/Utilities/Any.hpp
@@ -106,7 +106,7 @@ static _AnyAllocationReporter s_reporter;
 class AnyBaseAll {};
 
 /// Small opaque cache type which uses small buffer optimization
-template <size_t SIZE>
+template <std::size_t SIZE>
 class AnyBase : public AnyBaseAll {
   static_assert(sizeof(void*) <= SIZE, "Size is too small for a pointer");
 
@@ -487,18 +487,19 @@ class AnyBase : public AnyBaseAll {
     (*_to) = *_from;
   }
 
-  static constexpr size_t kMaxAlignment = std::max(alignof(std::max_align_t),
+  static constexpr std::size_t kMaxAlignment =
+      std::max(alignof(std::max_align_t),
 #if defined(__AVX512F__)
-                                                   size_t(64)
+               std::size_t(64)
 #elif defined(__AVX__)
-                                                   size_t(32)
+               std::size_t(32)
 #elif defined(__SSE__)
-                                                   size_t(16)
+               std::size_t(16)
 #else
-                                                   size_t(0)  // Neutral element
-                                                              // for maximum
+               std::size_t(0)  // Neutral element
+                               // for maximum
 #endif
-  );
+      );
 
   alignas(kMaxAlignment) std::array<std::byte, SIZE> m_data{};
   const Handler* m_handler{nullptr};
diff --git a/Core/include/Acts/Utilities/BinUtility.hpp b/Core/include/Acts/Utilities/BinUtility.hpp
index 145e9552f13..9b8491059aa 100644
--- a/Core/include/Acts/Utilities/BinUtility.hpp
+++ b/Core/include/Acts/Utilities/BinUtility.hpp
@@ -70,7 +70,7 @@ class BinUtility {
   /// @param opt is the binning option : open, closed
   /// @param value is the binninb value : binX, binY, binZ, etc.
   /// @param tForm is the (optional) transform
-  BinUtility(size_t bins, float min, float max, BinningOption opt = open,
+  BinUtility(std::size_t bins, float min, float max, BinningOption opt = open,
              BinningValue value = binX,
              const Transform3& tForm = Transform3::Identity())
       : m_binningData(), m_transform(tForm), m_itransform(tForm.inverse()) {
@@ -141,7 +141,7 @@ class BinUtility {
   const std::vector<BinningData>& binningData() const { return m_binningData; }
 
   /// Return the total number of bins
-  size_t bins() const { return bins(0) * bins(1) * bins(2); }
+  std::size_t bins() const { return bins(0) * bins(1) * bins(2); }
 
   /// Bin-triple fast access
   ///
@@ -150,15 +150,15 @@ class BinUtility {
   /// @param position is the 3D position to be evaluated
   ///
   /// @return is the bin value in 3D
-  std::array<size_t, 3> binTriple(const Vector3& position) const {
+  std::array<std::size_t, 3> binTriple(const Vector3& position) const {
     /// transform or not
     const Vector3 bPosition = m_itransform * position;
     // get the dimension
-    size_t mdim = m_binningData.size();
+    std::size_t mdim = m_binningData.size();
     /// now get the bins
-    size_t bin0 = m_binningData[0].searchGlobal(bPosition);
-    size_t bin1 = mdim > 1 ? m_binningData[1].searchGlobal(bPosition) : 0;
-    size_t bin2 = mdim > 2 ? m_binningData[2].searchGlobal(bPosition) : 0;
+    std::size_t bin0 = m_binningData[0].searchGlobal(bPosition);
+    std::size_t bin1 = mdim > 1 ? m_binningData[1].searchGlobal(bPosition) : 0;
+    std::size_t bin2 = mdim > 2 ? m_binningData[2].searchGlobal(bPosition) : 0;
     /// return the triple
     return {{bin0, bin1, bin2}};
   }
@@ -169,11 +169,11 @@ class BinUtility {
   /// @param ba is the bin dimension
   ///
   /// @return is the bin value
-  size_t bin(const Vector3& position, size_t ba = 0) const {
+  std::size_t bin(const Vector3& position, std::size_t ba = 0) const {
     if (ba >= m_binningData.size()) {
       return 0;
     }
-    size_t bEval = m_binningData[ba].searchGlobal(m_itransform * position);
+    std::size_t bEval = m_binningData[ba].searchGlobal(m_itransform * position);
     return bEval;
   }
 
@@ -187,7 +187,7 @@ class BinUtility {
   ///
   /// @return the next bin
   int nextDirection(const Vector3& position, const Vector3& direction,
-                    size_t ba = 0) const {
+                    std::size_t ba = 0) const {
     if (ba >= m_binningData.size()) {
       return 0;
     }
@@ -205,7 +205,7 @@ class BinUtility {
   /// @param ba is the bin dimension
   ///
   /// @return bin calculated from local
-  size_t bin(const Vector2& lposition, size_t ba = 0) const {
+  std::size_t bin(const Vector2& lposition, std::size_t ba = 0) const {
     if (ba >= m_binningData.size()) {
       return 0;
     }
@@ -245,14 +245,14 @@ class BinUtility {
 
   /// First bin maximal value
   /// @return the dimension of the binning data
-  size_t dimensions() const { return m_binningData.size(); }
+  std::size_t dimensions() const { return m_binningData.size(); }
 
   /// First bin maximal value
   ///
   /// @param ba is the binaccessor
   ///
-  /// @return size_t is the maximal bin of the accessor entry
-  size_t max(size_t ba = 0) const {
+  /// @return std::size_t is the maximal bin of the accessor entry
+  std::size_t max(std::size_t ba = 0) const {
     if (ba >= m_binningData.size()) {
       return 0;
     }
@@ -263,8 +263,8 @@ class BinUtility {
   ///
   /// @param ba is the binaccessor
   ///
-  /// @return size_t is the bins of the accessor entry
-  size_t bins(size_t ba) const {
+  /// @return std::size_t is the bins of the accessor entry
+  std::size_t bins(std::size_t ba) const {
     if (ba >= m_binningData.size()) {
       return 1;
     }
@@ -281,7 +281,7 @@ class BinUtility {
   /// @param ba is the binaccessor
   ///
   /// @return the binning value of the accessor entry
-  BinningValue binningValue(size_t ba = 0) const {
+  BinningValue binningValue(std::size_t ba = 0) const {
     if (ba >= m_binningData.size()) {
       throw "dimension out of bounds";
     }
@@ -289,11 +289,11 @@ class BinUtility {
   }
 
   /// Serialize the bin triple
-  /// - this creates a simple size_t from a triple object
+  /// - this creates a simple std::size_t from a triple object
   ///
   /// @param bin is the bin to be serialized
-  size_t serialize(const std::array<size_t, 3>& bin) const {
-    size_t serializedBin = bin[0];
+  std::size_t serialize(const std::array<std::size_t, 3>& bin) const {
+    std::size_t serializedBin = bin[0];
     if (m_binningData.size() == 2) {
       serializedBin += bin[1] * m_binningData[0].bins();
     } else if (m_binningData.size() == 3) {
diff --git a/Core/include/Acts/Utilities/BinnedArray.hpp b/Core/include/Acts/Utilities/BinnedArray.hpp
index efcbcf06bff..c735b53e4ab 100644
--- a/Core/include/Acts/Utilities/BinnedArray.hpp
+++ b/Core/include/Acts/Utilities/BinnedArray.hpp
@@ -41,7 +41,7 @@ class BinnedArray {
   ///
   /// @return the object according to the estimated bin
   virtual T object(const Vector2& lposition,
-                   std::array<size_t, 3>& bins) const = 0;
+                   std::array<std::size_t, 3>& bins) const = 0;
 
   /// Same method without bins for backward compatibility
   ///
@@ -49,7 +49,7 @@ class BinnedArray {
   ///
   /// @return the object according to the estimated bin
   virtual T object(const Vector2& lposition) const {
-    std::array<size_t, 3> bins{};
+    std::array<std::size_t, 3> bins{};
     return object(lposition, bins);
   }
 
@@ -60,7 +60,7 @@ class BinnedArray {
   ///
   /// @return the object according to the estimated bin
   virtual T object(const Vector3& position,
-                   std::array<size_t, 3>& bin) const = 0;
+                   std::array<std::size_t, 3>& bin) const = 0;
 
   /// Same method without bins for backward compatibility
   ///
@@ -68,7 +68,7 @@ class BinnedArray {
   ///
   /// @return the object according to the estimated bin
   virtual T object(const Vector3& position) const {
-    std::array<size_t, 3> bins{};
+    std::array<std::size_t, 3> bins{};
     return object(position, bins);
   }
 
diff --git a/Core/include/Acts/Utilities/BinnedArrayXD.hpp b/Core/include/Acts/Utilities/BinnedArrayXD.hpp
index 0f49f4b1d20..7bd2777da93 100644
--- a/Core/include/Acts/Utilities/BinnedArrayXD.hpp
+++ b/Core/include/Acts/Utilities/BinnedArrayXD.hpp
@@ -93,7 +93,7 @@ class BinnedArrayXD : public BinnedArray<T> {
         m_arrayObjects(),
         m_binUtility(std::move(bu)) {
     // get the total dimension
-    size_t objects =
+    std::size_t objects =
         m_binUtility->bins(0) * m_binUtility->bins(1) * m_binUtility->bins(2);
     /// reserve the right amount of data
     m_arrayObjects.reserve(objects);
@@ -131,9 +131,10 @@ class BinnedArrayXD : public BinnedArray<T> {
   /// @param bins is the bin triple filled during this access
   ///
   /// @return is the object in that bin
-  T object(const Vector2& lposition, std::array<size_t, 3>& bins) const final {
+  T object(const Vector2& lposition,
+           std::array<std::size_t, 3>& bins) const final {
     if (m_binUtility) {
-      size_t bdim = m_binUtility->dimensions();
+      std::size_t bdim = m_binUtility->dimensions();
       bins[2] = bdim > 2 ? m_binUtility->bin(lposition, 2) : 0;
       bins[1] = bdim > 1 ? m_binUtility->bin(lposition, 1) : 0;
       bins[0] = m_binUtility->bin(lposition, 0);
@@ -144,7 +145,7 @@ class BinnedArrayXD : public BinnedArray<T> {
 
   // satisfy overload / override
   T object(const Vector2& lposition) const override {
-    std::array<size_t, 3> bins{};
+    std::array<std::size_t, 3> bins{};
     return object(lposition, bins);
   }
 
@@ -154,9 +155,10 @@ class BinnedArrayXD : public BinnedArray<T> {
   /// @param bins is the bins triple filled during access
   ///
   /// @return is the object in that bin
-  T object(const Vector3& position, std::array<size_t, 3>& bins) const final {
+  T object(const Vector3& position,
+           std::array<std::size_t, 3>& bins) const final {
     if (m_binUtility) {
-      size_t bdim = m_binUtility->dimensions();
+      std::size_t bdim = m_binUtility->dimensions();
       bins[2] = bdim > 2 ? m_binUtility->bin(position, 2) : 0;
       bins[1] = bdim > 1 ? m_binUtility->bin(position, 1) : 0;
       bins[0] = m_binUtility->bin(position, 0);
@@ -167,7 +169,7 @@ class BinnedArrayXD : public BinnedArray<T> {
 
   // satisfy overload / override
   T object(const Vector3& position) const override {
-    std::array<size_t, 3> bins{};
+    std::array<std::size_t, 3> bins{};
     return object(position, bins);
   }
 
diff --git a/Core/include/Acts/Utilities/BinningData.hpp b/Core/include/Acts/Utilities/BinningData.hpp
index 914a4e7769f..94f17215c5c 100644
--- a/Core/include/Acts/Utilities/BinningData.hpp
+++ b/Core/include/Acts/Utilities/BinningData.hpp
@@ -84,7 +84,7 @@ class BinningData {
   /// @param bMax is the maximum value
   /// @param sBinData is (optional) sub structure
   /// @param sBinAdditive is the prescription for the sub structure
-  BinningData(BinningOption bOption, BinningValue bValue, size_t bBins,
+  BinningData(BinningOption bOption, BinningValue bValue, std::size_t bBins,
               float bMin, float bMax,
               std::unique_ptr<const BinningData> sBinData = nullptr,
               bool sBinAdditive = false)
@@ -105,7 +105,7 @@ class BinningData {
     m_functionPtr = &searchEquidistantWithBoundary;
     // fill the boundary vector for fast access to center & boundaries
     m_boundaries.reserve(m_bins + 1);
-    for (size_t ib = 0; ib < m_bins + 1; ++ib) {
+    for (std::size_t ib = 0; ib < m_bins + 1; ++ib) {
       m_boundaries.push_back(min + ib * step);
     }
     // the binning data has sub structure - multiplicative or additive
@@ -222,7 +222,7 @@ class BinningData {
   }
 
   /// Return the number of bins - including sub bins
-  size_t bins() const { return m_totalBins; }
+  std::size_t bins() const { return m_totalBins; }
 
   /// Return the boundaries  - including sub boundaries
   /// @return vector of floats indicating the boundary values
@@ -281,7 +281,7 @@ class BinningData {
   /// @param bin is the bin for which the center value is requested
   ///
   /// @return float value according to the bin center
-  float center(size_t bin) const {
+  float center(std::size_t bin) const {
     const std::vector<float>& bvals = boundaries();
     // take the center between bin boundaries
     float value =
@@ -294,7 +294,7 @@ class BinningData {
   /// @param bin is the bin for which the width is requested
   ///
   /// @return float value of width
-  float width(size_t bin) const {
+  float width(std::size_t bin) const {
     const std::vector<float>& bvals = boundaries();
     // take the center between bin boundaries
     float value = bin < (bvals.size() - 1) ? bvals[bin + 1] - bvals[bin] : 0.;
@@ -338,7 +338,7 @@ class BinningData {
   /// @param lposition is the search position in local coordinated
   ///
   /// @return bin according tot this
-  size_t searchLocal(const Vector2& lposition) const {
+  std::size_t searchLocal(const Vector2& lposition) const {
     if (zdim) {
       return 0;
     }
@@ -350,7 +350,7 @@ class BinningData {
   /// @param position is the search position in global coordinated
   ///
   /// @return bin according tot this
-  size_t searchGlobal(const Vector3& position) const {
+  std::size_t searchGlobal(const Vector3& position) const {
     if (zdim) {
       return 0;
     }
@@ -362,7 +362,7 @@ class BinningData {
   /// @param value is the searchvalue as float
   ///
   /// @return bin according tot this
-  size_t search(float value) const {
+  std::size_t search(float value) const {
     if (zdim) {
       return 0;
     }
@@ -377,9 +377,9 @@ class BinningData {
   /// @param value is the searchvalue as float
   ///
   /// @return bin according tot this
-  size_t searchWithSubStructure(float value) const {
+  std::size_t searchWithSubStructure(float value) const {
     // find the masterbin with the correct function pointer
-    size_t masterbin = (*m_functionPtr)(value, *this);
+    std::size_t masterbin = (*m_functionPtr)(value, *this);
     // additive sub binning -
     if (subBinningAdditive) {
       // no gauging done, for additive sub structure
@@ -389,7 +389,7 @@ class BinningData {
     float gvalue =
         value - masterbin * (subBinningData->max - subBinningData->min);
     // now go / additive or multiplicative
-    size_t subbin = subBinningData->search(gvalue);
+    std::size_t subbin = subBinningData->search(gvalue);
     // now return
     return masterbin * subBinningData->bins() + subbin;
   }
@@ -418,7 +418,7 @@ class BinningData {
   /// it is set to max
   ///
   /// @return the center value of the bin is given
-  float centerValue(size_t bin) const {
+  float centerValue(std::size_t bin) const {
     if (zdim) {
       return 0.5 * (min + max);
     }
@@ -428,12 +428,13 @@ class BinningData {
   }
 
  private:
-  size_t m_bins{};                  ///< number of bins
+  std::size_t m_bins{};             ///< number of bins
   std::vector<float> m_boundaries;  ///< vector of holding the bin boundaries
-  size_t m_totalBins{};             ///< including potential substructure
+  std::size_t m_totalBins{};        ///< including potential substructure
   std::vector<float> m_totalBoundaries;  ///< including potential substructure
 
-  size_t (*m_functionPtr)(float, const BinningData&){};  /// function pointer
+  std::size_t (*m_functionPtr)(float,
+                               const BinningData&){};  /// function pointer
 
   /// helper method to set the sub structure
   void checkSubStructure() {
@@ -473,9 +474,9 @@ class BinningData {
             subBinningData->boundaries();
         // create the boundary vector
         m_totalBoundaries.push_back(min);
-        for (size_t ib = 0; ib < m_bins; ++ib) {
+        for (std::size_t ib = 0; ib < m_bins; ++ib) {
           float offset = ib * step;
-          for (size_t isb = 1; isb < subBinBoundaries.size(); ++isb) {
+          for (std::size_t isb = 1; isb < subBinBoundaries.size(); ++isb) {
             m_totalBoundaries.push_back(offset + subBinBoundaries[isb]);
           }
         }
@@ -487,8 +488,8 @@ class BinningData {
 
   // Equidistant search
   // - fastest method
-  static size_t searchEquidistantWithBoundary(float value,
-                                              const BinningData& bData) {
+  static std::size_t searchEquidistantWithBoundary(float value,
+                                                   const BinningData& bData) {
     // vanilla
 
     int bin = static_cast<int>((value - bData.min) / bData.step);
@@ -503,14 +504,14 @@ class BinningData {
     }
     // if outside boundary : return boundary for open, opposite bin for closed
     bin = bin < 0 ? ((bData.option == open) ? 0 : (bData.m_bins - 1)) : bin;
-    return size_t((bin <= int(bData.m_bins - 1))
-                      ? bin
-                      : ((bData.option == open) ? (bData.m_bins - 1) : 0));
+    return std::size_t((bin <= int(bData.m_bins - 1))
+                           ? bin
+                           : ((bData.option == open) ? (bData.m_bins - 1) : 0));
   }
 
   // Search in arbitrary boundary
-  static size_t searchInVectorWithBoundary(float value,
-                                           const BinningData& bData) {
+  static std::size_t searchInVectorWithBoundary(float value,
+                                                const BinningData& bData) {
     // lower boundary
     if (value <= bData.m_boundaries[0]) {
       return (bData.option == closed) ? (bData.m_bins - 1) : 0;
@@ -522,8 +523,8 @@ class BinningData {
 
     auto lb = std::lower_bound(bData.m_boundaries.begin(),
                                bData.m_boundaries.end(), value);
-    return static_cast<size_t>(std::distance(bData.m_boundaries.begin(), lb) -
-                               1);
+    return static_cast<std::size_t>(
+        std::distance(bData.m_boundaries.begin(), lb) - 1);
   }
 
  public:
@@ -533,9 +534,9 @@ class BinningData {
   std::string toString(const std::string& indent) const {
     std::stringstream sl;
     sl << indent << "BinngingData object:" << '\n';
-    sl << indent << "  - type       : " << size_t(type) << '\n';
-    sl << indent << "  - option     : " << size_t(option) << '\n';
-    sl << indent << "  - value      : " << size_t(binvalue) << '\n';
+    sl << indent << "  - type       : " << std::size_t(type) << '\n';
+    sl << indent << "  - option     : " << std::size_t(option) << '\n';
+    sl << indent << "  - value      : " << std::size_t(binvalue) << '\n';
     sl << indent << "  - bins       : " << bins() << '\n';
     sl << indent << "  - min/max    : " << min << " / " << max << '\n';
     if (type == equidistant) {
diff --git a/Core/include/Acts/Utilities/BoundingBox.hpp b/Core/include/Acts/Utilities/BoundingBox.hpp
index 204fdd49454..6b2527917d5 100644
--- a/Core/include/Acts/Utilities/BoundingBox.hpp
+++ b/Core/include/Acts/Utilities/BoundingBox.hpp
@@ -24,7 +24,7 @@ namespace Acts {
  * Implementation of an Axis Aligned Bounding Box. This type is compatible
  * with 2D and 3D boxes
  */
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 class AxisAlignedBoundingBox {
  private:
   /**
@@ -88,7 +88,7 @@ class AxisAlignedBoundingBox {
   /**
    * Re-export dimension from template parameter
    */
-  static const size_t dim = DIM;
+  static const std::size_t dim = DIM;
 
   /**
    * Copy constructor from other bounding box.
@@ -199,7 +199,7 @@ class AxisAlignedBoundingBox {
    * @param fr The frustum
    * @return Whether the frustum intersects this AABB
    */
-  template <size_t sides>
+  template <std::size_t sides>
   bool intersect(const Frustum<value_type, DIM, sides>& fr) const;
 
   /**
@@ -290,7 +290,7 @@ class AxisAlignedBoundingBox {
    * @param color The color to use for drawing
    * @param trf An optional transform to apply first.
    */
-  template <size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
+  template <std::size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
   void draw(IVisualization3D& helper,
             std::array<int, 3> color = {120, 120, 120},
             const transform_type& trf = transform_type::Identity()) const;
@@ -307,17 +307,17 @@ class AxisAlignedBoundingBox {
    * @param fillcolor Color to fill the box with.
    * @return The outstream given in @p os.
    */
-  template <size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
+  template <std::size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
   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;
 
  private:
-  template <size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
+  template <std::size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
   std::pair<VertexType, VertexType> transformVertices(
       const transform_type& trf) const;
 
-  template <size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
+  template <std::size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
   std::pair<VertexType, VertexType> transformVertices(
       const transform_type& trf) const;
 
@@ -347,7 +347,7 @@ class AxisAlignedBoundingBox {
  */
 template <typename box_t>
 box_t* make_octree(std::vector<std::unique_ptr<box_t>>& store,
-                   const std::vector<box_t*>& prims, size_t max_depth = 1,
+                   const std::vector<box_t*>& prims, std::size_t max_depth = 1,
                    typename box_t::value_type envelope1 = 0);
 
 /**
@@ -359,7 +359,7 @@ box_t* make_octree(std::vector<std::unique_ptr<box_t>>& store,
  * @param box The bounding box
  * @return The given output stream.
  */
-template <typename T, typename U, size_t V>
+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 47496f36792..59cacc1fb65 100644
--- a/Core/include/Acts/Utilities/BoundingBox.ipp
+++ b/Core/include/Acts/Utilities/BoundingBox.ipp
@@ -6,7 +6,7 @@
 // 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/.
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::AxisAlignedBoundingBox(
     const entity_t* entity, const VertexType& vmin, const VertexType& vmax)
     : m_entity(entity),
@@ -16,7 +16,7 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::AxisAlignedBoundingBox(
       m_width(vmax - vmin),
       m_iwidth(1 / m_width) {}
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::AxisAlignedBoundingBox(
     const entity_t* entity, const VertexType& center, const Size& size)
     : m_entity(entity),
@@ -26,13 +26,13 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::AxisAlignedBoundingBox(
       m_width(size.get()),
       m_iwidth(1 / m_width) {}
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::AxisAlignedBoundingBox(
     const std::vector<self_t*>& boxes, vertex_array_type envelope)
     : m_entity(nullptr) {
   assert(boxes.size() > 1);
 
-  for (size_t i = 0; i < boxes.size(); i++) {
+  for (std::size_t i = 0; i < boxes.size(); i++) {
     if (i < boxes.size() - 1) {
       // set next on i to i+1
       boxes[i]->setSkip(boxes[i + 1]);
@@ -54,7 +54,7 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::AxisAlignedBoundingBox(
   m_iwidth = 1 / m_width;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 std::pair<
     typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType,
     typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType>
@@ -68,7 +68,7 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::wrap(
   vertex_array_type vmin(
       vertex_array_type::Constant(std::numeric_limits<value_type>::max()));
 
-  for (size_t i = 0; i < boxes.size(); i++) {
+  for (std::size_t i = 0; i < boxes.size(); i++) {
     vmin = vmin.min(boxes[i]->min().array());
     vmax = vmax.max(boxes[i]->max().array());
   }
@@ -79,7 +79,7 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::wrap(
   return {vmin, vmax};
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 std::pair<
     typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType,
     typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType>
@@ -93,7 +93,7 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::wrap(
   return wrap(box_ptrs, envelope);
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 std::pair<
     typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType,
     typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType>
@@ -107,14 +107,14 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::wrap(
   return wrap(box_ptrs, envelope);
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 bool Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::intersect(
     const VertexType& point) const {
   vertex_array_type t = (point - m_vmin).array() * m_iwidth;
   return t.minCoeff() >= 0 && t.maxCoeff() < 1;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 bool Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::intersect(
     const Ray<value_type, DIM>& ray) const {
   const VertexType& origin = ray.origin();
@@ -143,8 +143,8 @@ bool Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::intersect(
   return tmin < tmax && tmax > 0.0;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
-template <size_t sides>
+template <typename entity_t, typename value_t, std::size_t DIM>
+template <std::size_t sides>
 bool Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::intersect(
     const Frustum<value_type, DIM, sides>& fr) const {
   const auto& normals = fr.normals();
@@ -160,7 +160,7 @@ bool Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::intersect(
   // for loop, we could eliminate this, probably,
   // but sides+1 is known at compile time, so the compiler
   // will most likely unroll the loop
-  for (size_t i = 0; i < sides + 1; i++) {
+  for (std::size_t i = 0; i < sides + 1; i++) {
     const VertexType& normal = normals[i];
 
     // for AABBs, take the component from the min vertex, if the normal
@@ -182,7 +182,7 @@ bool Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::intersect(
   return true;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 void Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::setSkip(
     self_t* skip) {
   // set next on this
@@ -193,59 +193,59 @@ void Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::setSkip(
   }
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 const Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>*
 Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::getLeftChild() const {
   return m_left_child;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 const Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>*
 Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::getSkip() const {
   return m_skip;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 bool Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::hasEntity() const {
   return m_entity != nullptr;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 const entity_t* Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::entity()
     const {
   return m_entity;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 void Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::setEntity(
     const entity_t* entity) {
   m_entity = entity;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 const typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType&
 Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::center() const {
   return m_center;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 const typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType&
 Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::min() const {
   return m_vmin;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 const typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType&
 Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::max() const {
   return m_vmax;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 std::ostream& Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::toStream(
     std::ostream& os) const {
   os << "AABB(ctr=(";
 
-  for (size_t i = 0; i < DIM; i++) {
+  for (std::size_t i = 0; i < DIM; i++) {
     if (i > 0) {
       os << ", ";
     }
@@ -253,7 +253,7 @@ std::ostream& Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::toStream(
   }
 
   os << ") vmin=(";
-  for (size_t i = 0; i < DIM; i++) {
+  for (std::size_t i = 0; i < DIM; i++) {
     if (i > 0) {
       os << ", ";
     }
@@ -262,7 +262,7 @@ std::ostream& Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::toStream(
 
   os << ") vmax=(";
 
-  for (size_t i = 0; i < DIM; i++) {
+  for (std::size_t i = 0; i < DIM; i++) {
     if (i > 0) {
       os << ", ";
     }
@@ -274,8 +274,8 @@ std::ostream& Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::toStream(
   return os;
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
-template <size_t D, std::enable_if_t<D == 3, int>>
+template <typename entity_t, typename value_t, std::size_t DIM>
+template <std::size_t D, std::enable_if_t<D == 3, int>>
 std::pair<
     typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType,
     typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType>
@@ -298,7 +298,7 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::transformVertices(
   VertexType vmin = trf * vertices[0];
   VertexType vmax = trf * vertices[0];
 
-  for (size_t i = 1; i < 8; i++) {
+  for (std::size_t i = 1; i < 8; i++) {
     const VertexType vtx = trf * vertices[i];
     vmin = vmin.cwiseMin(vtx);
     vmax = vmax.cwiseMax(vtx);
@@ -307,8 +307,8 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::transformVertices(
   return {vmin, vmax};
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
-template <size_t D, std::enable_if_t<D == 2, int>>
+template <typename entity_t, typename value_t, std::size_t DIM>
+template <std::size_t D, std::enable_if_t<D == 2, int>>
 std::pair<
     typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType,
     typename Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::VertexType>
@@ -325,7 +325,7 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::transformVertices(
   VertexType vmin = trf * vertices[0];
   VertexType vmax = trf * vertices[0];
 
-  for (size_t i = 1; i < 4; i++) {
+  for (std::size_t i = 1; i < 4; i++) {
     const VertexType vtx = trf * vertices[i];
     vmin = vmin.cwiseMin(vtx);
     vmax = vmax.cwiseMax(vtx);
@@ -334,13 +334,13 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::transformVertices(
   return {vmin, vmax};
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 void Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::transform(
     const transform_type& trf) {
   std::tie(m_vmin, m_vmax) = transformVertices(trf);
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
+template <typename entity_t, typename value_t, std::size_t DIM>
 Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>
 Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::transformed(
     const transform_type& trf) const {
@@ -349,8 +349,8 @@ Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::transformed(
   return self_t(m_entity, vmin, vmax);
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
-template <size_t D, std::enable_if_t<D == 3, int>>
+template <typename entity_t, typename value_t, std::size_t DIM>
+template <std::size_t D, std::enable_if_t<D == 3, int>>
 void Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::draw(
     IVisualization3D& helper, std::array<int, 3> color,
     const transform_type& trf) const {
@@ -384,8 +384,8 @@ void Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::draw(
         {vmax.x(), vmax.y(), vmax.z()}, {vmin.x(), vmax.y(), vmax.z()});
 }
 
-template <typename entity_t, typename value_t, size_t DIM>
-template <size_t D, std::enable_if_t<D == 2, int>>
+template <typename entity_t, typename value_t, std::size_t DIM>
+template <std::size_t D, std::enable_if_t<D == 2, int>>
 std::ostream& Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::svg(
     std::ostream& os, value_type w, value_type h, value_type unit,
     const std::string& label, const std::string& fillcolor) const {
@@ -401,7 +401,7 @@ std::ostream& Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::svg(
   trf.scale(unit);
 
   auto draw_point = [&](const VertexType& p_, const std::string& color,
-                        size_t r) {
+                        std::size_t r) {
     VertexType p = trf * p_;
     os << "<circle ";
     os << "cx=\"" << p.x() << "\" cy=\"" << p.y() << "\" r=\"" << r << "\"";
@@ -422,7 +422,7 @@ std::ostream& Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::svg(
   };
 
   auto draw_text = [&](const VertexType& center_, const std::string& text,
-                       const std::string& color, size_t size) {
+                       const std::string& color, std::size_t size) {
     VertexType center = trf * center_;
     os << "<text dominant-baseline=\"middle\" text-anchor=\"middle\" ";
     os << "fill=\"" << color << "\" font-size=\"" << size << "\" ";
@@ -440,9 +440,9 @@ std::ostream& Acts::AxisAlignedBoundingBox<entity_t, value_t, DIM>::svg(
 
 template <typename box_t>
 box_t* octree_inner(std::vector<std::unique_ptr<box_t>>& store,
-                    size_t max_depth,
+                    std::size_t max_depth,
                     typename box_t::vertex_array_type envelope,
-                    const std::vector<box_t*>& lprims, size_t depth) {
+                    const std::vector<box_t*>& lprims, std::size_t depth) {
   using VertexType = typename box_t::VertexType;
 
   assert(lprims.size() > 0);
@@ -533,7 +533,8 @@ box_t* octree_inner(std::vector<std::unique_ptr<box_t>>& store,
 
 template <typename box_t>
 box_t* Acts::make_octree(std::vector<std::unique_ptr<box_t>>& store,
-                         const std::vector<box_t*>& prims, size_t max_depth,
+                         const std::vector<box_t*>& prims,
+                         std::size_t max_depth,
                          typename box_t::value_type envelope1) {
   static_assert(box_t::dim == 3, "Octree can only be created in 3D");
 
@@ -545,7 +546,7 @@ box_t* Acts::make_octree(std::vector<std::unique_ptr<box_t>>& store,
   return top;
 }
 
-template <typename T, typename U, size_t V>
+template <typename T, typename U, std::size_t V>
 std::ostream& Acts::operator<<(
     std::ostream& os, const Acts::AxisAlignedBoundingBox<T, U, V>& box) {
   return box.toStream(os);
diff --git a/Core/include/Acts/Utilities/Frustum.hpp b/Core/include/Acts/Utilities/Frustum.hpp
index b47d4b3a5d1..007e3fc8b25 100644
--- a/Core/include/Acts/Utilities/Frustum.hpp
+++ b/Core/include/Acts/Utilities/Frustum.hpp
@@ -24,11 +24,11 @@ namespace Acts {
 /// @tparam DIM The number of dimensions of ambient space
 /// @tparam SIDES The number of sides (= side planes) the frustum has (exactly 2
 /// in 2D, minimum 3 in 3D)
-template <typename value_t, size_t DIM, size_t SIDES>
+template <typename value_t, std::size_t DIM, std::size_t SIDES>
 class Frustum {
   using translation_t = Eigen::Translation<value_t, DIM>;
 
-  static constexpr size_t n_normals = SIDES + 1;
+  static constexpr std::size_t n_normals = SIDES + 1;
 
  public:
   /// Re expose the value type
@@ -41,9 +41,9 @@ class Frustum {
   using transform_type = Eigen::Transform<value_t, DIM, Eigen::Affine>;
 
   /// Re expose the number of dimensions
-  static constexpr size_t dim = DIM;
+  static constexpr std::size_t dim = DIM;
   /// Re expose the number of sides
-  static constexpr size_t sides = SIDES;
+  static constexpr std::size_t sides = SIDES;
 
   /// Constructor for the 2D case.
   /// @param origin The origin of the frustum
@@ -51,7 +51,7 @@ class Frustum {
   /// @param opening_angle The opening angle
   /// @note The @p opening_angle is defined as the angle between opposing side
   /// planes. The opening angle needs to be < pi.
-  template <size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
+  template <std::size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
   Frustum(const VertexType& origin, const VertexType& dir,
           value_type opening_angle);
 
@@ -61,7 +61,7 @@ class Frustum {
   /// @param opening_angle The opening angle
   /// @note The @p opening_angle is defined as the angle between opposing side
   /// planes. The opening angle needs to be < pi.
-  template <size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
+  template <std::size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
   Frustum(const VertexType& origin, const VertexType& dir,
           value_type opening_angle);
 
@@ -70,7 +70,7 @@ class Frustum {
   /// @param helper The visualization helper
   /// @param far_distance The distance to the virtual "far plane" at which point
   /// the side planes terminate visually.
-  template <size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
+  template <std::size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
   void draw(IVisualization3D& helper, value_type far_distance = 10) const;
 
   /// Draw a representation of this frustum as an SVG string to an outstream
@@ -81,7 +81,7 @@ class Frustum {
   /// @param far_distance The distance to the virtual "far line" at which point
   /// the side lines terminate visually.
   /// @param unit Multiplicative factor to apply to internal distances
-  template <size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
+  template <std::size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
   std::ostream& svg(std::ostream& os, value_type w, value_type h,
                     value_type far_distance = 1, value_type unit = 20.) const;
 
diff --git a/Core/include/Acts/Utilities/Frustum.ipp b/Core/include/Acts/Utilities/Frustum.ipp
index 7a0b33de0dc..75dbb3377ad 100644
--- a/Core/include/Acts/Utilities/Frustum.ipp
+++ b/Core/include/Acts/Utilities/Frustum.ipp
@@ -8,8 +8,8 @@
 
 #include "Acts/Utilities/VectorHelpers.hpp"
 
-template <typename value_t, size_t DIM, size_t SIDES>
-template <size_t D, std::enable_if_t<D == 2, int>>
+template <typename value_t, std::size_t DIM, std::size_t SIDES>
+template <std::size_t D, std::enable_if_t<D == 2, int>>
 Acts::Frustum<value_t, DIM, SIDES>::Frustum(const VertexType& origin,
                                             const VertexType& dir,
                                             value_type opening_angle)
@@ -30,8 +30,8 @@ Acts::Frustum<value_t, DIM, SIDES>::Frustum(const VertexType& origin,
   m_normals = {rot * VertexType::UnitX(), rot * normal1, rot * normal2};
 }
 
-template <typename value_t, size_t DIM, size_t SIDES>
-template <size_t D, std::enable_if_t<D == 3, int>>
+template <typename value_t, std::size_t DIM, std::size_t SIDES>
+template <std::size_t D, std::enable_if_t<D == 3, int>>
 Acts::Frustum<value_t, DIM, SIDES>::Frustum(const VertexType& origin,
                                             const VertexType& dir,
                                             value_type opening_angle)
@@ -63,7 +63,7 @@ Acts::Frustum<value_t, DIM, SIDES>::Frustum(const VertexType& origin,
   VertexType current_outward = lup;
   m_normals[1] = calculate_normal(current_outward);
 
-  for (size_t i = 1; i < sides; i++) {
+  for (std::size_t i = 1; i < sides; i++) {
     current_outward = rot * current_outward;
     m_normals[i + 1] = calculate_normal(current_outward);
   }
@@ -73,8 +73,8 @@ Acts::Frustum<value_t, DIM, SIDES>::Frustum(const VertexType& origin,
   }
 }
 
-template <typename value_t, size_t DIM, size_t SIDES>
-template <size_t D, std::enable_if_t<D == 3, int>>
+template <typename value_t, std::size_t DIM, std::size_t SIDES>
+template <std::size_t D, std::enable_if_t<D == 3, int>>
 void Acts::Frustum<value_t, DIM, SIDES>::draw(IVisualization3D& helper,
                                               value_type far_distance) const {
   static_assert(DIM == 3, "Drawing is only supported in 3D");
@@ -101,7 +101,7 @@ void Acts::Frustum<value_t, DIM, SIDES>::draw(IVisualization3D& helper,
   };
 
   // skip i=0 <=> pseudo-near
-  for (size_t i = 1; i < n_normals; i++) {
+  for (std::size_t i = 1; i < n_normals; i++) {
     const auto ixLine =
         ixPlanePlane(far_normal, far_center, m_normals[i], VertexType::Zero());
     planeFarIXs.at(i - 1) = ixLine;
@@ -109,8 +109,8 @@ void Acts::Frustum<value_t, DIM, SIDES>::draw(IVisualization3D& helper,
 
   std::array<VertexType, SIDES> points;
 
-  for (size_t i = 0; i < std::size(planeFarIXs); i++) {
-    size_t j = (i + 1) % std::size(planeFarIXs);
+  for (std::size_t i = 0; i < std::size(planeFarIXs); i++) {
+    std::size_t j = (i + 1) % std::size(planeFarIXs);
     const auto& l1 = planeFarIXs.at(i);
     const auto& l2 = planeFarIXs.at(j);
     const VertexType ix =
@@ -118,15 +118,15 @@ void Acts::Frustum<value_t, DIM, SIDES>::draw(IVisualization3D& helper,
     points.at(i) = ix;
   }
 
-  for (size_t i = 0; i < std::size(points); i++) {
-    size_t j = (i + 1) % std::size(points);
+  for (std::size_t i = 0; i < std::size(points); i++) {
+    std::size_t j = (i + 1) % std::size(points);
     helper.face(
         std::vector<VertexType>({m_origin, points.at(i), points.at(j)}));
   }
 }
 
-template <typename value_t, size_t DIM, size_t SIDES>
-template <size_t D, std::enable_if_t<D == 2, int>>
+template <typename value_t, std::size_t DIM, std::size_t SIDES>
+template <std::size_t D, std::enable_if_t<D == 2, int>>
 std::ostream& Acts::Frustum<value_t, DIM, SIDES>::svg(std::ostream& os,
                                                       value_type w,
                                                       value_type h,
@@ -146,7 +146,7 @@ std::ostream& Acts::Frustum<value_t, DIM, SIDES>::svg(std::ostream& os,
   std::array<std::string, 3> colors({"orange", "blue", "red"});
 
   auto draw_line = [&](const VertexType& left_, const VertexType& right_,
-                       const std::string& color, size_t width) {
+                       const std::string& color, std::size_t width) {
     VertexType left = trf * left_;
     VertexType right = trf * right_;
     os << "<line ";
@@ -160,7 +160,7 @@ std::ostream& Acts::Frustum<value_t, DIM, SIDES>::svg(std::ostream& os,
   };
 
   auto draw_point = [&](const VertexType& p_, const std::string& color,
-                        size_t r) {
+                        std::size_t r) {
     VertexType p = trf * p_;
     os << "<circle ";
     os << "cx=\"" << p.x() << "\" cy=\"" << p.y() << "\" r=\"" << r << "\"";
@@ -196,7 +196,7 @@ std::ostream& Acts::Frustum<value_t, DIM, SIDES>::svg(std::ostream& os,
 
   std::array<VertexType, 2> points;
 
-  for (size_t i = 1; i < n_normals; i++) {
+  for (std::size_t i = 1; i < n_normals; i++) {
     VertexType plane_dir(m_normals[i].y(), -m_normals[i].x());
 
     const VertexType ix = ixLineLine(far_point, far_dir, {0, 0}, plane_dir);
@@ -215,14 +215,14 @@ std::ostream& Acts::Frustum<value_t, DIM, SIDES>::svg(std::ostream& os,
   return os;
 }
 
-template <typename value_t, size_t DIM, size_t SIDES>
+template <typename value_t, std::size_t DIM, std::size_t SIDES>
 Acts::Frustum<value_t, DIM, SIDES>
 Acts::Frustum<value_t, DIM, SIDES>::transformed(
     const transform_type& trf) const {
   const auto& rot = trf.rotation();
 
   std::array<VertexType, n_normals> new_normals;
-  for (size_t i = 0; i < n_normals; i++) {
+  for (std::size_t i = 0; i < n_normals; i++) {
     new_normals[i] = rot * m_normals[i];
   }
 
diff --git a/Core/include/Acts/Utilities/Grid.hpp b/Core/include/Acts/Utilities/Grid.hpp
index 88be2aa164b..f4b1671a077 100644
--- a/Core/include/Acts/Utilities/Grid.hpp
+++ b/Core/include/Acts/Utilities/Grid.hpp
@@ -36,7 +36,7 @@ template <typename T, class... Axes>
 class Grid final {
  public:
   /// number of dimensions of the grid
-  static constexpr size_t DIM = sizeof...(Axes);
+  static constexpr std::size_t DIM = sizeof...(Axes);
 
   /// type of values stored
   using value_type = T;
@@ -47,7 +47,7 @@ class Grid final {
   /// type for points in d-dimensional grid space
   using point_t = std::array<ActsScalar, DIM>;
   /// index type using local bin indices along each axis
-  using index_t = std::array<size_t, DIM>;
+  using index_t = std::array<std::size_t, DIM>;
 
   /// @brief default constructor
   ///
@@ -100,14 +100,14 @@ class Grid final {
   /// @param  [in] bin global bin number
   /// @return reference to value stored in bin containing the given
   ///         point
-  reference at(size_t bin) { return m_values.at(bin); }
+  reference at(std::size_t bin) { return m_values.at(bin); }
 
   /// @brief access value stored in bin with given global bin number
   ///
   /// @param  [in] bin global bin number
   /// @return const-reference to value stored in bin containing the given
   ///         point
-  const_reference at(size_t bin) const { return m_values.at(bin); }
+  const_reference at(std::size_t bin) const { return m_values.at(bin); }
 
   /// @brief access value stored in bin with given local bin numbers
   ///
@@ -153,7 +153,7 @@ class Grid final {
   /// @brief dimensionality of grid
   ///
   /// @return number of axes spanning the grid
-  static constexpr size_t dimensions() { return DIM; }
+  static constexpr std::size_t dimensions() { return DIM; }
 
   /// @brief get center position of bin with given local bin numbers
   ///
@@ -178,7 +178,7 @@ class Grid final {
   ///      dimensions where d is dimensionality of the grid.
   /// @note This could be a under-/overflow bin along one or more axes.
   template <class Point>
-  size_t globalBinFromPosition(const Point& point) const {
+  std::size_t globalBinFromPosition(const Point& point) const {
     return globalBinFromLocalBins(localBinsFromPosition(point));
   }
 
@@ -189,7 +189,7 @@ class Grid final {
   ///
   /// @pre All local bin indices must be a valid index for the corresponding
   ///      axis (including the under-/overflow bin for this axis).
-  size_t globalBinFromLocalBins(const index_t& localBins) const {
+  std::size_t globalBinFromLocalBins(const index_t& localBins) const {
     return detail::grid_helper::getGlobalBin(localBins, m_axes);
   }
 
@@ -206,7 +206,7 @@ class Grid final {
   ///      dimensions where d is dimensionality of the grid.
   /// @note This could be a under-/overflow bin along one or more axes.
   template <class Point>
-  size_t globalBinFromFromLowerLeftEdge(const Point& point) const {
+  std::size_t globalBinFromFromLowerLeftEdge(const Point& point) const {
     return globalBinFromLocalBins(localBinsFromLowerLeftEdge(point));
   }
 
@@ -235,7 +235,7 @@ class Grid final {
   ///
   /// @note Local bin indices can contain under-/overflow bins along the
   ///       corresponding axis.
-  index_t localBinsFromGlobalBin(size_t bin) const {
+  index_t localBinsFromGlobalBin(std::size_t bin) const {
     return detail::grid_helper::getLocalBinIndices(bin, m_axes);
   }
 
@@ -256,7 +256,7 @@ class Grid final {
   index_t localBinsFromLowerLeftEdge(const Point& point) const {
     Point shiftedPoint;
     point_t width = detail::grid_helper::getWidth(m_axes);
-    for (size_t i = 0; i < DIM; i++) {
+    for (std::size_t i = 0; i < DIM; i++) {
       shiftedPoint[i] = point[i] + width[i] / 2;
     }
     return detail::grid_helper::getLocalBinIndices(shiftedPoint, m_axes);
@@ -312,7 +312,7 @@ class Grid final {
   ///                   bin of the grid.
   ///
   void setExteriorBins(const value_type& value) {
-    for (size_t index : detail::grid_helper::exteriorBinIndices(m_axes)) {
+    for (std::size_t index : detail::grid_helper::exteriorBinIndices(m_axes)) {
       at(index) = value;
     }
   }
@@ -348,7 +348,7 @@ class Grid final {
                                         std::array<ActsScalar, DIM>, U>::value>>
   T interpolate(const Point& point) const {
     // there are 2^DIM corner points used during the interpolation
-    constexpr size_t nCorners = 1 << DIM;
+    constexpr std::size_t nCorners = 1 << DIM;
 
     // construct vector of pairs of adjacent bin centers and values
     std::array<value_type, nCorners> neighbors{};
@@ -362,8 +362,8 @@ class Grid final {
     const auto& closestIndices = rawClosestPointsIndices(llIndices);
 
     // get values on grid points
-    size_t i = 0;
-    for (size_t index : closestIndices) {
+    std::size_t i = 0;
+    for (std::size_t index : closestIndices) {
       neighbors.at(i++) = at(index);
     }
 
@@ -403,7 +403,7 @@ class Grid final {
   ///       over-/underflow bins, the neighborhood is of size \f$2 \times
   ///       \text{size}+1\f$ along each dimension.
   detail::GlobalNeighborHoodIndices<DIM> neighborHoodIndices(
-      const index_t& localBins, size_t size = 1u) const {
+      const index_t& localBins, std::size_t size = 1u) const {
     return detail::grid_helper::neighborHoodIndices(localBins, size, m_axes);
   }
 
@@ -435,7 +435,7 @@ class Grid final {
   /// @return total number of bins in the grid
   ///
   /// @note This number contains under-and overflow bins along all axes.
-  size_t size(bool fullCounter = true) const {
+  std::size_t size(bool fullCounter = true) const {
     index_t nBinsArray = numLocalBins();
     std::size_t current_size = 1;
     // add under-and overflow bins for each axis and multiply all bins
diff --git a/Core/include/Acts/Utilities/Helpers.hpp b/Core/include/Acts/Utilities/Helpers.hpp
index 5d0f7b2518d..851a67b6048 100644
--- a/Core/include/Acts/Utilities/Helpers.hpp
+++ b/Core/include/Acts/Utilities/Helpers.hpp
@@ -91,23 +91,23 @@ std::array<value_type, kDIM> to_array(const std::vector<value_type>& vecvals) {
 /// @brief Dispatch a call based on a runtime value on a function taking the
 /// value at compile time.
 ///
-/// This function allows to write a templated functor, which accepts a @c size_t
+/// This function allows to write a templated functor, which accepts a @c std::size_t
 /// like parameter at compile time. It is then possible to make a call to the
 /// corresponding instance of the functor based on a runtime value. To achieve
 /// this, the function essentially created a if cascade between @c N and @c
 /// NMAX, attempting to find the right instance. Because the cascade is visible
 /// to the compiler entirely, it should be able to optimize.
 ///
-/// @tparam Callable Type which takes a size_t as a compile time param
+/// @tparam Callable Type which takes a std::size_t as a compile time param
 /// @tparam N Value from which to start the dispatch chain, i.e. 0 in most cases
 /// @tparam NMAX Maximum value up to which to attempt a dispatch
 /// @param v The runtime value to dispatch on
 /// @param args Additional arguments passed to @c Callable::invoke().
 /// @note @c Callable is expected to have a static member function @c invoke
 /// that is callable with @c Args
-template <template <size_t> class Callable, size_t N, size_t NMAX,
-          typename... Args>
-auto template_switch(size_t v, Args&&... args) {
+template <template <std::size_t> class Callable, std::size_t N,
+          std::size_t NMAX, typename... Args>
+auto template_switch(std::size_t v, Args&&... args) {
   if (v == N) {
     return Callable<N>::invoke(std::forward<Args>(args)...);
   }
@@ -132,10 +132,10 @@ auto template_switch(size_t v, Args&&... args) {
 /// @param v The runtime value to dispatch on
 /// @param func The lambda to invoke
 /// @param args Additional arguments passed to @p func
-template <size_t N, size_t NMAX, typename Lambda, typename... Args>
-auto template_switch_lambda(size_t v, Lambda&& func, Args&&... args) {
+template <std::size_t N, std::size_t NMAX, typename Lambda, typename... Args>
+auto template_switch_lambda(std::size_t v, Lambda&& func, Args&&... args) {
   if (v == N) {
-    return func(std::integral_constant<size_t, N>{},
+    return func(std::integral_constant<std::size_t, N>{},
                 std::forward<Args>(args)...);
   }
   if (v == 0) {
diff --git a/Core/include/Acts/Utilities/IAxis.hpp b/Core/include/Acts/Utilities/IAxis.hpp
index a790f4efa27..b10c02a7182 100644
--- a/Core/include/Acts/Utilities/IAxis.hpp
+++ b/Core/include/Acts/Utilities/IAxis.hpp
@@ -51,6 +51,6 @@ class IAxis {
   /// @brief get total number of bins
   ///
   /// @return total number of bins (excluding under-/overflow bins)
-  virtual size_t getNBins() const = 0;
+  virtual std::size_t getNBins() const = 0;
 };
 }  // namespace Acts
diff --git a/Core/include/Acts/Utilities/Interpolation.hpp b/Core/include/Acts/Utilities/Interpolation.hpp
index 93d9f042dd2..368104e21b5 100644
--- a/Core/include/Acts/Utilities/Interpolation.hpp
+++ b/Core/include/Acts/Utilities/Interpolation.hpp
@@ -71,7 +71,7 @@ namespace Acts {
 ///    - (4,2,6): 101 = 5
 ///    - (4,5,3): 110 = 6
 ///    - (4,5,6): 111 = 7
-template <typename T, size_t N, class Point1, class Point2 = Point1,
+template <typename T, std::size_t N, class Point1, class Point2 = Point1,
           class Point3 = Point2,
           typename = std::enable_if_t<
               detail::can_interpolate<Point1, Point2, Point3, T>::value>>
diff --git a/Core/include/Acts/Utilities/Ray.hpp b/Core/include/Acts/Utilities/Ray.hpp
index b07e6234e44..f3f7635569d 100644
--- a/Core/include/Acts/Utilities/Ray.hpp
+++ b/Core/include/Acts/Utilities/Ray.hpp
@@ -17,7 +17,7 @@ namespace Acts {
 /// direction.
 /// @tparam value_t The floating point type to use
 /// @tparam DIM The number of dimensions in which this ray is defined (2 or 3)
-template <typename value_t, size_t DIM>
+template <typename value_t, std::size_t DIM>
 class Ray {
  public:
   /// Re expose the value type
@@ -59,7 +59,7 @@ class Ray {
   /// Helper to draw this ray using a given visualization helper.
   /// @param helper The visualization helper
   /// @param far_distance The "length" of the drawn line representing the ray
-  template <size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
+  template <std::size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
   void draw(IVisualization3D& helper, value_type far_distance = 10) const;
 
  private:
@@ -72,7 +72,7 @@ class Ray {
 /// @param os The out stream
 /// @param ray The ray to write to @p os
 /// @return The outstream given in @p os
-template <typename T, size_t D>
+template <typename T, std::size_t D>
 std::ostream& operator<<(std::ostream& os, const Ray<T, D>& ray) {
   ray.dump(os);
   return os;
diff --git a/Core/include/Acts/Utilities/Ray.ipp b/Core/include/Acts/Utilities/Ray.ipp
index 78f09dd23c9..5d7279f7796 100644
--- a/Core/include/Acts/Utilities/Ray.ipp
+++ b/Core/include/Acts/Utilities/Ray.ipp
@@ -7,20 +7,20 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "Acts/Definitions/Algebra.hpp"
-template <typename value_t, size_t DIM>
+template <typename value_t, std::size_t DIM>
 Acts::Ray<value_t, DIM>::Ray(const VertexType& origin, const VertexType& dir)
     : m_origin(origin), m_dir(dir.normalized()), m_idir(1 / m_dir.array()) {}
-template <typename value_t, size_t DIM>
+template <typename value_t, std::size_t DIM>
 std::ostream& Acts::Ray<value_t, DIM>::toStream(std::ostream& os) const {
   os << "Ray(";
-  for (size_t i = 0; i < DIM; i++) {
+  for (std::size_t i = 0; i < DIM; i++) {
     if (i > 0) {
       os << ", ";
     }
     os << m_origin[i];
   }
   os << " -> ";
-  for (size_t i = 0; i < DIM; i++) {
+  for (std::size_t i = 0; i < DIM; i++) {
     if (i > 0) {
       os << ", ";
     }
@@ -31,14 +31,14 @@ std::ostream& Acts::Ray<value_t, DIM>::toStream(std::ostream& os) const {
   return os;
 }
 
-template <typename value_t, size_t DIM>
+template <typename value_t, std::size_t DIM>
 Acts::Ray<value_t, DIM> Acts::Ray<value_t, DIM>::transformed(
     const transform_type& trf) const {
   return Ray<value_t, DIM>(trf * m_origin, trf.rotation() * m_dir);
 }
 
-template <typename value_t, size_t DIM>
-template <size_t D, std::enable_if_t<D == 3, int>>
+template <typename value_t, std::size_t DIM>
+template <std::size_t D, std::enable_if_t<D == 3, int>>
 void Acts::Ray<value_t, DIM>::draw(IVisualization3D& helper,
                                    value_type far_distance) const {
   static_assert(DIM == 3, "OBJ is only supported in 3D");
@@ -46,7 +46,7 @@ void Acts::Ray<value_t, DIM>::draw(IVisualization3D& helper,
   helper.line(m_origin, (m_origin + m_dir * far_distance).eval());
 }
 
-template <typename U, size_t V>
+template <typename U, std::size_t V>
 std::ostream& operator<<(std::ostream& os, const Acts::Ray<U, V>& ray) {
   ray.dump(os);
   return os;
diff --git a/Core/include/Acts/Utilities/detail/Axis.hpp b/Core/include/Acts/Utilities/detail/Axis.hpp
index b511828cf0c..be9e22f9edd 100644
--- a/Core/include/Acts/Utilities/detail/Axis.hpp
+++ b/Core/include/Acts/Utilities/detail/Axis.hpp
@@ -33,10 +33,11 @@ class NeighborHoodIndices {
  public:
   NeighborHoodIndices() = default;
 
-  NeighborHoodIndices(size_t begin, size_t end)
+  NeighborHoodIndices(std::size_t begin, std::size_t end)
       : m_begin1(begin), m_end1(end), m_begin2(end), m_end2(end) {}
 
-  NeighborHoodIndices(size_t begin1, size_t end1, size_t begin2, size_t end2)
+  NeighborHoodIndices(std::size_t begin1, std::size_t end1, std::size_t begin2,
+                      std::size_t end2)
       : m_begin1(begin1), m_end1(end1), m_begin2(begin2), m_end2(end2) {}
 
   class iterator {
@@ -44,15 +45,15 @@ class NeighborHoodIndices {
     iterator() = default;
 
     // Specialized constructor for end() iterator
-    iterator(size_t current) : m_current(current), m_wrapped(true) {}
+    iterator(std::size_t current) : m_current(current), m_wrapped(true) {}
 
-    iterator(size_t begin1, size_t end1, size_t begin2)
+    iterator(std::size_t begin1, std::size_t end1, std::size_t begin2)
         : m_current(begin1),
           m_end1(end1),
           m_begin2(begin2),
           m_wrapped(begin1 == begin2) {}
 
-    size_t operator*() const { return m_current; }
+    std::size_t operator*() const { return m_current; }
 
     iterator& operator++() {
       ++m_current;
@@ -70,7 +71,7 @@ class NeighborHoodIndices {
     bool operator!=(const iterator& it) const { return !(*this == it); }
 
    private:
-    size_t m_current = 0, m_end1 = 0, m_begin2 = 0;
+    std::size_t m_current = 0, m_end1 = 0, m_begin2 = 0;
     bool m_wrapped = false;
   };
 
@@ -79,20 +80,20 @@ class NeighborHoodIndices {
   iterator end() const { return iterator(m_end2); }
 
   // Number of indices that will be produced if this sequence is iterated
-  size_t size() const { return (m_end1 - m_begin1) + (m_end2 - m_begin2); }
+  std::size_t size() const { return (m_end1 - m_begin1) + (m_end2 - m_begin2); }
 
   // Collect the sequence of indices into an std::vector
-  std::vector<size_t> collect() const {
-    std::vector<size_t> result;
+  std::vector<std::size_t> collect() const {
+    std::vector<std::size_t> result;
     result.reserve(this->size());
-    for (size_t idx : *this) {
+    for (std::size_t idx : *this) {
       result.push_back(idx);
     }
     return result;
   }
 
  private:
-  size_t m_begin1 = 0, m_end1 = 0, m_begin2 = 0, m_end2 = 0;
+  std::size_t m_begin1 = 0, m_end1 = 0, m_begin2 = 0, m_end2 = 0;
 };
 
 /// @brief calculate bin indices for an equidistant binning
@@ -110,7 +111,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   ///
   /// Divide the range \f$[\text{xmin},\text{xmax})\f$ into \f$\text{nBins}\f$
   /// equidistant bins.
-  Axis(ActsScalar xmin, ActsScalar xmax, size_t nBins)
+  Axis(ActsScalar xmin, ActsScalar xmax, std::size_t nBins)
       : m_min(xmin),
         m_max(xmax),
         m_width((xmax - xmin) / nBins),
@@ -138,7 +139,8 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   /// @param [in] idx requested bin index
   /// @param [in] sizes how many neighboring bins (up/down)
   /// @return Set of neighboring bin indices (global)
-  NeighborHoodIndices neighborHoodIndices(size_t idx, size_t size = 1) const {
+  NeighborHoodIndices neighborHoodIndices(std::size_t idx,
+                                          std::size_t size = 1) const {
     return neighborHoodIndices(idx, std::make_pair(-size, size));
   }
 
@@ -154,7 +156,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   ///       as neighbors
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Open, int> = 0>
-  NeighborHoodIndices neighborHoodIndices(size_t idx,
+  NeighborHoodIndices neighborHoodIndices(std::size_t idx,
                                           std::pair<int, int> sizes = {
                                               -1, 1}) const {
     constexpr int min = 0;
@@ -176,7 +178,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   ///       as neighbors
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Bound, int> = 0>
-  NeighborHoodIndices neighborHoodIndices(size_t idx,
+  NeighborHoodIndices neighborHoodIndices(std::size_t idx,
                                           std::pair<int, int> sizes = {
                                               -1, 1}) const {
     if (idx <= 0 || idx >= (getNBins() + 1)) {
@@ -201,7 +203,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   ///       side of the axis as neighbors. (excludes underflow / overflow)
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Closed, int> = 0>
-  NeighborHoodIndices neighborHoodIndices(size_t idx,
+  NeighborHoodIndices neighborHoodIndices(std::size_t idx,
                                           std::pair<int, int> sizes = {
                                               -1, 1}) const {
     // Handle invalid indices
@@ -229,8 +231,8 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
     //
     const int itmin = idx + sizes.first;
     const int itmax = idx + sizes.second;
-    const size_t itfirst = wrapBin(itmin);
-    const size_t itlast = wrapBin(itmax);
+    const std::size_t itfirst = wrapBin(itmin);
+    const std::size_t itlast = wrapBin(itmax);
     if (itfirst <= itlast) {
       return NeighborHoodIndices(itfirst, itlast + 1);
     } else {
@@ -246,7 +248,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   /// @return valid bin index
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Open, int> = 0>
-  size_t wrapBin(int bin) const {
+  std::size_t wrapBin(int bin) const {
     return std::max(std::min(bin, static_cast<int>(getNBins()) + 1), 0);
   }
 
@@ -258,7 +260,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   /// @return valid bin index
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Bound, int> = 0>
-  size_t wrapBin(int bin) const {
+  std::size_t wrapBin(int bin) const {
     return std::max(std::min(bin, static_cast<int>(getNBins())), 1);
   }
 
@@ -270,7 +272,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   /// @return valid bin index
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Closed, int> = 0>
-  size_t wrapBin(int bin) const {
+  std::size_t wrapBin(int bin) const {
     const int w = getNBins();
     return 1 + (w + ((bin - 1) % w)) % w;
     // return int(bin<1)*w - int(bin>w)*w + bin;
@@ -286,7 +288,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   ///       bin with lower bound @c l and upper bound @c u.
   /// @note Bin indices start at @c 1. The underflow bin has the index @c 0
   ///       while the index <tt>nBins + 1</tt> indicates the overflow bin .
-  size_t getBin(ActsScalar x) const {
+  std::size_t getBin(ActsScalar x) const {
     return wrapBin(
         static_cast<int>(std::floor((x - getMin()) / getBinWidth()) + 1));
   }
@@ -294,7 +296,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   /// @brief get bin width
   ///
   /// @return constant width for all bins
-  ActsScalar getBinWidth(size_t /*bin*/ = 0) const { return m_width; }
+  ActsScalar getBinWidth(std::size_t /*bin*/ = 0) const { return m_width; }
 
   /// @brief get lower bound of bin
   ///
@@ -306,7 +308,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   ///
   /// @note Bin intervals have a closed lower bound, i.e. the lower boundary
   ///       belongs to the bin with the given bin index.
-  ActsScalar getBinLowerBound(size_t bin) const {
+  ActsScalar getBinLowerBound(std::size_t bin) const {
     return getMin() + (bin - 1) * getBinWidth();
   }
 
@@ -320,7 +322,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   ///
   /// @note Bin intervals have an open upper bound, i.e. the upper boundary
   ///       does @b not belong to the bin with the given bin index.
-  ActsScalar getBinUpperBound(size_t bin) const {
+  ActsScalar getBinUpperBound(std::size_t bin) const {
     return getMin() + bin * getBinWidth();
   }
 
@@ -331,7 +333,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   ///
   /// @pre @c bin must be a valid bin index (excluding under-/overflow bins),
   ///      i.e. \f$1 \le \text{bin} \le \text{nBins}\f$
-  ActsScalar getBinCenter(size_t bin) const {
+  ActsScalar getBinCenter(std::size_t bin) const {
     return getMin() + (bin - 0.5) * getBinWidth();
   }
 
@@ -348,7 +350,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   /// @brief get total number of bins
   ///
   /// @return total number of bins (excluding under-/overflow bins)
-  size_t getNBins() const override { return m_bins; }
+  std::size_t getNBins() const override { return m_bins; }
 
   /// @brief check whether value is inside axis limits
   ///
@@ -363,7 +365,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   /// @return Vector which contains the bin edges
   std::vector<ActsScalar> getBinEdges() const override {
     std::vector<ActsScalar> binEdges;
-    for (size_t i = 1; i <= m_bins; i++) {
+    for (std::size_t i = 1; i <= m_bins; i++) {
       binEdges.push_back(getBinLowerBound(i));
     }
     binEdges.push_back(getBinUpperBound(m_bins));
@@ -378,7 +380,7 @@ class Axis<AxisType::Equidistant, bdt> final : public IAxis {
   /// constant bin width
   ActsScalar m_width;
   /// number of bins (excluding under-/overflow bins)
-  size_t m_bins;
+  std::size_t m_bins;
 };
 
 /// @brief calculate bin indices for a variable binning
@@ -421,7 +423,8 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   /// @param [in] idx requested bin index
   /// @param [in] size how many neighboring bins
   /// @return Set of neighboring bin indices (global)
-  NeighborHoodIndices neighborHoodIndices(size_t idx, size_t size = 1) const {
+  NeighborHoodIndices neighborHoodIndices(std::size_t idx,
+                                          std::size_t size = 1) const {
     return neighborHoodIndices(idx, std::make_pair(-size, size));
   }
 
@@ -437,7 +440,7 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   ///       as neighbors
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Open, int> = 0>
-  NeighborHoodIndices neighborHoodIndices(size_t idx,
+  NeighborHoodIndices neighborHoodIndices(std::size_t idx,
                                           std::pair<int, int> sizes = {
                                               -1, 1}) const {
     constexpr int min = 0;
@@ -458,7 +461,7 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   ///       as neighbors
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Bound, int> = 0>
-  NeighborHoodIndices neighborHoodIndices(size_t idx,
+  NeighborHoodIndices neighborHoodIndices(std::size_t idx,
                                           std::pair<int, int> sizes = {
                                               -1, 1}) const {
     if (idx <= 0 || idx >= (getNBins() + 1)) {
@@ -482,7 +485,7 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   ///       side of the axis as neighbors. (excludes underflow / overflow)
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Closed, int> = 0>
-  NeighborHoodIndices neighborHoodIndices(size_t idx,
+  NeighborHoodIndices neighborHoodIndices(std::size_t idx,
                                           std::pair<int, int> sizes = {
                                               -1, 1}) const {
     // Handle invalid indices
@@ -510,8 +513,8 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
     //
     const int itmin = idx + sizes.first;
     const int itmax = idx + sizes.second;
-    const size_t itfirst = wrapBin(itmin);
-    const size_t itlast = wrapBin(itmax);
+    const std::size_t itfirst = wrapBin(itmin);
+    const std::size_t itlast = wrapBin(itmax);
     if (itfirst <= itlast) {
       return NeighborHoodIndices(itfirst, itlast + 1);
     } else {
@@ -527,7 +530,7 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   /// @return valid bin index
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Open, int> = 0>
-  size_t wrapBin(int bin) const {
+  std::size_t wrapBin(int bin) const {
     return std::max(std::min(bin, static_cast<int>(getNBins()) + 1), 0);
   }
 
@@ -539,7 +542,7 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   /// @return valid bin index
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Bound, int> = 0>
-  size_t wrapBin(int bin) const {
+  std::size_t wrapBin(int bin) const {
     return std::max(std::min(bin, static_cast<int>(getNBins())), 1);
   }
 
@@ -551,7 +554,7 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   /// @return valid bin index
   template <AxisBoundaryType T = bdt,
             std::enable_if_t<T == AxisBoundaryType::Closed, int> = 0>
-  size_t wrapBin(int bin) const {
+  std::size_t wrapBin(int bin) const {
     const int w = getNBins();
     return 1 + (w + ((bin - 1) % w)) % w;
     // return int(bin<1)*w - int(bin>w)*w + bin;
@@ -567,7 +570,7 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   ///       bin with lower bound @c l and upper bound @c u.
   /// @note Bin indices start at @c 1. The underflow bin has the index @c 0
   ///       while the index <tt>nBins + 1</tt> indicates the overflow bin .
-  size_t getBin(ActsScalar x) const {
+  std::size_t getBin(ActsScalar x) const {
     const auto it =
         std::upper_bound(std::begin(m_binEdges), std::end(m_binEdges), x);
     return wrapBin(std::distance(std::begin(m_binEdges), it));
@@ -580,7 +583,7 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   ///
   /// @pre @c bin must be a valid bin index (excluding under-/overflow bins),
   ///      i.e. \f$1 \le \text{bin} \le \text{nBins}\f$
-  ActsScalar getBinWidth(size_t bin) const {
+  ActsScalar getBinWidth(std::size_t bin) const {
     return m_binEdges.at(bin) - m_binEdges.at(bin - 1);
   }
 
@@ -594,7 +597,7 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   ///
   /// @note Bin intervals have a closed lower bound, i.e. the lower boundary
   ///       belongs to the bin with the given bin index.
-  ActsScalar getBinLowerBound(size_t bin) const {
+  ActsScalar getBinLowerBound(std::size_t bin) const {
     return m_binEdges.at(bin - 1);
   }
 
@@ -608,7 +611,9 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   ///
   /// @note Bin intervals have an open upper bound, i.e. the upper boundary
   ///       does @b not belong to the bin with the given bin index.
-  ActsScalar getBinUpperBound(size_t bin) const { return m_binEdges.at(bin); }
+  ActsScalar getBinUpperBound(std::size_t bin) const {
+    return m_binEdges.at(bin);
+  }
 
   /// @brief get bin center
   ///
@@ -617,7 +622,7 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   ///
   /// @pre @c bin must be a valid bin index (excluding under-/overflow bins),
   ///      i.e. \f$1 \le \text{bin} \le \text{nBins}\f$
-  ActsScalar getBinCenter(size_t bin) const {
+  ActsScalar getBinCenter(std::size_t bin) const {
     return 0.5 * (getBinLowerBound(bin) + getBinUpperBound(bin));
   }
 
@@ -634,7 +639,7 @@ class Axis<AxisType::Variable, bdt> final : public IAxis {
   /// @brief get total number of bins
   ///
   /// @return total number of bins (excluding under-/overflow bins)
-  size_t getNBins() const override { return m_binEdges.size() - 1; }
+  std::size_t getNBins() const override { return m_binEdges.size() - 1; }
 
   /// @brief check whether value is inside axis limits
   ///
diff --git a/Core/include/Acts/Utilities/detail/MPL/at_index.hpp b/Core/include/Acts/Utilities/detail/MPL/at_index.hpp
index cc78f3da8d8..e45bf816a48 100644
--- a/Core/include/Acts/Utilities/detail/MPL/at_index.hpp
+++ b/Core/include/Acts/Utilities/detail/MPL/at_index.hpp
@@ -21,11 +21,11 @@ namespace detail {
  *         at the given position in `values` if 0 &le; `index` <
  *         sizeof...(values). Otherwise, a compile-time error is generated.
  */
-template <typename T, size_t index, T... values>
+template <typename T, std::size_t index, T... values>
 struct at_index;
 
 /// @cond
-template <typename T, size_t index, T next, T... others>
+template <typename T, std::size_t index, T next, T... others>
 struct at_index<T, index, next, others...> {
   static constexpr T value = at_index<T, index - 1, others...>::value;
 };
diff --git a/Core/include/Acts/Utilities/detail/Subspace.hpp b/Core/include/Acts/Utilities/detail/Subspace.hpp
index aa5450de7d5..e6985c024ae 100644
--- a/Core/include/Acts/Utilities/detail/Subspace.hpp
+++ b/Core/include/Acts/Utilities/detail/Subspace.hpp
@@ -36,10 +36,10 @@ namespace detail {
 /// axes at compile time. This was tried previously and resulted in sizable
 /// resource consumption at compile time without runtime benefits.
 ///
-/// All types are intentionally using `size_t` as their template values, instead
-/// of the more specific index enums, to reduce the number of templates. This is
-/// fully compatible as the index enums are required to be convertible to
-/// `size_t`.
+/// All types are intentionally using `std::size_t` as their template values,
+/// instead of the more specific index enums, to reduce the number of templates.
+/// This is fully compatible as the index enums are required to be convertible
+/// to `std::size_t`.
 ///
 /// All types intentionally only define the subspace but not how vectors
 /// and matrices are stored to avoid unnecessary coupling between components,
@@ -60,9 +60,9 @@ namespace detail {
 ///
 /// @tparam kFullSize Size of the full vector space
 /// @tparam kSize Size of the subspace
-template <size_t kFullSize, size_t kSize>
+template <std::size_t kFullSize, std::size_t kSize>
 class FixedSizeSubspace {
-  static_assert(kFullSize <= static_cast<size_t>(UINT8_MAX),
+  static_assert(kFullSize <= static_cast<std::size_t>(UINT8_MAX),
                 "Full vector space size is larger than the supported range");
   static_assert(1u <= kSize, "Subspace size must be at least 1");
   static_assert(kSize <= kFullSize,
@@ -94,7 +94,7 @@ class FixedSizeSubspace {
   /// @param indices Unique, ordered indices
   template <typename index_t>
   constexpr FixedSizeSubspace(const std::array<index_t, kSize>& indices) {
-    for (size_t i = 0u; i < kSize; ++i) {
+    for (std::size_t i = 0u; i < kSize; ++i) {
       assert((indices[i] < kFullSize) &&
              "Axis indices must be within the full space");
       if (0u < i) {
@@ -102,7 +102,7 @@ class FixedSizeSubspace {
                "Axis indices must be unique and ordered");
       }
     }
-    for (size_t i = 0; i < kSize; ++i) {
+    for (std::size_t i = 0; i < kSize; ++i) {
       m_axes[i] = static_cast<uint8_t>(indices[i]);
     }
   }
@@ -114,19 +114,19 @@ class FixedSizeSubspace {
   FixedSizeSubspace& operator=(FixedSizeSubspace&&) = default;
 
   /// Size of the subspace.
-  static constexpr size_t size() { return kSize; }
+  static constexpr std::size_t size() { return kSize; }
   /// Size of the full vector space.
-  static constexpr size_t fullSize() { return kFullSize; }
+  static constexpr std::size_t fullSize() { return kFullSize; }
 
   /// Axis indices that comprise the subspace.
   ///
   /// The specific container and index type should be considered an
   /// implementation detail. Users should treat the return type as a generic
-  /// container whose elements are convertible to `size_t`.
+  /// container whose elements are convertible to `std::size_t`.
   constexpr const std::array<uint8_t, kSize>& indices() const { return m_axes; }
 
   /// Check if the given axis index in the full space is part of the subspace.
-  constexpr bool contains(size_t index) const {
+  constexpr bool contains(std::size_t index) const {
     bool isContained = false;
     // always iterate over all elements to avoid branching and hope the compiler
     // can optimise this for us.
diff --git a/Core/include/Acts/Utilities/detail/grid_helper.hpp b/Core/include/Acts/Utilities/detail/grid_helper.hpp
index 498dd446af0..c3cc2d82883 100644
--- a/Core/include/Acts/Utilities/detail/grid_helper.hpp
+++ b/Core/include/Acts/Utilities/detail/grid_helper.hpp
@@ -38,7 +38,7 @@ constexpr T ipow(T num, unsigned int pow) {
 // paying the price of dynamic memory allocation in hot magnetic field
 // interpolation code.
 //
-template <size_t DIM>
+template <std::size_t DIM>
 class GlobalNeighborHoodIndices {
  public:
   // You can get the local neighbor indices from
@@ -46,12 +46,12 @@ class GlobalNeighborHoodIndices {
   // each direction from grid_helper_impl<DIM>::getNBins.
   GlobalNeighborHoodIndices(
       std::array<NeighborHoodIndices, DIM>& neighborIndices,
-      const std::array<size_t, DIM>& nBinsArray)
+      const std::array<std::size_t, DIM>& nBinsArray)
       : m_localIndices(neighborIndices) {
     if (DIM == 1) {
       return;
     }
-    size_t globalStride = 1;
+    std::size_t globalStride = 1;
     for (long i = DIM - 2; i >= 0; --i) {
       globalStride *= (nBinsArray[i + 1] + 2);
       m_globalStrides[i] = globalStride;
@@ -66,12 +66,12 @@ class GlobalNeighborHoodIndices {
              std::array<NeighborHoodIndices::iterator, DIM>&& localIndicesIter)
         : m_localIndicesIter(std::move(localIndicesIter)), m_parent(&parent) {}
 
-    size_t operator*() const {
-      size_t globalIndex = *m_localIndicesIter[DIM - 1];
+    std::size_t operator*() const {
+      std::size_t globalIndex = *m_localIndicesIter[DIM - 1];
       if (DIM == 1) {
         return globalIndex;
       }
-      for (size_t i = 0; i < DIM - 1; ++i) {
+      for (std::size_t i = 0; i < DIM - 1; ++i) {
         globalIndex += m_parent->m_globalStrides[i] * (*m_localIndicesIter[i]);
       }
       return globalIndex;
@@ -118,7 +118,7 @@ class GlobalNeighborHoodIndices {
 
   iterator begin() const {
     std::array<NeighborHoodIndices::iterator, DIM> localIndicesIter{};
-    for (size_t i = 0; i < DIM; ++i) {
+    for (std::size_t i = 0; i < DIM; ++i) {
       localIndicesIter[i] = m_localIndices[i].begin();
     }
     return iterator(*this, std::move(localIndicesIter));
@@ -127,9 +127,9 @@ class GlobalNeighborHoodIndices {
   iterator end() const { return iterator(); }
 
   // Number of indices that will be produced if this sequence is iterated
-  size_t size() const {
-    size_t result = m_localIndices[0].size();
-    for (size_t i = 1; i < DIM; ++i) {
+  std::size_t size() const {
+    std::size_t result = m_localIndices[0].size();
+    for (std::size_t i = 1; i < DIM; ++i) {
       result *= m_localIndices[i].size();
     }
     return result;
@@ -137,46 +137,46 @@ class GlobalNeighborHoodIndices {
 
   // Collect the sequence of indices into a vector
   auto collect() const {
-    boost::container::small_vector<size_t, ipow(3, DIM)> result;
+    boost::container::small_vector<std::size_t, ipow(3, DIM)> result;
     result.reserve(this->size());
-    for (size_t idx : *this) {
+    for (std::size_t idx : *this) {
       result.push_back(idx);
     }
     return result;
   }
 
-  std::vector<size_t> collectVector() const {
+  std::vector<std::size_t> collectVector() const {
     auto result = collect();
     return {result.begin(), result.end()};
   }
 
  private:
   std::array<NeighborHoodIndices, DIM> m_localIndices{};
-  std::array<size_t, DIM - 1> m_globalStrides{};
+  std::array<std::size_t, DIM - 1> m_globalStrides{};
 };
 
 /// @cond
 /// @brief helper struct to calculate number of bins inside a grid
 ///
 /// @tparam N number of axes to consider
-template <size_t N>
+template <std::size_t N>
 struct grid_helper_impl;
 
-template <size_t N>
+template <std::size_t N>
 struct grid_helper_impl {
   template <class... Axes>
   static void getBinCenter(
       std::array<ActsScalar, sizeof...(Axes)>& center,
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     center.at(N) = std::get<N>(axes).getBinCenter(localIndices.at(N));
     grid_helper_impl<N - 1>::getBinCenter(center, localIndices, axes);
   }
 
   template <class... Axes>
-  static void getGlobalBin(const std::array<size_t, sizeof...(Axes)>& localBins,
-                           const std::tuple<Axes...>& axes, size_t& bin,
-                           size_t& area) {
+  static void getGlobalBin(
+      const std::array<std::size_t, sizeof...(Axes)>& localBins,
+      const std::tuple<Axes...>& axes, std::size_t& bin, std::size_t& area) {
     const auto& thisAxis = std::get<N>(axes);
     bin += area * localBins.at(N);
     // make sure to account for under-/overflow bins
@@ -185,21 +185,21 @@ struct grid_helper_impl {
   }
 
   template <class Point, class... Axes>
-  static void getLocalBinIndices(const Point& point,
-                                 const std::tuple<Axes...>& axes,
-                                 std::array<size_t, sizeof...(Axes)>& indices) {
+  static void getLocalBinIndices(
+      const Point& point, const std::tuple<Axes...>& axes,
+      std::array<std::size_t, sizeof...(Axes)>& indices) {
     const auto& thisAxis = std::get<N>(axes);
-    indices.at(N) = static_cast<size_t>(thisAxis.getBin(point[N]));
+    indices.at(N) = static_cast<std::size_t>(thisAxis.getBin(point[N]));
     grid_helper_impl<N - 1>::getLocalBinIndices(point, axes, indices);
   }
 
   template <class... Axes>
-  static void getLocalBinIndices(size_t& bin, const std::tuple<Axes...>& axes,
-                                 size_t& area,
-                                 std::array<size_t, sizeof...(Axes)>& indices) {
+  static void getLocalBinIndices(
+      std::size_t& bin, const std::tuple<Axes...>& axes, std::size_t& area,
+      std::array<std::size_t, sizeof...(Axes)>& indices) {
     const auto& thisAxis = std::get<N>(axes);
     // make sure to account for under-/overflow bins
-    size_t new_area = area * (thisAxis.getNBins() + 2);
+    std::size_t new_area = area * (thisAxis.getNBins() + 2);
     grid_helper_impl<N - 1>::getLocalBinIndices(bin, axes, new_area, indices);
     indices.at(N) = bin / area;
     bin %= area;
@@ -208,7 +208,7 @@ struct grid_helper_impl {
   template <class... Axes>
   static void getLowerLeftBinEdge(
       std::array<ActsScalar, sizeof...(Axes)>& llEdge,
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     llEdge.at(N) = std::get<N>(axes).getBinLowerBound(localIndices.at(N));
     grid_helper_impl<N - 1>::getLowerLeftBinEdge(llEdge, localIndices, axes);
@@ -216,7 +216,7 @@ struct grid_helper_impl {
 
   template <class... Axes>
   static void getLowerLeftBinIndices(
-      std::array<size_t, sizeof...(Axes)>& localIndices,
+      std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     localIndices.at(N) = std::get<N>(axes).wrapBin(localIndices.at(N) - 1);
     grid_helper_impl<N - 1>::getLowerLeftBinIndices(localIndices, axes);
@@ -224,7 +224,7 @@ struct grid_helper_impl {
 
   template <class... Axes>
   static void getNBins(const std::tuple<Axes...>& axes,
-                       std::array<size_t, sizeof...(Axes)>& nBinsArray) {
+                       std::array<std::size_t, sizeof...(Axes)>& nBinsArray) {
     // by convention getNBins does not include under-/overflow bins
     nBinsArray[N] = std::get<N>(axes).getNBins();
     grid_helper_impl<N - 1>::getNBins(axes, nBinsArray);
@@ -240,7 +240,7 @@ struct grid_helper_impl {
   template <class... Axes>
   static void getUpperRightBinEdge(
       std::array<ActsScalar, sizeof...(Axes)>& urEdge,
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     urEdge.at(N) = std::get<N>(axes).getBinUpperBound(localIndices.at(N));
     grid_helper_impl<N - 1>::getUpperRightBinEdge(urEdge, localIndices, axes);
@@ -248,7 +248,7 @@ struct grid_helper_impl {
 
   template <class... Axes>
   static void getUpperRightBinIndices(
-      std::array<size_t, sizeof...(Axes)>& localIndices,
+      std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     localIndices.at(N) = std::get<N>(axes).wrapBin(localIndices.at(N) + 1);
     grid_helper_impl<N - 1>::getUpperRightBinIndices(localIndices, axes);
@@ -283,11 +283,11 @@ struct grid_helper_impl {
 
   template <class... Axes>
   static void neighborHoodIndices(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       std::pair<int, int> sizes, const std::tuple<Axes...>& axes,
       std::array<NeighborHoodIndices, sizeof...(Axes)>& neighborIndices) {
     // ask n-th axis
-    size_t locIdx = localIndices.at(N);
+    std::size_t locIdx = localIndices.at(N);
     NeighborHoodIndices locNeighbors =
         std::get<N>(axes).neighborHoodIndices(locIdx, sizes);
     neighborIndices.at(N) = locNeighbors;
@@ -298,12 +298,12 @@ struct grid_helper_impl {
 
   template <class... Axes>
   static void neighborHoodIndices(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       std::array<std::pair<int, int>, sizeof...(Axes)> sizes,
       const std::tuple<Axes...>& axes,
       std::array<NeighborHoodIndices, sizeof...(Axes)>& neighborIndices) {
     // ask n-th axis
-    size_t locIdx = localIndices.at(N);
+    std::size_t locIdx = localIndices.at(N);
     NeighborHoodIndices locNeighbors =
         std::get<N>(axes).neighborHoodIndices(locIdx, sizes.at(N));
     neighborIndices.at(N) = locNeighbors;
@@ -313,12 +313,12 @@ struct grid_helper_impl {
   }
 
   template <class... Axes>
-  static void exteriorBinIndices(std::array<size_t, sizeof...(Axes)>& idx,
+  static void exteriorBinIndices(std::array<std::size_t, sizeof...(Axes)>& idx,
                                  std::array<bool, sizeof...(Axes)> isExterior,
-                                 std::set<size_t>& combinations,
+                                 std::set<std::size_t>& combinations,
                                  const std::tuple<Axes...>& axes) {
     // iterate over this axis' bins, remembering which bins are exterior
-    for (size_t i = 0; i < std::get<N>(axes).getNBins() + 2; ++i) {
+    for (std::size_t i = 0; i < std::get<N>(axes).getNBins() + 2; ++i) {
       idx.at(N) = i;
       isExterior.at(N) = (i == 0) || (i == std::get<N>(axes).getNBins() + 1);
       // vary other axes recursively
@@ -333,31 +333,31 @@ struct grid_helper_impl<0u> {
   template <class... Axes>
   static void getBinCenter(
       std::array<ActsScalar, sizeof...(Axes)>& center,
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     center.at(0u) = std::get<0u>(axes).getBinCenter(localIndices.at(0u));
   }
 
   template <class... Axes>
-  static void getGlobalBin(const std::array<size_t, sizeof...(Axes)>& localBins,
-                           const std::tuple<Axes...>& /*axes*/, size_t& bin,
-                           size_t& area) {
+  static void getGlobalBin(
+      const std::array<std::size_t, sizeof...(Axes)>& localBins,
+      const std::tuple<Axes...>& /*axes*/, std::size_t& bin,
+      std::size_t& area) {
     bin += area * localBins.at(0u);
   }
 
   template <class Point, class... Axes>
-  static void getLocalBinIndices(const Point& point,
-                                 const std::tuple<Axes...>& axes,
-                                 std::array<size_t, sizeof...(Axes)>& indices) {
+  static void getLocalBinIndices(
+      const Point& point, const std::tuple<Axes...>& axes,
+      std::array<std::size_t, sizeof...(Axes)>& indices) {
     const auto& thisAxis = std::get<0u>(axes);
     indices.at(0u) = thisAxis.getBin(point[0u]);
   }
 
   template <class... Axes>
-  static void getLocalBinIndices(size_t& bin,
-                                 const std::tuple<Axes...>& /*axes*/,
-                                 size_t& area,
-                                 std::array<size_t, sizeof...(Axes)>& indices) {
+  static void getLocalBinIndices(
+      std::size_t& bin, const std::tuple<Axes...>& /*axes*/, std::size_t& area,
+      std::array<std::size_t, sizeof...(Axes)>& indices) {
     // make sure to account for under-/overflow bins
     indices.at(0u) = bin / area;
     bin %= area;
@@ -366,21 +366,21 @@ struct grid_helper_impl<0u> {
   template <class... Axes>
   static void getLowerLeftBinEdge(
       std::array<ActsScalar, sizeof...(Axes)>& llEdge,
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     llEdge.at(0u) = std::get<0u>(axes).getBinLowerBound(localIndices.at(0u));
   }
 
   template <class... Axes>
   static void getLowerLeftBinIndices(
-      std::array<size_t, sizeof...(Axes)>& localIndices,
+      std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     localIndices.at(0u) = std::get<0u>(axes).wrapBin(localIndices.at(0u) - 1);
   }
 
   template <class... Axes>
   static void getNBins(const std::tuple<Axes...>& axes,
-                       std::array<size_t, sizeof...(Axes)>& nBinsArray) {
+                       std::array<std::size_t, sizeof...(Axes)>& nBinsArray) {
     // by convention getNBins does not include under-/overflow bins
     nBinsArray[0u] = std::get<0u>(axes).getNBins();
   }
@@ -394,14 +394,14 @@ struct grid_helper_impl<0u> {
   template <class... Axes>
   static void getUpperRightBinEdge(
       std::array<ActsScalar, sizeof...(Axes)>& urEdge,
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     urEdge.at(0u) = std::get<0u>(axes).getBinUpperBound(localIndices.at(0u));
   }
 
   template <class... Axes>
   static void getUpperRightBinIndices(
-      std::array<size_t, sizeof...(Axes)>& localIndices,
+      std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     localIndices.at(0u) = std::get<0u>(axes).wrapBin(localIndices.at(0u) + 1);
   }
@@ -431,11 +431,11 @@ struct grid_helper_impl<0u> {
 
   template <class... Axes>
   static void neighborHoodIndices(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       std::pair<int, int> sizes, const std::tuple<Axes...>& axes,
       std::array<NeighborHoodIndices, sizeof...(Axes)>& neighborIndices) {
     // ask 0-th axis
-    size_t locIdx = localIndices.at(0u);
+    std::size_t locIdx = localIndices.at(0u);
     NeighborHoodIndices locNeighbors =
         std::get<0u>(axes).neighborHoodIndices(locIdx, sizes);
     neighborIndices.at(0u) = locNeighbors;
@@ -443,40 +443,40 @@ struct grid_helper_impl<0u> {
 
   template <class... Axes>
   static void neighborHoodIndices(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       std::array<std::pair<int, int>, sizeof...(Axes)> sizes,
       const std::tuple<Axes...>& axes,
       std::array<NeighborHoodIndices, sizeof...(Axes)>& neighborIndices) {
     // ask 0-th axis
-    size_t locIdx = localIndices.at(0u);
+    std::size_t locIdx = localIndices.at(0u);
     NeighborHoodIndices locNeighbors =
         std::get<0u>(axes).neighborHoodIndices(locIdx, sizes.at(0u));
     neighborIndices.at(0u) = locNeighbors;
   }
 
   template <class... Axes>
-  static void exteriorBinIndices(std::array<size_t, sizeof...(Axes)>& idx,
+  static void exteriorBinIndices(std::array<std::size_t, sizeof...(Axes)>& idx,
                                  std::array<bool, sizeof...(Axes)> isExterior,
-                                 std::set<size_t>& combinations,
+                                 std::set<std::size_t>& combinations,
                                  const std::tuple<Axes...>& axes) {
     // For each exterior bin on this axis, we will do this
-    auto recordExteriorBin = [&](size_t i) {
+    auto recordExteriorBin = [&](std::size_t i) {
       idx.at(0u) = i;
       // at this point, combinations are complete: save the global bin
-      size_t bin = 0, area = 1;
+      std::size_t bin = 0, area = 1;
       grid_helper_impl<sizeof...(Axes) - 1>::getGlobalBin(idx, axes, bin, area);
       combinations.insert(bin);
     };
 
     // The first and last bins on this axis are exterior by definition
-    for (size_t i :
-         {static_cast<size_t>(0), std::get<0u>(axes).getNBins() + 1}) {
+    for (std::size_t i :
+         {static_cast<std::size_t>(0), std::get<0u>(axes).getNBins() + 1}) {
       recordExteriorBin(i);
     }
 
     // If no other axis is on an exterior index, stop here
     bool otherAxisExterior = false;
-    for (size_t N = 1; N < sizeof...(Axes); ++N) {
+    for (std::size_t N = 1; N < sizeof...(Axes); ++N) {
       otherAxisExterior = otherAxisExterior | isExterior[N];
     }
     if (!otherAxisExterior) {
@@ -484,7 +484,7 @@ struct grid_helper_impl<0u> {
     }
 
     // Otherwise, we're on a grid border: iterate over all the other indices
-    for (size_t i = 1; i <= std::get<0u>(axes).getNBins(); ++i) {
+    for (std::size_t i = 1; i <= std::get<0u>(axes).getNBins(); ++i) {
       recordExteriorBin(i);
     }
   }
@@ -506,7 +506,7 @@ struct grid_helper {
   ///       along any axis).
   template <class... Axes>
   static GlobalNeighborHoodIndices<sizeof...(Axes)> closestPointsIndices(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     // get neighboring bins, but only increment.
     return neighborHoodIndices(localIndices, std::make_pair(0, 1), axes);
@@ -523,10 +523,10 @@ struct grid_helper {
   ///      under-/overflow bins).
   template <class... Axes>
   static std::array<ActsScalar, sizeof...(Axes)> getBinCenter(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     std::array<ActsScalar, sizeof...(Axes)> center{};
-    constexpr size_t MAX = sizeof...(Axes) - 1;
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
     grid_helper_impl<MAX>::getBinCenter(center, localIndices, axes);
 
     return center;
@@ -543,12 +543,12 @@ struct grid_helper {
   /// @pre All local bin indices must be a valid index for the corresponding
   ///      axis (including the under-/overflow bin for this axis).
   template <class... Axes>
-  static size_t getGlobalBin(
-      const std::array<size_t, sizeof...(Axes)>& localBins,
+  static std::size_t getGlobalBin(
+      const std::array<std::size_t, sizeof...(Axes)>& localBins,
       const std::tuple<Axes...>& axes) {
-    constexpr size_t MAX = sizeof...(Axes) - 1;
-    size_t area = 1;
-    size_t bin = 0;
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
+    std::size_t area = 1;
+    std::size_t bin = 0;
 
     grid_helper_impl<MAX>::getGlobalBin(localBins, axes, bin, area);
 
@@ -570,10 +570,10 @@ struct grid_helper {
   ///      dimensions where d is the number of axis objects in the tuple.
   /// @note This could be a under-/overflow bin along one or more axes.
   template <class Point, class... Axes>
-  static std::array<size_t, sizeof...(Axes)> getLocalBinIndices(
+  static std::array<std::size_t, sizeof...(Axes)> getLocalBinIndices(
       const Point& point, const std::tuple<Axes...>& axes) {
-    constexpr size_t MAX = sizeof...(Axes) - 1;
-    std::array<size_t, sizeof...(Axes)> indices{};
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
+    std::array<std::size_t, sizeof...(Axes)> indices{};
 
     grid_helper_impl<MAX>::getLocalBinIndices(point, axes, indices);
 
@@ -591,11 +591,11 @@ struct grid_helper {
   ///
   /// @note Local bin indices can contain under-/overflow bins along any axis.
   template <class... Axes>
-  static std::array<size_t, sizeof...(Axes)> getLocalBinIndices(
-      size_t bin, const std::tuple<Axes...>& axes) {
-    constexpr size_t MAX = sizeof...(Axes) - 1;
-    size_t area = 1;
-    std::array<size_t, sizeof...(Axes)> indices{};
+  static std::array<std::size_t, sizeof...(Axes)> getLocalBinIndices(
+      std::size_t bin, const std::tuple<Axes...>& axes) {
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
+    std::size_t area = 1;
+    std::array<std::size_t, sizeof...(Axes)> indices{};
 
     grid_helper_impl<MAX>::getLocalBinIndices(bin, axes, area, indices);
 
@@ -613,10 +613,10 @@ struct grid_helper {
   ///      underflow bins).
   template <class... Axes>
   static std::array<ActsScalar, sizeof...(Axes)> getLowerLeftBinEdge(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     std::array<ActsScalar, sizeof...(Axes)> llEdge{};
-    constexpr size_t MAX = sizeof...(Axes) - 1;
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
     grid_helper_impl<MAX>::getLowerLeftBinEdge(llEdge, localIndices, axes);
 
     return llEdge;
@@ -636,10 +636,10 @@ struct grid_helper {
   /// lower-left neighbor which simply means that all local bin indices are
   /// decremented by one.
   template <class... Axes>
-  static std::array<size_t, sizeof...(Axes)> getLowerLeftBinIndices(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+  static std::array<std::size_t, sizeof...(Axes)> getLowerLeftBinIndices(
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
-    constexpr size_t MAX = sizeof...(Axes) - 1;
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
     auto llIndices = localIndices;
     grid_helper_impl<MAX>::getLowerLeftBinIndices(llIndices, axes);
 
@@ -655,9 +655,9 @@ struct grid_helper {
   ///
   /// @note This does not include under-/overflow bins along each axis.
   template <class... Axes>
-  static std::array<size_t, sizeof...(Axes)> getNBins(
+  static std::array<std::size_t, sizeof...(Axes)> getNBins(
       const std::tuple<Axes...>& axes) {
-    std::array<size_t, sizeof...(Axes)> nBinsArray{};
+    std::array<std::size_t, sizeof...(Axes)> nBinsArray{};
     grid_helper_impl<sizeof...(Axes) - 1>::getNBins(axes, nBinsArray);
     return nBinsArray;
   }
@@ -687,10 +687,10 @@ struct grid_helper {
   ///      overflow bins).
   template <class... Axes>
   static std::array<ActsScalar, sizeof...(Axes)> getUpperRightBinEdge(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
     std::array<ActsScalar, sizeof...(Axes)> urEdge{};
-    constexpr size_t MAX = sizeof...(Axes) - 1;
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
     grid_helper_impl<MAX>::getUpperRightBinEdge(urEdge, localIndices, axes);
 
     return urEdge;
@@ -710,10 +710,10 @@ struct grid_helper {
   /// upper-right neighbor which simply means that all local bin indices are
   /// incremented by one.
   template <class... Axes>
-  static std::array<size_t, sizeof...(Axes)> getUpperRightBinIndices(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+  static std::array<std::size_t, sizeof...(Axes)> getUpperRightBinIndices(
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       const std::tuple<Axes...>& axes) {
-    constexpr size_t MAX = sizeof...(Axes) - 1;
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
     auto urIndices = localIndices;
     grid_helper_impl<MAX>::getUpperRightBinIndices(urIndices, axes);
 
@@ -781,9 +781,10 @@ struct grid_helper {
   ///
   template <class... Axes>
   static GlobalNeighborHoodIndices<sizeof...(Axes)> neighborHoodIndices(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
-      std::pair<size_t, size_t> sizes, const std::tuple<Axes...>& axes) {
-    constexpr size_t MAX = sizeof...(Axes) - 1;
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
+      std::pair<std::size_t, std::size_t> sizes,
+      const std::tuple<Axes...>& axes) {
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
 
     // length N array which contains local neighbors based on size par
     std::array<NeighborHoodIndices, sizeof...(Axes)> neighborIndices{};
@@ -792,7 +793,7 @@ struct grid_helper {
                                                neighborIndices);
 
     // Query the number of bins
-    std::array<size_t, sizeof...(Axes)> nBinsArray = getNBins(axes);
+    std::array<std::size_t, sizeof...(Axes)> nBinsArray = getNBins(axes);
 
     // Produce iterator of global indices
     return GlobalNeighborHoodIndices(neighborIndices, nBinsArray);
@@ -800,8 +801,8 @@ struct grid_helper {
 
   template <class... Axes>
   static GlobalNeighborHoodIndices<sizeof...(Axes)> neighborHoodIndices(
-      const std::array<size_t, sizeof...(Axes)>& localIndices, size_t size,
-      const std::tuple<Axes...>& axes) {
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
+      std::size_t size, const std::tuple<Axes...>& axes) {
     return neighborHoodIndices(localIndices, std::make_pair(int(-size), size),
                                axes);
   }
@@ -829,10 +830,10 @@ struct grid_helper {
   ///
   template <class... Axes>
   static GlobalNeighborHoodIndices<sizeof...(Axes)> neighborHoodIndices(
-      const std::array<size_t, sizeof...(Axes)>& localIndices,
+      const std::array<std::size_t, sizeof...(Axes)>& localIndices,
       std::array<std::pair<int, int>, sizeof...(Axes)>& sizes,
       const std::tuple<Axes...>& axes) {
-    constexpr size_t MAX = sizeof...(Axes) - 1;
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
 
     // length N array which contains local neighbors based on size par
     std::array<NeighborHoodIndices, sizeof...(Axes)> neighborIndices{};
@@ -841,7 +842,7 @@ struct grid_helper {
                                                neighborIndices);
 
     // Query the number of bins
-    std::array<size_t, sizeof...(Axes)> nBinsArray = getNBins(axes);
+    std::array<std::size_t, sizeof...(Axes)> nBinsArray = getNBins(axes);
 
     // Produce iterator of global indices
     return GlobalNeighborHoodIndices(neighborIndices, nBinsArray);
@@ -853,12 +854,13 @@ struct grid_helper {
   /// @param  [in] axes         actual axis objects spanning the grid
   /// @return set of global bin indices for all over- and underflow bins
   template <class... Axes>
-  static std::set<size_t> exteriorBinIndices(const std::tuple<Axes...>& axes) {
-    constexpr size_t MAX = sizeof...(Axes) - 1;
+  static std::set<std::size_t> exteriorBinIndices(
+      const std::tuple<Axes...>& axes) {
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
 
-    std::array<size_t, sizeof...(Axes)> idx{};
+    std::array<std::size_t, sizeof...(Axes)> idx{};
     std::array<bool, sizeof...(Axes)> isExterior{};
-    std::set<size_t> combinations;
+    std::set<std::size_t> combinations;
     grid_helper_impl<MAX>::exteriorBinIndices(idx, isExterior, combinations,
                                               axes);
 
@@ -880,7 +882,7 @@ struct grid_helper {
   ///      dimensions where d is the number of axis objects in the tuple.
   template <class Point, class... Axes>
   static bool isInside(const Point& position, const std::tuple<Axes...>& axes) {
-    constexpr size_t MAX = sizeof...(Axes) - 1;
+    constexpr std::size_t MAX = sizeof...(Axes) - 1;
     return grid_helper_impl<MAX>::isInside(position, axes);
   }
 };
diff --git a/Core/include/Acts/Utilities/detail/interpolation_impl.hpp b/Core/include/Acts/Utilities/detail/interpolation_impl.hpp
index 3d4fca39936..57890f3a1f5 100644
--- a/Core/include/Acts/Utilities/detail/interpolation_impl.hpp
+++ b/Core/include/Acts/Utilities/detail/interpolation_impl.hpp
@@ -63,16 +63,16 @@ struct can_interpolate {
 /// @brief determine number of dimension from power of 2
 ///
 /// @tparam N power of 2
-template <size_t N>
+template <std::size_t N>
 struct get_dimension {
   /// exponent @c d such that \f$2^d = N \f$
-  static constexpr size_t value = get_dimension<(N >> 1)>::value + 1u;
+  static constexpr std::size_t value = get_dimension<(N >> 1)>::value + 1u;
 };
 
 /// @cond
 template <>
 struct get_dimension<2u> {
-  static constexpr size_t value = 1u;
+  static constexpr std::size_t value = 1u;
 };
 /// @endcond
 
@@ -94,14 +94,14 @@ struct get_dimension<2u> {
 /// - @c N is the number of hyper box corners which is \f$2^d\f$ where \f$d\f$
 /// is the dimensionality of the hyper box. The dimensionality must be
 /// consistent with the provided @c Point types.
-template <typename T, class Point1, class Point2, class Point3, size_t D,
-          size_t N>
+template <typename T, class Point1, class Point2, class Point3, std::size_t D,
+          std::size_t N>
 struct interpolate_impl;
 
 /// @cond
 // recursive implementation of linear interpolation in multiple dimensions
-template <typename T, class Point1, class Point2, class Point3, size_t D,
-          size_t N>
+template <typename T, class Point1, class Point2, class Point3, std::size_t D,
+          std::size_t N>
 struct interpolate_impl {
   static T run(const Point1& pos, const Point2& lowerLeft,
                const Point3& upperRight, const std::array<T, N>& fields) {
@@ -109,7 +109,7 @@ struct interpolate_impl {
     const double f = (pos[D] - lowerLeft[D]) / (upperRight[D] - lowerLeft[D]);
 
     std::array<T, (N >> 1)> newFields{};
-    for (size_t i = 0; i < N / 2; ++i) {
+    for (std::size_t i = 0; i < N / 2; ++i) {
       newFields.at(i) = (1 - f) * fields.at(2 * i) + f * fields.at(2 * i + 1);
     }
 
@@ -119,7 +119,7 @@ struct interpolate_impl {
 };
 
 // simple linear interpolation in 1D
-template <typename T, class Point1, class Point2, class Point3, size_t D>
+template <typename T, class Point1, class Point2, class Point3, std::size_t D>
 struct interpolate_impl<T, Point1, Point2, Point3, D, 2u> {
   static T run(const Point1& pos, const Point2& lowerLeft,
                const Point3& upperRight, const std::array<T, 2u>& fields) {
diff --git a/Core/include/Acts/Visualization/EventDataView3D.hpp b/Core/include/Acts/Visualization/EventDataView3D.hpp
index 7f162218cd2..d7de8e94eda 100644
--- a/Core/include/Acts/Visualization/EventDataView3D.hpp
+++ b/Core/include/Acts/Visualization/EventDataView3D.hpp
@@ -69,8 +69,8 @@ struct EventDataView3D {
   /// @param lposition The local anker point of the ellipse
   /// @param transform The transform to global
   static inline std::vector<Vector3> createEllipse(
-      double lambda0, double lambda1, double theta, size_t lseg, double offset,
-      const Vector2& lposition = Vector2(0., 0.),
+      double lambda0, double lambda1, double theta, std::size_t lseg,
+      double offset, const Vector2& lposition = Vector2(0., 0.),
       const Transform3& transform = Transform3::Identity()) {
     double ctheta = std::cos(theta);
     double stheta = std::sin(theta);
@@ -82,7 +82,7 @@ struct EventDataView3D {
     std::vector<Vector3> ellipse;
     ellipse.reserve(lseg);
     double thetaStep = 2 * M_PI / lseg;
-    for (size_t it = 0; it < lseg; ++it) {
+    for (std::size_t it = 0; it < lseg; ++it) {
       double phi = -M_PI + it * thetaStep;
       double cphi = std::cos(phi);
       double sphi = std::sin(phi);
@@ -222,7 +222,8 @@ struct EventDataView3D {
   template <typename traj_t>
   static void drawMultiTrajectory(
       IVisualization3D& helper, const traj_t& multiTraj,
-      const size_t& entryIndex, const GeometryContext& gctx = GeometryContext(),
+      const std::size_t& entryIndex,
+      const GeometryContext& gctx = GeometryContext(),
       double momentumScale = 1., double locErrorScale = 1.,
       double angularErrorScale = 1.,
       const ViewConfig& surfaceConfig = s_viewSensitive,
diff --git a/Core/include/Acts/Visualization/IVisualization3D.hpp b/Core/include/Acts/Visualization/IVisualization3D.hpp
index ca351f5ad76..6daf34c4e2f 100644
--- a/Core/include/Acts/Visualization/IVisualization3D.hpp
+++ b/Core/include/Acts/Visualization/IVisualization3D.hpp
@@ -24,7 +24,7 @@ namespace Acts {
 /// conform to.
 class IVisualization3D {
  public:
-  using FaceType = std::vector<size_t>;
+  using FaceType = std::vector<std::size_t>;
 
   /// Draw a vertex at a given location and a color.
   /// @param vtx The vertex position
diff --git a/Core/include/Acts/Visualization/ObjVisualization3D.hpp b/Core/include/Acts/Visualization/ObjVisualization3D.hpp
index f8271ccf194..a915ecadee8 100644
--- a/Core/include/Acts/Visualization/ObjVisualization3D.hpp
+++ b/Core/include/Acts/Visualization/ObjVisualization3D.hpp
@@ -38,7 +38,7 @@ class ObjVisualization3D : public IVisualization3D {
   using VertexType = Eigen::Matrix<ValueType, 3, 1>;
 
   /// Type of a line
-  using LineType = std::pair<size_t, size_t>;
+  using LineType = std::pair<std::size_t, std::size_t>;
 
   /// Constructor that allows to set scalor and precision
   /// @param prec The output precision with std::setprecision
@@ -84,9 +84,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<size_t, ColorRGB> m_lineColors;
-  std::map<size_t, ColorRGB> m_vertexColors;
-  std::map<size_t, ColorRGB> m_faceColors;
+  std::map<std::size_t, ColorRGB> m_lineColors;
+  std::map<std::size_t, ColorRGB> m_vertexColors;
+  std::map<std::size_t, ColorRGB> m_faceColors;
 };
 
 #ifndef DOXYGEN
diff --git a/Core/include/Acts/Visualization/PlyVisualization3D.hpp b/Core/include/Acts/Visualization/PlyVisualization3D.hpp
index c3c3fe9b0d5..b28783a0bcd 100644
--- a/Core/include/Acts/Visualization/PlyVisualization3D.hpp
+++ b/Core/include/Acts/Visualization/PlyVisualization3D.hpp
@@ -62,7 +62,7 @@ class PlyVisualization3D : public IVisualization3D {
  private:
   std::vector<std::pair<VertexType, ColorRGB>> m_vertices;
   std::vector<FaceType> m_faces;
-  std::vector<std::pair<std::pair<size_t, size_t>, ColorRGB>> m_edges;
+  std::vector<std::pair<std::pair<std::size_t, std::size_t>, ColorRGB>> m_edges;
 };
 
 #ifndef DOXYGEN
diff --git a/Core/include/Acts/Visualization/detail/ObjVisualization3D.ipp b/Core/include/Acts/Visualization/detail/ObjVisualization3D.ipp
index f466098dc29..51a0854b85e 100644
--- a/Core/include/Acts/Visualization/detail/ObjVisualization3D.ipp
+++ b/Core/include/Acts/Visualization/detail/ObjVisualization3D.ipp
@@ -61,7 +61,7 @@ void ObjVisualization3D<T>::faces(const std::vector<Vector3>& vtxs,
       } else {
         FaceType rawFace = face;
         std::transform(rawFace.begin(), rawFace.end(), rawFace.begin(),
-                       [&](size_t& iv) { return (iv + vtxoffs); });
+                       [&](std::size_t& iv) { return (iv + vtxoffs); });
         m_faces.push_back(rawFace);
       }
     }
@@ -117,7 +117,7 @@ void ObjVisualization3D<T>::write(std::ostream& os, std::ostream& mos) const {
     return std::string("usemtl ") + materialName;
   };
 
-  size_t iv = 0;
+  std::size_t iv = 0;
   ColorRGB lastVertexColor = {0, 0, 0};
   for (const VertexType& vtx : m_vertices) {
     if (m_vertexColors.find(iv) != m_vertexColors.end()) {
@@ -133,7 +133,7 @@ void ObjVisualization3D<T>::write(std::ostream& os, std::ostream& mos) const {
        << m_outputScalor * vtx.z() << "\n";
     ++iv;
   }
-  size_t il = 0;
+  std::size_t il = 0;
   ColorRGB lastLineColor = {0, 0, 0};
   for (const LineType& ln : m_lines) {
     if (m_lineColors.find(il) != m_lineColors.end()) {
@@ -146,7 +146,7 @@ void ObjVisualization3D<T>::write(std::ostream& os, std::ostream& mos) const {
     os << "l " << ln.first + 1 << " " << ln.second + 1 << "\n";
     ++il;
   }
-  size_t is = 0;
+  std::size_t is = 0;
   ColorRGB lastFaceColor = {0, 0, 0};
   for (const FaceType& fc : m_faces) {
     if (m_faceColors.find(is) != m_faceColors.end()) {
@@ -157,7 +157,7 @@ void ObjVisualization3D<T>::write(std::ostream& os, std::ostream& mos) const {
       }
     }
     os << "f";
-    for (size_t i = 0; i < fc.size(); i++) {
+    for (std::size_t i = 0; i < fc.size(); i++) {
       os << " " << fc[i] + 1;
     }
     os << "\n";
diff --git a/Core/include/Acts/Visualization/detail/PlyVisualization3D.ipp b/Core/include/Acts/Visualization/detail/PlyVisualization3D.ipp
index 46b98c63ce8..b97dbde0fc9 100644
--- a/Core/include/Acts/Visualization/detail/PlyVisualization3D.ipp
+++ b/Core/include/Acts/Visualization/detail/PlyVisualization3D.ipp
@@ -34,9 +34,9 @@ template <typename T>
 void PlyVisualization3D<T>::line(const Vector3& a, const Vector3& b,
                                  ColorRGB color) {
   vertex(a, color);
-  size_t idx_a = m_vertices.size() - 1;
+  std::size_t idx_a = m_vertices.size() - 1;
   vertex(b, color);
-  size_t idx_b = m_vertices.size() - 1;
+  std::size_t idx_b = m_vertices.size() - 1;
   m_edges.emplace_back(std::make_pair(std::make_pair(idx_a, idx_b), color));
 }
 
@@ -80,14 +80,15 @@ void PlyVisualization3D<T>::write(std::ostream& os) const {
 
   for (const FaceType& fc : m_faces) {
     os << fc.size();
-    for (size_t i = 0; i < fc.size(); i++) {
+    for (std::size_t i = 0; i < fc.size(); i++) {
       os << " " << fc[i];
     }
     os << "\n";
   }
 
-  for (const std::pair<std::pair<size_t, size_t>, ColorRGB>& edge : m_edges) {
-    std::pair<size_t, size_t> idxs = edge.first;
+  for (const std::pair<std::pair<std::size_t, std::size_t>, ColorRGB>& edge :
+       m_edges) {
+    std::pair<std::size_t, std::size_t> idxs = edge.first;
     os << idxs.first << " " << idxs.second << " ";
     os << edge.second[0] << " " << edge.second[1] << " " << edge.second[2]
        << "\n";
diff --git a/Core/src/Detector/DetectorVolume.cpp b/Core/src/Detector/DetectorVolume.cpp
index c3d4f3294bd..c06663e138c 100644
--- a/Core/src/Detector/DetectorVolume.cpp
+++ b/Core/src/Detector/DetectorVolume.cpp
@@ -253,7 +253,7 @@ void Acts::Experimental::DetectorVolume::assignSurfaceCandidatesUpdator(
 }
 
 Acts::Extent Acts::Experimental::DetectorVolume::extent(
-    const GeometryContext& gctx, size_t nseg) const {
+    const GeometryContext& gctx, std::size_t nseg) const {
   Extent volumeExtent;
   for (const auto* p : portals()) {
     volumeExtent.extend(
@@ -263,7 +263,7 @@ Acts::Extent Acts::Experimental::DetectorVolume::extent(
 }
 
 bool Acts::Experimental::DetectorVolume::checkContainment(
-    const GeometryContext& gctx, size_t nseg) const {
+    const GeometryContext& gctx, std::size_t nseg) const {
   // Create the volume extent
   auto volumeExtent = extent(gctx, nseg);
   // Check surfaces
diff --git a/Core/src/Detector/LayerStructureBuilder.cpp b/Core/src/Detector/LayerStructureBuilder.cpp
index c0d6ca042da..8ffd6a9a6d9 100644
--- a/Core/src/Detector/LayerStructureBuilder.cpp
+++ b/Core/src/Detector/LayerStructureBuilder.cpp
@@ -52,7 +52,7 @@ template <Acts::detail::AxisBoundaryType aType>
 Acts::Experimental::SurfaceCandidatesUpdator createUpdator(
     const Acts::GeometryContext& gctx,
     std::vector<std::shared_ptr<Acts::Surface>> lSurfaces,
-    std::vector<size_t> assignToAll,
+    std::vector<std::size_t> assignToAll,
     const Acts::Experimental::ProtoBinning& binning) {
   // The surface candidate updator & a generator for polyhedrons
   Acts::Experimental::SurfaceCandidatesUpdator sfCandidates;
@@ -95,7 +95,7 @@ template <Acts::detail::AxisBoundaryType aType,
 Acts::Experimental::SurfaceCandidatesUpdator createUpdator(
     const Acts::GeometryContext& gctx,
     const std::vector<std::shared_ptr<Acts::Surface>>& lSurfaces,
-    const std::vector<size_t>& assignToAll,
+    const std::vector<std::size_t>& assignToAll,
     const Acts::Experimental::ProtoBinning& aBinning,
     const Acts::Experimental::ProtoBinning& bBinning) {
   // The surface candidate updator & a generator for polyhedrons
@@ -175,7 +175,7 @@ Acts::Experimental::LayerStructureBuilder::construct(
 
   // Check whether support structure is scheduled to be built, and if so
   // collect those that should be assigned to all bins
-  std::vector<size_t> assignToAll = {};
+  std::vector<std::size_t> assignToAll = {};
   if (!m_cfg.supports.empty()) {
     ACTS_DEBUG("Adding " << m_cfg.supports.size() << " support structures.")
     // The surface candidate updator
diff --git a/Core/src/Detector/Portal.cpp b/Core/src/Detector/Portal.cpp
index a333c99ed5f..680be3a664b 100644
--- a/Core/src/Detector/Portal.cpp
+++ b/Core/src/Detector/Portal.cpp
@@ -111,7 +111,7 @@ void Acts::Experimental::Portal::assignDetectorVolumeUpdator(
   if (m_volumeUpdators[0u].connected() && m_volumeUpdators[1u].connected()) {
     throw std::runtime_error("Portal: portal already has links on both sides.");
   }
-  size_t idx = m_volumeUpdators[0u].connected() ? 1u : 0u;
+  std::size_t idx = m_volumeUpdators[0u].connected() ? 1u : 0u;
   m_volumeUpdators[idx] = std::move(dVolumeUpdator);
   m_attachedVolumes[idx] = std::move(attachedVolumes);
 }
diff --git a/Core/src/Detector/detail/CylindricalDetectorHelper.cpp b/Core/src/Detector/detail/CylindricalDetectorHelper.cpp
index 8db6d0bbc8c..aefefc91765 100644
--- a/Core/src/Detector/detail/CylindricalDetectorHelper.cpp
+++ b/Core/src/Detector/detail/CylindricalDetectorHelper.cpp
@@ -510,7 +510,7 @@ Acts::Experimental::detail::CylindricalDetectorHelper::connectInR(
       // - if the volume doesn't have an inner portal, indices need to
       //   be shifted by -1 to update the correct index, that's the case for
       //   size 3 and 5 for portals
-      size_t nPortals = iv->portals().size();
+      std::size_t nPortals = iv->portals().size();
       bool innerPresent = (nPortals == 3u || nPortals == 5u);
       int iOffset = (innerPresent && i > 2u) ? -1 : 0;
       ACTS_VERBOSE("-- update portal with index "
@@ -648,7 +648,7 @@ Acts::Experimental::detail::CylindricalDetectorHelper::connectInZ(
   ActsScalar avgPhi = refValues[CylinderVolumeBounds::BoundValues::eAveragePhi];
 
   // Check if inner cylinder and sectors are present by the number of portals
-  size_t nPortals = volumes[volumes.size() - 1u]->portals().size();
+  std::size_t nPortals = volumes[volumes.size() - 1u]->portals().size();
   bool innerPresent = (nPortals != 3u && nPortals != 5u);
   bool sectorsPresent = nPortals > 4u;
 
@@ -743,7 +743,7 @@ Acts::Experimental::detail::CylindricalDetectorHelper::connectInPhi(
   DetectorComponent::PortalContainer dShell;
 
   // Check if inner cylinder and sectors are present by the number of portals
-  size_t nPortals = volumes[volumes.size() - 1u]->portals().size();
+  std::size_t nPortals = volumes[volumes.size() - 1u]->portals().size();
   bool innerPresent = (nPortals != 3u && nPortals != 5u);
 
   Transform3 refTransform = volumes[0u]->transform(gctx);
diff --git a/Core/src/Detector/detail/SupportHelper.cpp b/Core/src/Detector/detail/SupportHelper.cpp
index d01088011a4..fdd487fa59c 100644
--- a/Core/src/Detector/detail/SupportHelper.cpp
+++ b/Core/src/Detector/detail/SupportHelper.cpp
@@ -124,7 +124,7 @@ Acts::Experimental::detail::SupportHelper::discSupport(
 
 void Acts::Experimental::detail::SupportHelper::addSupport(
     std::vector<std::shared_ptr<Surface>>& layerSurfaces,
-    std::vector<size_t>& assignToAll, const Extent& layerExtent,
+    std::vector<std::size_t>& assignToAll, const Extent& layerExtent,
     Surface::SurfaceType layerRepresentation,
     const std::array<ActsScalar, 5u>& layerSupportValues,
     std::optional<Transform3> layerTransform, unsigned int supportSplits) {
diff --git a/Core/src/Digitization/CartesianSegmentation.cpp b/Core/src/Digitization/CartesianSegmentation.cpp
index 6b1e0715f58..4b9470a4f85 100644
--- a/Core/src/Digitization/CartesianSegmentation.cpp
+++ b/Core/src/Digitization/CartesianSegmentation.cpp
@@ -22,8 +22,8 @@
 #include <utility>
 
 Acts::CartesianSegmentation::CartesianSegmentation(
-    const std::shared_ptr<const PlanarBounds>& mBounds, size_t numCellsX,
-    size_t numCellsY)
+    const std::shared_ptr<const PlanarBounds>& mBounds, std::size_t numCellsX,
+    std::size_t numCellsY)
     : m_activeBounds(mBounds), m_binUtility(nullptr) {
   auto mutableBinUtility = std::make_shared<BinUtility>(
       numCellsX, -mBounds->boundingBox().halfLengthX(),
@@ -134,7 +134,7 @@ void Acts::CartesianSegmentation::createSegmentationSurfaces(
   // boundarySurfaces
   segmentationSurfacesX.reserve(m_binUtility->bins(0));
   // create and fill them
-  for (size_t ibinx = 0; ibinx <= m_binUtility->bins(0); ++ibinx) {
+  for (std::size_t ibinx = 0; ibinx <= m_binUtility->bins(0); ++ibinx) {
     // the current step x position
     double cPosX =
         -m_activeBounds->boundingBox().halfLengthX() + ibinx * pitchX;
@@ -194,7 +194,7 @@ void Acts::CartesianSegmentation::createSegmentationSurfaces(
   // reserve, it's always (number of bins-1) as the boundaries are within the
   // boundarySurfaces
   segmentationSurfacesY.reserve(m_binUtility->bins(1));
-  for (size_t ibiny = 0; ibiny <= m_binUtility->bins(1); ++ibiny) {
+  for (std::size_t ibiny = 0; ibiny <= m_binUtility->bins(1); ++ibiny) {
     // the position of the bin surface
     double binPosY =
         -m_activeBounds->boundingBox().halfLengthY() + ibiny * pitchY;
diff --git a/Core/src/Digitization/DigitizationModule.cpp b/Core/src/Digitization/DigitizationModule.cpp
index 12b02ae66fa..7a15809c05f 100644
--- a/Core/src/Digitization/DigitizationModule.cpp
+++ b/Core/src/Digitization/DigitizationModule.cpp
@@ -78,8 +78,8 @@ Acts::SurfacePtrVector Acts::DigitizationModule::stepSurfaces(
   const DigitizationCell endCell = m_segmentation->cell(end);
 
   // go along x - first with the naive binning (i.e. w.o lorentz angle)
-  size_t sCellX = startCell.channel0;
-  size_t eCellX = endCell.channel0;
+  std::size_t sCellX = startCell.channel0;
+  std::size_t eCellX = endCell.channel0;
   if (sCellX > eCellX) {
     std::swap(sCellX, eCellX);
   }
@@ -89,8 +89,8 @@ Acts::SurfacePtrVector Acts::DigitizationModule::stepSurfaces(
   }
   ++eCellX;  // @TODO check : safe because we can assume to have eCell+1
   // the surfaces along Y are easy, just the bin surfaces
-  size_t sCellY = startCell.channel1;
-  size_t eCellY = endCell.channel1;
+  std::size_t sCellY = startCell.channel1;
+  std::size_t eCellY = endCell.channel1;
   if (sCellY > eCellY) {
     std::swap(sCellY, eCellY);
   }
diff --git a/Core/src/Digitization/PlanarModuleStepper.cpp b/Core/src/Digitization/PlanarModuleStepper.cpp
index 1a2d40b1b34..696a6dddfa6 100644
--- a/Core/src/Digitization/PlanarModuleStepper.cpp
+++ b/Core/src/Digitization/PlanarModuleStepper.cpp
@@ -87,7 +87,7 @@ std::vector<Acts::DigitizationStep> Acts::PlanarModuleStepper::cellSteps(
   // intersect them - fast exit for cases where
   // readout and counter readout are hit
   Vector3 intersection3D(moduleIntersection.x(), moduleIntersection.y(), 0.);
-  size_t attempts = 0;
+  std::size_t attempts = 0;
   // the collected intersections
   std::vector<Acts::Intersection3D> boundaryIntersections;
   // run them - and check for the fast exit
diff --git a/Core/src/EventData/CorrectedTransformationFreeToBound.cpp b/Core/src/EventData/CorrectedTransformationFreeToBound.cpp
index 4ce77b00522..d4333882c4d 100644
--- a/Core/src/EventData/CorrectedTransformationFreeToBound.cpp
+++ b/Core/src/EventData/CorrectedTransformationFreeToBound.cpp
@@ -71,7 +71,7 @@ Acts::detail::CorrectedFreeToBoundTransformer::operator()(
   }
 
   // The number of sigma points
-  size_t sampleSize = 2 * eFreeSize + 1;
+  std::size_t sampleSize = 2 * eFreeSize + 1;
   // The sampled free parameters, the weight for measurement W_m and weight for
   // covariance, W_c
   std::vector<std::tuple<FreeVector, ActsScalar, ActsScalar>> sampledFreeParams;
diff --git a/Core/src/EventData/VectorMultiTrajectory.cpp b/Core/src/EventData/VectorMultiTrajectory.cpp
index f2dd3df614e..9dfbc37a83f 100644
--- a/Core/src/EventData/VectorMultiTrajectory.cpp
+++ b/Core/src/EventData/VectorMultiTrajectory.cpp
@@ -187,7 +187,7 @@ void VectorMultiTrajectory::clear_impl() {
 }
 
 void detail_vmt::VectorMultiTrajectoryBase::Statistics::toStream(
-    std::ostream& os, size_t n) {
+    std::ostream& os, std::size_t n) {
   using namespace boost::histogram;
   using cat = axis::category<std::string>;
 
@@ -214,7 +214,7 @@ void detail_vmt::VectorMultiTrajectoryBase::Statistics::toStream(
       std::string key = column_axis.bin(c);
       auto v = h.at(c, t);
       if (key == "count") {
-        p(key, static_cast<size_t>(v));
+        p(key, static_cast<std::size_t>(v));
         continue;
       }
       p(key, v / 1024 / 1024, "M");
diff --git a/Core/src/Geometry/CuboidVolumeBuilder.cpp b/Core/src/Geometry/CuboidVolumeBuilder.cpp
index 0d0abcb0528..a795325993a 100644
--- a/Core/src/Geometry/CuboidVolumeBuilder.cpp
+++ b/Core/src/Geometry/CuboidVolumeBuilder.cpp
@@ -268,7 +268,7 @@ Acts::MutableTrackingVolumePtr Acts::CuboidVolumeBuilder::trackingVolume(
   std::vector<float> binBoundaries;
   binBoundaries.push_back(volumes[0]->center().x() -
                           m_cfg.volumeCfg[0].length.x() * 0.5);
-  for (size_t i = 0; i < volumes.size(); i++) {
+  for (std::size_t i = 0; i < volumes.size(); i++) {
     binBoundaries.push_back(volumes[i]->center().x() +
                             m_cfg.volumeCfg[i].length.x() * 0.5);
   }
diff --git a/Core/src/Geometry/CylinderLayer.cpp b/Core/src/Geometry/CylinderLayer.cpp
index 1df7c405c4b..66f7e5ecbba 100644
--- a/Core/src/Geometry/CylinderLayer.cpp
+++ b/Core/src/Geometry/CylinderLayer.cpp
@@ -72,7 +72,7 @@ void Acts::CylinderLayer::buildApproachDescriptor() {
 
     // fill in the surfaces into the vector
     std::vector<std::shared_ptr<const Surface>> aSurfaces;
-    if (bSurfaces.size() > size_t(tubeInnerCover)) {
+    if (bSurfaces.size() > std::size_t(tubeInnerCover)) {
       aSurfaces.push_back(
           bSurfaces.at(tubeInnerCover)->surfaceRepresentation().getSharedPtr());
     }
diff --git a/Core/src/Geometry/CylinderVolumeHelper.cpp b/Core/src/Geometry/CylinderVolumeHelper.cpp
index 9438919bacc..afea1979802 100644
--- a/Core/src/Geometry/CylinderVolumeHelper.cpp
+++ b/Core/src/Geometry/CylinderVolumeHelper.cpp
@@ -287,7 +287,7 @@ std::shared_ptr<Acts::TrackingVolume>
 Acts::CylinderVolumeHelper::createContainerTrackingVolume(
     const GeometryContext& gctx, const TrackingVolumeVector& volumes) const {
   // check if you have more than one volume
-  if (volumes.size() <= (size_t)1) {
+  if (volumes.size() <= (std::size_t)1) {
     ACTS_WARNING(
         "None (only one) TrackingVolume given to create container "
         "volume (min required: 2) - returning 0 ");
@@ -302,7 +302,7 @@ Acts::CylinderVolumeHelper::createContainerTrackingVolume(
   auto firstVolume = volumes.begin();
   auto lastVolume = volumes.end();
 
-  for (size_t ivol = 0; firstVolume != lastVolume; ++firstVolume, ++ivol) {
+  for (std::size_t ivol = 0; firstVolume != lastVolume; ++firstVolume, ++ivol) {
     ACTS_VERBOSE("   - volume (" << ivol
                                  << ") is : " << (*firstVolume)->volumeName());
     ACTS_VERBOSE("     at position : " << (*firstVolume)->center().x() << ", "
@@ -602,7 +602,7 @@ bool Acts::CylinderVolumeHelper::interGlueTrackingVolume(
 
     // list the volume names:
     //  and make the screen output readable
-    size_t ivol = 0;
+    std::size_t ivol = 0;
     for (auto& vol : volumes) {
       ACTS_VERBOSE("[" << ivol++ << "] - volume : " << vol->volumeName());
     }
@@ -761,14 +761,14 @@ void Acts::CylinderVolumeHelper::glueTrackingVolumes(
   const GlueVolumesDescriptor& gvDescriptorTwo =
       tvolTwo->glueVolumesDescriptor();
 
-  size_t volOneGlueVols =
+  std::size_t volOneGlueVols =
       gvDescriptorOne.glueVolumes(faceOne)
           ? gvDescriptorOne.glueVolumes(faceOne)->arrayObjects().size()
           : 0;
   ACTS_VERBOSE("GlueVolumeDescriptor of volume '"
                << tvolOne->volumeName() << "' has " << volOneGlueVols << " @ "
                << faceOne);
-  size_t volTwoGlueVols =
+  std::size_t volTwoGlueVols =
       gvDescriptorTwo.glueVolumes(faceTwo)
           ? gvDescriptorTwo.glueVolumes(faceTwo)->arrayObjects().size()
           : 0;
diff --git a/Core/src/Geometry/Extent.cpp b/Core/src/Geometry/Extent.cpp
index f580d979fe7..175607c7abb 100644
--- a/Core/src/Geometry/Extent.cpp
+++ b/Core/src/Geometry/Extent.cpp
@@ -152,7 +152,7 @@ bool Acts::Extent::constrains(BinningValue bValue) const {
   if (bValue == binValues) {
     return (m_constrains.count() > 0);
   }
-  return m_constrains.test(size_t(bValue));
+  return m_constrains.test(std::size_t(bValue));
 }
 
 bool Acts::Extent::operator==(const Extent& e) const {
@@ -174,7 +174,7 @@ bool Acts::Extent::operator==(const Extent& e) const {
 std::string Acts::Extent::toString(const std::string& indent) const {
   std::stringstream sl;
   sl << indent << "Extent in space : " << std::endl;
-  for (size_t ib = 0; ib < static_cast<size_t>(binValues); ++ib) {
+  for (std::size_t ib = 0; ib < static_cast<std::size_t>(binValues); ++ib) {
     if (constrains((BinningValue)ib)) {
       sl << indent << "  - value :" << std::setw(10) << binningValueNames()[ib]
          << " | range = [" << m_range[ib].min() << ", " << m_range[ib].max()
diff --git a/Core/src/Geometry/GenericCuboidVolumeBounds.cpp b/Core/src/Geometry/GenericCuboidVolumeBounds.cpp
index 35dea03539f..90a2418dc3f 100644
--- a/Core/src/Geometry/GenericCuboidVolumeBounds.cpp
+++ b/Core/src/Geometry/GenericCuboidVolumeBounds.cpp
@@ -37,7 +37,7 @@ Acts::GenericCuboidVolumeBounds::GenericCuboidVolumeBounds(
     const std::array<double, GenericCuboidVolumeBounds::BoundValues::eSize>&
         values) noexcept(false)
     : m_vertices() {
-  for (size_t iv = 0; iv < 8; ++iv) {
+  for (std::size_t iv = 0; iv < 8; ++iv) {
     m_vertices[iv] =
         Vector3(values[iv * 3], values[iv * 3 + 1], values[iv * 3 + 2]);
   }
@@ -46,10 +46,10 @@ Acts::GenericCuboidVolumeBounds::GenericCuboidVolumeBounds(
 
 bool Acts::GenericCuboidVolumeBounds::inside(const Acts::Vector3& gpos,
                                              double tol) const {
-  constexpr std::array<size_t, 6> vtxs = {0, 4, 0, 1, 2, 1};
+  constexpr std::array<std::size_t, 6> vtxs = {0, 4, 0, 1, 2, 1};
   // needs to be on same side, get ref
   bool ref = std::signbit((gpos - m_vertices[vtxs[0]]).dot(m_normals[0]));
-  for (size_t i = 1; i < 6; i++) {
+  for (std::size_t i = 1; i < 6; i++) {
     double dot = (gpos - m_vertices[vtxs[i]]).dot(m_normals[i]);
     if (std::signbit(dot) != ref) {
       // technically outside, but how far?
@@ -70,7 +70,7 @@ Acts::OrientedSurfaces Acts::GenericCuboidVolumeBounds::orientedSurfaces(
   // approximate cog of the volume
   Vector3 cog(0, 0, 0);
 
-  for (size_t i = 0; i < 8; i++) {
+  for (std::size_t i = 0; i < 8; i++) {
     cog += m_vertices[i];
   }
 
@@ -131,7 +131,7 @@ Acts::OrientedSurfaces Acts::GenericCuboidVolumeBounds::orientedSurfaces(
 std::ostream& Acts::GenericCuboidVolumeBounds::toStream(
     std::ostream& sl) const {
   sl << "Acts::GenericCuboidVolumeBounds: vertices (x, y, z) =\n";
-  for (size_t i = 0; i < 8; i++) {
+  for (std::size_t i = 0; i < 8; i++) {
     if (i > 0) {
       sl << ",\n";
     }
@@ -145,13 +145,13 @@ void Acts::GenericCuboidVolumeBounds::construct() noexcept(false) {
   // the normals point inwards
   Vector3 cog(0, 0, 0);
 
-  for (size_t i = 0; i < 8; i++) {
+  for (std::size_t i = 0; i < 8; i++) {
     cog += m_vertices[i];
   }
 
   cog *= 0.125;  // 1/8.
 
-  size_t idx = 0;
+  std::size_t idx = 0;
 
   auto handle_face = [&](const auto& a, const auto& b, const auto& c,
                          const auto& d) {
@@ -189,8 +189,8 @@ void Acts::GenericCuboidVolumeBounds::construct() noexcept(false) {
 std::vector<double> Acts::GenericCuboidVolumeBounds::values() const {
   std::vector<double> rvalues;
   rvalues.reserve(BoundValues::eSize);
-  for (size_t iv = 0; iv < 8; ++iv) {
-    for (size_t ic = 0; ic < 3; ++ic) {
+  for (std::size_t iv = 0; iv < 8; ++iv) {
+    for (std::size_t ic = 0; ic < 3; ++ic) {
       rvalues.push_back(m_vertices[iv][ic]);
     }
   }
@@ -210,7 +210,7 @@ Acts::Volume::BoundingBox Acts::GenericCuboidVolumeBounds::boundingBox(
   vmin = transform * m_vertices[0];
   vmax = transform * m_vertices[0];
 
-  for (size_t i = 1; i < 8; i++) {
+  for (std::size_t i = 1; i < 8; i++) {
     Vector3 vtx = transform * m_vertices[i];
     vmin = vmin.cwiseMin(vtx);
     vmax = vmax.cwiseMax(vtx);
diff --git a/Core/src/Geometry/LayerCreator.cpp b/Core/src/Geometry/LayerCreator.cpp
index f1e14190546..1f24a2573bb 100644
--- a/Core/src/Geometry/LayerCreator.cpp
+++ b/Core/src/Geometry/LayerCreator.cpp
@@ -52,8 +52,8 @@ void Acts::LayerCreator::setLogger(std::unique_ptr<const Logger> newLogger) {
 
 Acts::MutableLayerPtr Acts::LayerCreator::cylinderLayer(
     const GeometryContext& gctx,
-    std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsPhi,
-    size_t binsZ, std::optional<ProtoLayer> _protoLayer,
+    std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t binsPhi,
+    std::size_t binsZ, std::optional<ProtoLayer> _protoLayer,
     const Transform3& transform, std::unique_ptr<ApproachDescriptor> ad) const {
   ProtoLayer protoLayer =
       _protoLayer ? *_protoLayer : ProtoLayer(gctx, surfaces);
@@ -197,8 +197,8 @@ Acts::MutableLayerPtr Acts::LayerCreator::cylinderLayer(
 
 Acts::MutableLayerPtr Acts::LayerCreator::discLayer(
     const GeometryContext& gctx,
-    std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsR,
-    size_t binsPhi, std::optional<ProtoLayer> _protoLayer,
+    std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t binsR,
+    std::size_t binsPhi, std::optional<ProtoLayer> _protoLayer,
     const Transform3& transform, std::unique_ptr<ApproachDescriptor> ad) const {
   ProtoLayer protoLayer =
       _protoLayer ? *_protoLayer : ProtoLayer(gctx, surfaces);
@@ -322,9 +322,10 @@ Acts::MutableLayerPtr Acts::LayerCreator::discLayer(
 
 Acts::MutableLayerPtr Acts::LayerCreator::planeLayer(
     const GeometryContext& gctx,
-    std::vector<std::shared_ptr<const Surface>> surfaces, size_t bins1,
-    size_t bins2, BinningValue bValue, std::optional<ProtoLayer> _protoLayer,
-    const Transform3& transform, std::unique_ptr<ApproachDescriptor> ad) const {
+    std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t bins1,
+    std::size_t bins2, BinningValue bValue,
+    std::optional<ProtoLayer> _protoLayer, const Transform3& transform,
+    std::unique_ptr<ApproachDescriptor> ad) const {
   ProtoLayer protoLayer =
       _protoLayer ? *_protoLayer : ProtoLayer(gctx, surfaces);
 
@@ -428,12 +429,12 @@ bool Acts::LayerCreator::checkBinning(const GeometryContext& gctx,
   std::vector<const Surface*> surfaces = sArray.surfaces();
   std::set<const Surface*> sensitiveSurfaces(surfaces.begin(), surfaces.end());
   std::set<const Surface*> accessibleSurfaces;
-  size_t nEmptyBins = 0;
-  size_t nBinsChecked = 0;
+  std::size_t nEmptyBins = 0;
+  std::size_t nBinsChecked = 0;
 
   // iterate over all bins
-  size_t size = sArray.size();
-  for (size_t b = 0; b < size; ++b) {
+  std::size_t size = sArray.size();
+  for (std::size_t b = 0; b < size; ++b) {
     std::vector<const Surface*> binContent = sArray.at(b);
     // we don't check under/overflow bins
     if (!sArray.isValidBin(b)) {
diff --git a/Core/src/Geometry/PassiveLayerBuilder.cpp b/Core/src/Geometry/PassiveLayerBuilder.cpp
index e8ec533ff06..865067c8a27 100644
--- a/Core/src/Geometry/PassiveLayerBuilder.cpp
+++ b/Core/src/Geometry/PassiveLayerBuilder.cpp
@@ -57,13 +57,13 @@ const Acts::LayerVector Acts::PassiveLayerBuilder::endcapLayers(
     const Acts::GeometryContext& /*gctx*/, int side) const {
   LayerVector eLayers;
   // pos/neg layers
-  size_t numpnLayers = m_cfg.posnegLayerPositionZ.size();
+  std::size_t numpnLayers = m_cfg.posnegLayerPositionZ.size();
   if (numpnLayers != 0u) {
     ACTS_DEBUG("Configured to build " << numpnLayers
                                       << " passive layers on side :" << side);
     eLayers.reserve(numpnLayers);
     // loop through
-    for (size_t ipnl = 0; ipnl < numpnLayers; ++ipnl) {
+    for (std::size_t ipnl = 0; ipnl < numpnLayers; ++ipnl) {
       // some screen output
       ACTS_VERBOSE("- build layers "
                    << (ipnl)
@@ -101,13 +101,13 @@ const Acts::LayerVector Acts::PassiveLayerBuilder::centralLayers(
     const Acts::GeometryContext& /*gctx*/) const {
   LayerVector cLayers;
   // the central layers
-  size_t numcLayers = m_cfg.centralLayerRadii.size();
+  std::size_t numcLayers = m_cfg.centralLayerRadii.size();
   if (numcLayers != 0u) {
     ACTS_DEBUG("Configured to build " << numcLayers
                                       << " passive central layers.");
     cLayers.reserve(numcLayers);
     // loop through
-    for (size_t icl = 0; icl < numcLayers; ++icl) {
+    for (std::size_t icl = 0; icl < numcLayers; ++icl) {
       // some screen output
       ACTS_VERBOSE("- build layer "
                    << icl
diff --git a/Core/src/Geometry/Polyhedron.cpp b/Core/src/Geometry/Polyhedron.cpp
index ede9959cbf8..b6970ecc7fc 100644
--- a/Core/src/Geometry/Polyhedron.cpp
+++ b/Core/src/Geometry/Polyhedron.cpp
@@ -18,7 +18,7 @@
 #include <utility>
 
 void Acts::Polyhedron::merge(const Acts::Polyhedron& other) {
-  size_t cvert = vertices.size();
+  std::size_t cvert = vertices.size();
   vertices.insert(vertices.end(), other.vertices.begin(), other.vertices.end());
   /// Add the new faces with offsets
   auto join = [&](std::vector<FaceType>& existing,
@@ -26,7 +26,7 @@ void Acts::Polyhedron::merge(const Acts::Polyhedron& other) {
     for (const auto& aface : additional) {
       FaceType nface = aface;
       std::transform(nface.begin(), nface.end(), nface.begin(),
-                     [&](size_t x) { return (x + cvert); });
+                     [&](std::size_t x) { return (x + cvert); });
       existing.push_back(nface);
     }
   };
@@ -87,8 +87,8 @@ Acts::Extent Acts::Polyhedron::extent(const Transform3& transform) const {
         return dist;
       };
 
-      for (size_t iv = 1; iv < vtxs.size() + 1; ++iv) {
-        size_t fpoint = iv < vtxs.size() ? iv : 0;
+      for (std::size_t iv = 1; iv < vtxs.size() + 1; ++iv) {
+        std::size_t fpoint = iv < vtxs.size() ? iv : 0;
         double testR = radialDistance(vtxs[fpoint], vtxs[iv - 1]);
         extent.range(binR).expandMin(testR);
       }
diff --git a/Core/src/Geometry/SurfaceArrayCreator.cpp b/Core/src/Geometry/SurfaceArrayCreator.cpp
index 20e90d80429..0cb41b9aa0a 100644
--- a/Core/src/Geometry/SurfaceArrayCreator.cpp
+++ b/Core/src/Geometry/SurfaceArrayCreator.cpp
@@ -29,8 +29,8 @@ using Acts::VectorHelpers::phi;
 std::unique_ptr<Acts::SurfaceArray>
 Acts::SurfaceArrayCreator::surfaceArrayOnCylinder(
     const GeometryContext& gctx,
-    std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsPhi,
-    size_t binsZ, std::optional<ProtoLayer> protoLayerOpt,
+    std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t binsPhi,
+    std::size_t binsZ, std::optional<ProtoLayer> protoLayerOpt,
     const Transform3& transform) const {
   std::vector<const Surface*> surfacesRaw = unpack_shared_vector(surfaces);
   // Check if we have proto layer, else build it
@@ -127,8 +127,8 @@ Acts::SurfaceArrayCreator::surfaceArrayOnCylinder(
 
   // get the number of bins
   auto axes = sl->getAxes();
-  size_t bins0 = axes.at(0)->getNBins();
-  size_t bins1 = axes.at(1)->getNBins();
+  std::size_t bins0 = axes.at(0)->getNBins();
+  std::size_t bins1 = axes.at(1)->getNBins();
 
   ACTS_VERBOSE("Creating a SurfaceArray on a cylinder");
   ACTS_VERBOSE(" -- with " << surfaces.size() << " surfaces.")
@@ -142,8 +142,8 @@ Acts::SurfaceArrayCreator::surfaceArrayOnCylinder(
 std::unique_ptr<Acts::SurfaceArray>
 Acts::SurfaceArrayCreator::surfaceArrayOnDisc(
     const GeometryContext& gctx,
-    std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsR,
-    size_t binsPhi, std::optional<ProtoLayer> protoLayerOpt,
+    std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t binsR,
+    std::size_t binsPhi, std::optional<ProtoLayer> protoLayerOpt,
     const Transform3& transform) const {
   std::vector<const Surface*> surfacesRaw = unpack_shared_vector(surfaces);
   // check if we have proto layer, else build it
@@ -179,8 +179,8 @@ Acts::SurfaceArrayCreator::surfaceArrayOnDisc(
 
   // get the number of bins
   auto axes = sl->getAxes();
-  size_t bins0 = axes.at(0)->getNBins();
-  size_t bins1 = axes.at(1)->getNBins();
+  std::size_t bins0 = axes.at(0)->getNBins();
+  std::size_t bins1 = axes.at(1)->getNBins();
 
   ACTS_VERBOSE(" -- with " << surfaces.size() << " surfaces.")
   ACTS_VERBOSE(" -- with r x phi  = " << bins0 << " x " << bins1 << " = "
@@ -226,11 +226,11 @@ Acts::SurfaceArrayCreator::surfaceArrayOnDisc(
     std::vector<std::vector<const Surface*>> phiModules(pAxisR.nBins);
     for (const auto& srf : surfacesRaw) {
       Vector3 bpos = srf->binningPosition(gctx, binR);
-      size_t bin = pAxisR.getBin(perp(bpos));
+      std::size_t bin = pAxisR.getBin(perp(bpos));
       phiModules.at(bin).push_back(srf);
     }
 
-    std::vector<size_t> nPhiModules;
+    std::vector<std::size_t> nPhiModules;
     auto matcher = m_cfg.surfaceMatcher;
     auto equal = [&gctx, &matcher](const Surface* a, const Surface* b) {
       return matcher(gctx, binPhi, a, b);
@@ -238,7 +238,8 @@ Acts::SurfaceArrayCreator::surfaceArrayOnDisc(
 
     std::transform(
         phiModules.begin(), phiModules.end(), std::back_inserter(nPhiModules),
-        [&equal, this](const std::vector<const Surface*>& surfaces_) -> size_t {
+        [&equal,
+         this](const std::vector<const Surface*>& surfaces_) -> std::size_t {
           return this->findKeySurfaces(surfaces_, equal).size();
         });
 
@@ -248,7 +249,7 @@ Acts::SurfaceArrayCreator::surfaceArrayOnDisc(
     // but the rotation is done considering all bins.
     // This might be resolved through bin completion, but not sure.
     // @TODO: check in extrapolation
-    size_t nBinsPhi =
+    std::size_t nBinsPhi =
         (*std::min_element(nPhiModules.begin(), nPhiModules.end()));
     pAxisPhi = createEquidistantAxis(gctx, surfacesRaw, binPhi, protoLayer,
                                      ftransform, nBinsPhi);
@@ -285,8 +286,8 @@ Acts::SurfaceArrayCreator::surfaceArrayOnDisc(
 
   // get the number of bins
   auto axes = sl->getAxes();
-  size_t bins0 = axes.at(0)->getNBins();
-  size_t bins1 = axes.at(1)->getNBins();
+  std::size_t bins0 = axes.at(0)->getNBins();
+  std::size_t bins1 = axes.at(1)->getNBins();
 
   ACTS_VERBOSE(" -- with " << surfaces.size() << " surfaces.")
   ACTS_VERBOSE(" -- with r x phi  = " << bins0 << " x " << bins1 << " = "
@@ -303,8 +304,9 @@ Acts::SurfaceArrayCreator::surfaceArrayOnDisc(
 std::unique_ptr<Acts::SurfaceArray>
 Acts::SurfaceArrayCreator::surfaceArrayOnPlane(
     const GeometryContext& gctx,
-    std::vector<std::shared_ptr<const Surface>> surfaces, size_t bins1,
-    size_t bins2, BinningValue bValue, std::optional<ProtoLayer> protoLayerOpt,
+    std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t bins1,
+    std::size_t bins2, BinningValue bValue,
+    std::optional<ProtoLayer> protoLayerOpt,
     const Transform3& transform) const {
   std::vector<const Surface*> surfacesRaw = unpack_shared_vector(surfaces);
   // check if we have proto layer, else build it
@@ -396,7 +398,7 @@ std::vector<const Acts::Surface*> Acts::SurfaceArrayCreator::findKeySurfaces(
   return keys;
 }
 
-size_t Acts::SurfaceArrayCreator::determineBinCount(
+std::size_t Acts::SurfaceArrayCreator::determineBinCount(
     const GeometryContext& gctx, const std::vector<const Surface*>& surfaces,
     BinningValue bValue) const {
   auto matcher = m_cfg.surfaceMatcher;
@@ -448,7 +450,7 @@ Acts::SurfaceArrayCreator::createVariableAxis(
     // rotate using transform from before
     AxisScalar previous = phi(keys.at(0)->binningPosition(gctx, binPhi));
     // go through key surfaces
-    for (size_t i = 1; i < keys.size(); i++) {
+    for (std::size_t i = 1; i < keys.size(); i++) {
       const Surface* surface = keys.at(i);
       // create central binning values which is the mean of the center
       // positions in the binning direction of the current and previous
@@ -552,7 +554,7 @@ Acts::SurfaceArrayCreator::ProtoAxis
 Acts::SurfaceArrayCreator::createEquidistantAxis(
     const GeometryContext& gctx, const std::vector<const Surface*>& surfaces,
     BinningValue bValue, const ProtoLayer& protoLayer, Transform3& transform,
-    size_t nBins) const {
+    std::size_t nBins) const {
   if (surfaces.empty()) {
     throw std::logic_error(
         "No surfaces handed over for creating equidistant axis!");
@@ -569,7 +571,7 @@ Acts::SurfaceArrayCreator::createEquidistantAxis(
   // direction
   std::vector<const Acts::Surface*> keys;
 
-  size_t binNumber = 0;
+  std::size_t binNumber = 0;
   if (nBins == 0) {
     // determine bin count
     binNumber = determineBinCount(gctx, surfaces, bValue);
diff --git a/Core/src/Geometry/TrackingGeometry.cpp b/Core/src/Geometry/TrackingGeometry.cpp
index cf7606e0243..1d04db1b6fa 100644
--- a/Core/src/Geometry/TrackingGeometry.cpp
+++ b/Core/src/Geometry/TrackingGeometry.cpp
@@ -25,7 +25,7 @@ Acts::TrackingGeometry::TrackingGeometry(
     : m_world(highestVolume),
       m_beam(Surface::makeShared<PerigeeSurface>(Vector3::Zero())) {
   // Close the geometry: assign geometryID and successively the material
-  size_t volumeID = 0;
+  std::size_t volumeID = 0;
   highestVolume->closeGeometry(materialDecorator, m_volumesById, volumeID, hook,
                                logger);
   m_volumesById.rehash(0);
diff --git a/Core/src/Geometry/TrackingVolume.cpp b/Core/src/Geometry/TrackingVolume.cpp
index 952157ec304..69d2bbcc3f1 100644
--- a/Core/src/Geometry/TrackingVolume.cpp
+++ b/Core/src/Geometry/TrackingVolume.cpp
@@ -364,7 +364,8 @@ void Acts::TrackingVolume::interlinkLayers() {
 void Acts::TrackingVolume::closeGeometry(
     const IMaterialDecorator* materialDecorator,
     std::unordered_map<GeometryIdentifier, const TrackingVolume*>& volumeMap,
-    size_t& vol, const GeometryIdentifierHook& hook, const Logger& logger) {
+    std::size_t& vol, const GeometryIdentifierHook& hook,
+    const Logger& logger) {
   // we can construct the volume ID from this
   auto volumeID = GeometryIdentifier().setVolume(++vol);
   // assign the Volume ID to the volume itself
diff --git a/Core/src/Geometry/TrapezoidVolumeBounds.cpp b/Core/src/Geometry/TrapezoidVolumeBounds.cpp
index de3ceba7b2e..d70a5a126b0 100644
--- a/Core/src/Geometry/TrapezoidVolumeBounds.cpp
+++ b/Core/src/Geometry/TrapezoidVolumeBounds.cpp
@@ -172,7 +172,7 @@ Acts::Volume::BoundingBox Acts::TrapezoidVolumeBounds::boundingBox(
   Vector3 vmin = transform * vertices[0];
   Vector3 vmax = transform * vertices[0];
 
-  for (size_t i = 1; i < 8; i++) {
+  for (std::size_t i = 1; i < 8; i++) {
     const Vector3 vtx = transform * vertices[i];
     vmin = vmin.cwiseMin(vtx);
     vmax = vmax.cwiseMax(vtx);
diff --git a/Core/src/MagneticField/BFieldMapUtils.cpp b/Core/src/MagneticField/BFieldMapUtils.cpp
index cd111cce94c..1b03207d43a 100644
--- a/Core/src/MagneticField/BFieldMapUtils.cpp
+++ b/Core/src/MagneticField/BFieldMapUtils.cpp
@@ -30,12 +30,13 @@ using Acts::VectorHelpers::phi;
 Acts::InterpolatedBFieldMap<
     Acts::Grid<Acts::Vector2, Acts::detail::EquidistantAxis,
                Acts::detail::EquidistantAxis>>
-Acts::fieldMapRZ(const std::function<size_t(std::array<size_t, 2> binsRZ,
-                                            std::array<size_t, 2> nBinsRZ)>&
-                     localToGlobalBin,
-                 std::vector<double> rPos, std::vector<double> zPos,
-                 std::vector<Acts::Vector2> bField, double lengthUnit,
-                 double BFieldUnit, bool firstQuadrant) {
+Acts::fieldMapRZ(
+    const std::function<std::size_t(std::array<std::size_t, 2> binsRZ,
+                                    std::array<std::size_t, 2> nBinsRZ)>&
+        localToGlobalBin,
+    std::vector<double> rPos, std::vector<double> zPos,
+    std::vector<Acts::Vector2> bField, double lengthUnit, double BFieldUnit,
+    bool firstQuadrant) {
   // [1] Create Grid
   // sort the values
   std::sort(rPos.begin(), rPos.end());
@@ -46,8 +47,8 @@ Acts::fieldMapRZ(const std::function<size_t(std::array<size_t, 2> binsRZ,
   rPos.shrink_to_fit();
   zPos.shrink_to_fit();
   // get the number of bins
-  size_t nBinsR = rPos.size();
-  size_t nBinsZ = zPos.size();
+  std::size_t nBinsR = rPos.size();
+  std::size_t nBinsZ = zPos.size();
 
   // get the minimum and maximum. We just sorted the vectors, so these are just
   // the first and last elements.
@@ -63,7 +64,7 @@ Acts::fieldMapRZ(const std::function<size_t(std::array<size_t, 2> binsRZ,
   zMax += stepZ;
   if (firstQuadrant) {
     zMin = -zPos[nBinsZ - 1];
-    nBinsZ = static_cast<size_t>(2. * nBinsZ - 1);
+    nBinsZ = static_cast<std::size_t>(2. * nBinsZ - 1);
   }
 
   // Create the axis for the grid
@@ -78,15 +79,15 @@ Acts::fieldMapRZ(const std::function<size_t(std::array<size_t, 2> binsRZ,
   Grid_t grid(std::make_tuple(std::move(rAxis), std::move(zAxis)));
 
   // [2] Set the bField values
-  for (size_t i = 1; i <= nBinsR; ++i) {
-    for (size_t j = 1; j <= nBinsZ; ++j) {
-      std::array<size_t, 2> nIndices = {{rPos.size(), zPos.size()}};
+  for (std::size_t i = 1; i <= nBinsR; ++i) {
+    for (std::size_t j = 1; j <= nBinsZ; ++j) {
+      std::array<std::size_t, 2> nIndices = {{rPos.size(), zPos.size()}};
       Grid_t::index_t indices = {{i, j}};
       if (firstQuadrant) {
         // std::vectors begin with 0 and we do not want the user needing to
         // take underflow or overflow bins in account this is why we need to
         // subtract by one
-        size_t n = std::abs(int(j) - int(zPos.size()));
+        std::size_t n = std::abs(int(j) - int(zPos.size()));
         Grid_t::index_t indicesFirstQuadrant = {{i - 1, n}};
 
         grid.atLocalBins(indices) =
@@ -136,12 +137,13 @@ Acts::fieldMapRZ(const std::function<size_t(std::array<size_t, 2> binsRZ,
 Acts::InterpolatedBFieldMap<
     Acts::Grid<Acts::Vector3, Acts::detail::EquidistantAxis,
                Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis>>
-Acts::fieldMapXYZ(const std::function<size_t(std::array<size_t, 3> binsXYZ,
-                                             std::array<size_t, 3> nBinsXYZ)>&
-                      localToGlobalBin,
-                  std::vector<double> xPos, std::vector<double> yPos,
-                  std::vector<double> zPos, std::vector<Acts::Vector3> bField,
-                  double lengthUnit, double BFieldUnit, bool firstOctant) {
+Acts::fieldMapXYZ(
+    const std::function<std::size_t(std::array<std::size_t, 3> binsXYZ,
+                                    std::array<std::size_t, 3> nBinsXYZ)>&
+        localToGlobalBin,
+    std::vector<double> xPos, std::vector<double> yPos,
+    std::vector<double> zPos, std::vector<Acts::Vector3> bField,
+    double lengthUnit, double BFieldUnit, bool firstOctant) {
   // [1] Create Grid
   // Sort the values
   std::sort(xPos.begin(), xPos.end());
@@ -155,9 +157,9 @@ Acts::fieldMapXYZ(const std::function<size_t(std::array<size_t, 3> binsXYZ,
   yPos.shrink_to_fit();
   zPos.shrink_to_fit();
   // get the number of bins
-  size_t nBinsX = xPos.size();
-  size_t nBinsY = yPos.size();
-  size_t nBinsZ = zPos.size();
+  std::size_t nBinsX = xPos.size();
+  std::size_t nBinsY = yPos.size();
+  std::size_t nBinsZ = zPos.size();
 
   // Create the axis for the grid
   // get minima and maximia. We just sorted the vectors, so these are just the
@@ -201,19 +203,19 @@ Acts::fieldMapXYZ(const std::function<size_t(std::array<size_t, 3> binsXYZ,
       std::make_tuple(std::move(xAxis), std::move(yAxis), std::move(zAxis)));
 
   // [2] Set the bField values
-  for (size_t i = 1; i <= nBinsX; ++i) {
-    for (size_t j = 1; j <= nBinsY; ++j) {
-      for (size_t k = 1; k <= nBinsZ; ++k) {
+  for (std::size_t i = 1; i <= nBinsX; ++i) {
+    for (std::size_t j = 1; j <= nBinsY; ++j) {
+      for (std::size_t k = 1; k <= nBinsZ; ++k) {
         Grid_t::index_t indices = {{i, j, k}};
-        std::array<size_t, 3> nIndices = {
+        std::array<std::size_t, 3> nIndices = {
             {xPos.size(), yPos.size(), zPos.size()}};
         if (firstOctant) {
           // std::vectors begin with 0 and we do not want the user needing to
           // take underflow or overflow bins in account this is why we need to
           // subtract by one
-          size_t m = std::abs(int(i) - (int(xPos.size())));
-          size_t n = std::abs(int(j) - (int(yPos.size())));
-          size_t l = std::abs(int(k) - (int(zPos.size())));
+          std::size_t m = std::abs(int(i) - (int(xPos.size())));
+          std::size_t n = std::abs(int(j) - (int(yPos.size())));
+          std::size_t l = std::abs(int(k) - (int(zPos.size())));
           Grid_t::index_t indicesFirstOctant = {{m, n, l}};
 
           grid.atLocalBins(indices) =
@@ -253,13 +255,13 @@ Acts::InterpolatedBFieldMap<
                Acts::detail::EquidistantAxis>>
 Acts::solenoidFieldMap(std::pair<double, double> rlim,
                        std::pair<double, double> zlim,
-                       std::pair<size_t, size_t> nbins,
+                       std::pair<std::size_t, std::size_t> nbins,
                        const SolenoidBField& field) {
   double rMin = 0, rMax = 0, zMin = 0, zMax = 0;
   std::tie(rMin, rMax) = rlim;
   std::tie(zMin, zMax) = zlim;
 
-  size_t nBinsR = 0, nBinsZ = 0;
+  std::size_t nBinsR = 0, nBinsZ = 0;
   std::tie(nBinsR, nBinsZ) = nbins;
 
   double stepZ = std::abs(zMax - zMin) / (nBinsZ - 1);
@@ -303,8 +305,8 @@ Acts::solenoidFieldMap(std::pair<double, double> rlim,
 
   // iterate over all bins, set their value to the solenoid value
   // at their lower left position
-  for (size_t i = 0; i <= nBinsR + 1; i++) {
-    for (size_t j = 0; j <= nBinsZ + 1; j++) {
+  for (std::size_t i = 0; i <= nBinsR + 1; i++) {
+    for (std::size_t j = 0; j <= nBinsZ + 1; j++) {
       Grid_t::index_t index({i, j});
       if (i == 0 || j == 0 || i == nBinsR + 1 || j == nBinsZ + 1) {
         // under or overflow bin, set zero
diff --git a/Core/src/MagneticField/SolenoidBField.cpp b/Core/src/MagneticField/SolenoidBField.cpp
index ecb46a09e28..52c9cddd7ec 100644
--- a/Core/src/MagneticField/SolenoidBField.cpp
+++ b/Core/src/MagneticField/SolenoidBField.cpp
@@ -67,7 +67,7 @@ Acts::Vector2 Acts::SolenoidBField::multiCoilField(const Vector2& pos,
                                                    double scale) const {
   // iterate over all coils
   Vector2 resultField(0, 0);
-  for (size_t coil = 0; coil < m_cfg.nCoils; coil++) {
+  for (std::size_t coil = 0; coil < m_cfg.nCoils; coil++) {
     Vector2 shiftedPos =
         Vector2(pos[0], pos[1] + m_cfg.length * 0.5 - m_dz * (coil + 0.5));
     resultField += singleCoilField(shiftedPos, scale);
diff --git a/Core/src/Material/AccumulatedSurfaceMaterial.cpp b/Core/src/Material/AccumulatedSurfaceMaterial.cpp
index 301dfe1b358..42350b4f327 100644
--- a/Core/src/Material/AccumulatedSurfaceMaterial.cpp
+++ b/Core/src/Material/AccumulatedSurfaceMaterial.cpp
@@ -24,33 +24,33 @@ Acts::AccumulatedSurfaceMaterial::AccumulatedSurfaceMaterial(double splitFactor)
 Acts::AccumulatedSurfaceMaterial::AccumulatedSurfaceMaterial(
     const BinUtility& binUtility, double splitFactor)
     : m_binUtility(binUtility), m_splitFactor(splitFactor) {
-  size_t bins0 = m_binUtility.bins(0);
-  size_t bins1 = m_binUtility.bins(1);
+  std::size_t bins0 = m_binUtility.bins(0);
+  std::size_t bins1 = m_binUtility.bins(1);
   AccumulatedVector accVec(bins0, AccumulatedMaterialSlab());
   m_accumulatedMaterial = AccumulatedMatrix(bins1, accVec);
 }
 
 // Assign a material properties object
-std::array<size_t, 3> Acts::AccumulatedSurfaceMaterial::accumulate(
+std::array<std::size_t, 3> Acts::AccumulatedSurfaceMaterial::accumulate(
     const Vector2& lp, const MaterialSlab& mp, double pathCorrection) {
   if (m_binUtility.dimensions() == 0) {
     m_accumulatedMaterial[0][0].accumulate(mp, pathCorrection);
     return {0, 0, 0};
   }
-  size_t bin0 = m_binUtility.bin(lp, 0);
-  size_t bin1 = m_binUtility.bin(lp, 1);
+  std::size_t bin0 = m_binUtility.bin(lp, 0);
+  std::size_t bin1 = m_binUtility.bin(lp, 1);
   m_accumulatedMaterial[bin1][bin0].accumulate(mp, pathCorrection);
   return {bin0, bin1, 0};
 }
 
 // Assign a material properties object
-std::array<size_t, 3> Acts::AccumulatedSurfaceMaterial::accumulate(
+std::array<std::size_t, 3> Acts::AccumulatedSurfaceMaterial::accumulate(
     const Vector3& gp, const MaterialSlab& mp, double pathCorrection) {
   if (m_binUtility.dimensions() == 0) {
     m_accumulatedMaterial[0][0].accumulate(mp, pathCorrection);
     return {0, 0, 0};
   }
-  std::array<size_t, 3> bTriple = m_binUtility.binTriple(gp);
+  std::array<std::size_t, 3> bTriple = m_binUtility.binTriple(gp);
   m_accumulatedMaterial[bTriple[1]][bTriple[0]].accumulate(mp, pathCorrection);
   return bTriple;
 }
@@ -63,14 +63,14 @@ void Acts::AccumulatedSurfaceMaterial::trackVariance(const Vector3& gp,
     m_accumulatedMaterial[0][0].trackVariance(slabReference, emptyHit);
     return;
   }
-  std::array<size_t, 3> bTriple = m_binUtility.binTriple(gp);
-  std::vector<std::array<size_t, 3>> trackBins = {bTriple};
+  std::array<std::size_t, 3> bTriple = m_binUtility.binTriple(gp);
+  std::vector<std::array<std::size_t, 3>> trackBins = {bTriple};
   trackVariance(trackBins, slabReference);
 }
 
 // Average the information accumulated during one event
 void Acts::AccumulatedSurfaceMaterial::trackVariance(
-    const std::vector<std::array<size_t, 3>>& trackBins,
+    const std::vector<std::array<std::size_t, 3>>& trackBins,
     MaterialSlab slabReference, bool emptyHit) {
   // the homogeneous material case
   if (m_binUtility.dimensions() == 0) {
@@ -100,14 +100,14 @@ void Acts::AccumulatedSurfaceMaterial::trackAverage(const Vector3& gp,
     return;
   }
 
-  std::array<size_t, 3> bTriple = m_binUtility.binTriple(gp);
-  std::vector<std::array<size_t, 3>> trackBins = {bTriple};
+  std::array<std::size_t, 3> bTriple = m_binUtility.binTriple(gp);
+  std::vector<std::array<std::size_t, 3>> trackBins = {bTriple};
   trackAverage(trackBins, emptyHit);
 }
 
 // Average the information accumulated during one event
 void Acts::AccumulatedSurfaceMaterial::trackAverage(
-    const std::vector<std::array<size_t, 3>>& trackBins, bool emptyHit) {
+    const std::vector<std::array<std::size_t, 3>>& trackBins, bool emptyHit) {
   // the homogeneous material case
   if (m_binUtility.dimensions() == 0) {
     m_accumulatedMaterial[0][0].trackAverage(emptyHit);
@@ -142,8 +142,8 @@ Acts::AccumulatedSurfaceMaterial::totalAverage() {
       m_binUtility.bins(1),
       MaterialSlabVector(m_binUtility.bins(0), MaterialSlab()));
   // Loop over and fill
-  for (size_t ib1 = 0; ib1 < m_binUtility.bins(1); ++ib1) {
-    for (size_t ib0 = 0; ib0 < m_binUtility.bins(0); ++ib0) {
+  for (std::size_t ib1 = 0; ib1 < m_binUtility.bins(1); ++ib1) {
+    for (std::size_t ib0 = 0; ib0 < m_binUtility.bins(0); ++ib0) {
       mpMatrix[ib1][ib0] = m_accumulatedMaterial[ib1][ib0].totalAverage().first;
     }
   }
diff --git a/Core/src/Material/BinnedSurfaceMaterial.cpp b/Core/src/Material/BinnedSurfaceMaterial.cpp
index 7d31e0a6a42..380bcc1a4b3 100644
--- a/Core/src/Material/BinnedSurfaceMaterial.cpp
+++ b/Core/src/Material/BinnedSurfaceMaterial.cpp
@@ -42,16 +42,16 @@ Acts::BinnedSurfaceMaterial& Acts::BinnedSurfaceMaterial::operator*=(
 const Acts::MaterialSlab& Acts::BinnedSurfaceMaterial::materialSlab(
     const Vector2& lp) const {
   // the first bin
-  size_t ibin0 = m_binUtility.bin(lp, 0);
-  size_t ibin1 = m_binUtility.max(1) != 0u ? m_binUtility.bin(lp, 1) : 0;
+  std::size_t ibin0 = m_binUtility.bin(lp, 0);
+  std::size_t ibin1 = m_binUtility.max(1) != 0u ? m_binUtility.bin(lp, 1) : 0;
   return m_fullMaterial[ibin1][ibin0];
 }
 
 const Acts::MaterialSlab& Acts::BinnedSurfaceMaterial::materialSlab(
     const Acts::Vector3& gp) const {
   // the first bin
-  size_t ibin0 = m_binUtility.bin(gp, 0);
-  size_t ibin1 = m_binUtility.max(1) != 0u ? m_binUtility.bin(gp, 1) : 0;
+  std::size_t ibin0 = m_binUtility.bin(gp, 0);
+  std::size_t ibin1 = m_binUtility.max(1) != 0u ? m_binUtility.bin(gp, 1) : 0;
   return m_fullMaterial[ibin1][ibin0];
 }
 
diff --git a/Core/src/Material/MaterialGridHelper.cpp b/Core/src/Material/MaterialGridHelper.cpp
index 6e0d446bd51..ba17dfb1801 100644
--- a/Core/src/Material/MaterialGridHelper.cpp
+++ b/Core/src/Material/MaterialGridHelper.cpp
@@ -21,8 +21,8 @@
 Acts::Grid2D Acts::createGrid(Acts::MaterialGridAxisData gridAxis1,
                               Acts::MaterialGridAxisData gridAxis2) {
   // get the number of bins
-  size_t nBinsAxis1 = std::get<2>(gridAxis1);
-  size_t nBinsAxis2 = std::get<2>(gridAxis2);
+  std::size_t nBinsAxis1 = std::get<2>(gridAxis1);
+  std::size_t nBinsAxis2 = std::get<2>(gridAxis2);
 
   // get the minimum and maximum
   double minAxis1 = std::get<0>(gridAxis1);
@@ -49,9 +49,9 @@ Acts::Grid3D Acts::createGrid(Acts::MaterialGridAxisData gridAxis1,
                               Acts::MaterialGridAxisData gridAxis2,
                               Acts::MaterialGridAxisData gridAxis3) {
   // get the number of bins
-  size_t nBinsAxis1 = std::get<2>(gridAxis1);
-  size_t nBinsAxis2 = std::get<2>(gridAxis2);
-  size_t nBinsAxis3 = std::get<2>(gridAxis3);
+  std::size_t nBinsAxis1 = std::get<2>(gridAxis1);
+  std::size_t nBinsAxis2 = std::get<2>(gridAxis2);
+  std::size_t nBinsAxis3 = std::get<2>(gridAxis3);
 
   // get the minimum and maximum
   double minAxis1 = std::get<0>(gridAxis1);
@@ -64,11 +64,11 @@ Acts::Grid3D Acts::createGrid(Acts::MaterialGridAxisData gridAxis1,
   // to
   // left boundary)
   double stepAxis1 =
-      std::fabs(maxAxis1 - minAxis1) / std::max(nBinsAxis1 - 1, size_t(1));
+      std::fabs(maxAxis1 - minAxis1) / std::max(nBinsAxis1 - 1, std::size_t(1));
   double stepAxis2 =
-      std::fabs(maxAxis2 - minAxis2) / std::max(nBinsAxis2 - 1, size_t(1));
+      std::fabs(maxAxis2 - minAxis2) / std::max(nBinsAxis2 - 1, std::size_t(1));
   double stepAxis3 =
-      std::fabs(maxAxis3 - minAxis3) / std::max(nBinsAxis3 - 1, size_t(1));
+      std::fabs(maxAxis3 - minAxis3) / std::max(nBinsAxis3 - 1, std::size_t(1));
   maxAxis1 += stepAxis1;
   maxAxis2 += stepAxis2;
   maxAxis3 += stepAxis3;
@@ -137,7 +137,7 @@ Acts::Grid2D Acts::createGrid2D(
   bool isCartesian = false;
   bool isCylindrical = false;
 
-  for (size_t b = 0; b < bu.size(); b++) {
+  for (std::size_t b = 0; b < bu.size(); b++) {
     if (bu[b].binvalue == Acts::binX || bu[b].binvalue == Acts::binY) {
       isCartesian = true;
     }
@@ -175,7 +175,7 @@ Acts::Grid3D Acts::createGrid3D(
   bool isCartesian = false;
   bool isCylindrical = false;
 
-  for (size_t b = 0; b < bu.size(); b++) {
+  for (std::size_t b = 0; b < bu.size(); b++) {
     if (bu[b].binvalue == Acts::binX || bu[b].binvalue == Acts::binY) {
       isCartesian = true;
     }
@@ -221,7 +221,7 @@ Acts::MaterialGrid2D Acts::mapMaterialPoints(Acts::Grid2D& grid) {
 
   // Fill the material Grid by averaging the material in the 2D grid
   Acts::MaterialGrid2D mGrid(std::make_tuple(axis1, axis2));
-  for (size_t index = 0; index < grid.size(); index++) {
+  for (std::size_t index = 0; index < grid.size(); index++) {
     mGrid.at(index) = grid.at(index).average().parameters();
   }
 
@@ -241,7 +241,7 @@ Acts::MaterialGrid3D Acts::mapMaterialPoints(Acts::Grid3D& grid) {
 
   // Fill the material Grid by averaging the material in the 3D grid
   Acts::MaterialGrid3D mGrid(std::make_tuple(axis1, axis2, axis3));
-  for (size_t index = 0; index < grid.size(); index++) {
+  for (std::size_t index = 0; index < grid.size(); index++) {
     mGrid.at(index) = grid.at(index).average().parameters();
   }
   return mGrid;
diff --git a/Core/src/Material/MaterialMapUtils.cpp b/Core/src/Material/MaterialMapUtils.cpp
index 46ae4e2dcdd..37c9e13c0f7 100644
--- a/Core/src/Material/MaterialMapUtils.cpp
+++ b/Core/src/Material/MaterialMapUtils.cpp
@@ -26,8 +26,8 @@ using Acts::VectorHelpers::perp;
 using Acts::VectorHelpers::phi;
 
 auto Acts::materialMapperRZ(
-    const std::function<size_t(std::array<size_t, 2> binsRZ,
-                               std::array<size_t, 2> nBinsRZ)>&
+    const std::function<std::size_t(std::array<std::size_t, 2> binsRZ,
+                                    std::array<std::size_t, 2> nBinsRZ)>&
         materialVectorToGridMapper,
     std::vector<double> rPos, std::vector<double> zPos,
     const std::vector<Acts::Material>& material, double lengthUnit)
@@ -51,8 +51,8 @@ auto Acts::materialMapperRZ(
   rPos.shrink_to_fit();
   zPos.shrink_to_fit();
   // get the number of bins
-  size_t nBinsR = rPos.size();
-  size_t nBinsZ = zPos.size();
+  std::size_t nBinsR = rPos.size();
+  std::size_t nBinsZ = zPos.size();
 
   // get the minimum and maximum
   auto minMaxR = std::minmax_element(rPos.begin(), rPos.end());
@@ -78,9 +78,9 @@ auto Acts::materialMapperRZ(
   Grid_t grid(std::make_tuple(std::move(rAxis), std::move(zAxis)));
 
   // [3] Set the material values
-  for (size_t i = 1; i <= nBinsR; ++i) {
-    for (size_t j = 1; j <= nBinsZ; ++j) {
-      std::array<size_t, 2> nIndices = {{rPos.size(), zPos.size()}};
+  for (std::size_t i = 1; i <= nBinsR; ++i) {
+    for (std::size_t j = 1; j <= nBinsZ; ++j) {
+      std::array<std::size_t, 2> nIndices = {{rPos.size(), zPos.size()}};
       Grid_t::index_t indices = {{i, j}};
       // std::vectors begin with 0 and we do not want the user needing to
       // take underflow or overflow bins in account this is why we need to
@@ -108,8 +108,8 @@ auto Acts::materialMapperRZ(
 }
 
 auto Acts::materialMapperXYZ(
-    const std::function<size_t(std::array<size_t, 3> binsXYZ,
-                               std::array<size_t, 3> nBinsXYZ)>&
+    const std::function<std::size_t(std::array<std::size_t, 3> binsXYZ,
+                                    std::array<std::size_t, 3> nBinsXYZ)>&
         materialVectorToGridMapper,
     std::vector<double> xPos, std::vector<double> yPos,
     std::vector<double> zPos, const std::vector<Material>& material,
@@ -137,9 +137,9 @@ auto Acts::materialMapperXYZ(
   yPos.shrink_to_fit();
   zPos.shrink_to_fit();
   // get the number of bins
-  size_t nBinsX = xPos.size();
-  size_t nBinsY = yPos.size();
-  size_t nBinsZ = zPos.size();
+  std::size_t nBinsX = xPos.size();
+  std::size_t nBinsY = yPos.size();
+  std::size_t nBinsZ = zPos.size();
 
   // get the minimum and maximum
   auto minMaxX = std::minmax_element(xPos.begin(), xPos.end());
@@ -173,11 +173,11 @@ auto Acts::materialMapperXYZ(
       std::make_tuple(std::move(xAxis), std::move(yAxis), std::move(zAxis)));
 
   // [3] Set the bField values
-  for (size_t i = 1; i <= nBinsX; ++i) {
-    for (size_t j = 1; j <= nBinsY; ++j) {
-      for (size_t k = 1; k <= nBinsZ; ++k) {
+  for (std::size_t i = 1; i <= nBinsX; ++i) {
+    for (std::size_t j = 1; j <= nBinsY; ++j) {
+      for (std::size_t k = 1; k <= nBinsZ; ++k) {
         Grid_t::index_t indices = {{i, j, k}};
-        std::array<size_t, 3> nIndices = {
+        std::array<std::size_t, 3> nIndices = {
             {xPos.size(), yPos.size(), zPos.size()}};
         // std::vectors begin with 0 and we do not want the user needing to
         // take underflow or overflow bins in account this is why we need to
diff --git a/Core/src/Material/SurfaceMaterialMapper.cpp b/Core/src/Material/SurfaceMaterialMapper.cpp
index c6535e2cc14..4ad6a026541 100644
--- a/Core/src/Material/SurfaceMaterialMapper.cpp
+++ b/Core/src/Material/SurfaceMaterialMapper.cpp
@@ -129,7 +129,7 @@ void Acts::SurfaceMaterialMapper::checkAndInsert(State& mState,
           surface.surfaceMaterialSharedPtr();
     }
     auto geoID = surface.geometryId();
-    size_t volumeID = geoID.volume();
+    std::size_t volumeID = geoID.volume();
     ACTS_DEBUG("Material surface found with volumeID " << volumeID);
     ACTS_DEBUG("       - surfaceID is " << geoID);
 
@@ -284,10 +284,12 @@ void Acts::SurfaceMaterialMapper::mapInteraction(
   auto currentAccMaterial = mState.accumulatedMaterial.end();
 
   // To remember the bins of this event
-  using MapBin = std::pair<AccumulatedSurfaceMaterial*, std::array<size_t, 3>>;
+  using MapBin =
+      std::pair<AccumulatedSurfaceMaterial*, std::array<std::size_t, 3>>;
   using MaterialBin = std::pair<AccumulatedSurfaceMaterial*,
                                 std::shared_ptr<const ISurfaceMaterial>>;
-  std::map<AccumulatedSurfaceMaterial*, std::array<size_t, 3>> touchedMapBins;
+  std::map<AccumulatedSurfaceMaterial*, std::array<std::size_t, 3>>
+      touchedMapBins;
   std::map<AccumulatedSurfaceMaterial*, std::shared_ptr<const ISurfaceMaterial>>
       touchedMaterialBin;
   if (sfIter != mappingSurfaces.end() &&
@@ -421,7 +423,7 @@ void Acts::SurfaceMaterialMapper::mapInteraction(
 
   // After mapping this track, average the touched bins
   for (auto tmapBin : touchedMapBins) {
-    std::vector<std::array<size_t, 3>> trackBins = {tmapBin.second};
+    std::vector<std::array<std::size_t, 3>> trackBins = {tmapBin.second};
     if (m_cfg.computeVariance) {
       tmapBin.first->trackVariance(
           trackBins, touchedMaterialBin[tmapBin.first]->materialSlab(
@@ -463,8 +465,10 @@ void Acts::SurfaceMaterialMapper::mapInteraction(
 
 void Acts::SurfaceMaterialMapper::mapSurfaceInteraction(
     State& mState, std::vector<MaterialInteraction>& rMaterial) const {
-  using MapBin = std::pair<AccumulatedSurfaceMaterial*, std::array<size_t, 3>>;
-  std::map<AccumulatedSurfaceMaterial*, std::array<size_t, 3>> touchedMapBins;
+  using MapBin =
+      std::pair<AccumulatedSurfaceMaterial*, std::array<std::size_t, 3>>;
+  std::map<AccumulatedSurfaceMaterial*, std::array<std::size_t, 3>>
+      touchedMapBins;
   std::map<AccumulatedSurfaceMaterial*, std::shared_ptr<const ISurfaceMaterial>>
       touchedMaterialBin;
 
@@ -492,7 +496,7 @@ void Acts::SurfaceMaterialMapper::mapSurfaceInteraction(
 
   // After mapping this track, average the touched bins
   for (auto tmapBin : touchedMapBins) {
-    std::vector<std::array<size_t, 3>> trackBins = {tmapBin.second};
+    std::vector<std::array<std::size_t, 3>> trackBins = {tmapBin.second};
     if (m_cfg.computeVariance) {
       tmapBin.first->trackVariance(
           trackBins,
diff --git a/Core/src/Material/VolumeMaterialMapper.cpp b/Core/src/Material/VolumeMaterialMapper.cpp
index 273bca73d1c..5a6b927698d 100644
--- a/Core/src/Material/VolumeMaterialMapper.cpp
+++ b/Core/src/Material/VolumeMaterialMapper.cpp
@@ -98,7 +98,7 @@ void Acts::VolumeMaterialMapper::checkAndInsert(
   // Check if the volume has a proxy
   if (volumeMaterial != nullptr) {
     auto geoID = volume.geometryId();
-    size_t volumeID = geoID.volume();
+    std::size_t volumeID = geoID.volume();
     ACTS_DEBUG("Material volume found with volumeID " << volumeID);
     ACTS_DEBUG("       - ID is " << geoID);
 
diff --git a/Core/src/Surfaces/ConeSurface.cpp b/Core/src/Surfaces/ConeSurface.cpp
index 1a96e536f06..4a8045173f6 100644
--- a/Core/src/Surfaces/ConeSurface.cpp
+++ b/Core/src/Surfaces/ConeSurface.cpp
@@ -176,7 +176,7 @@ const Acts::ConeBounds& Acts::ConeSurface::bounds() const {
 }
 
 Acts::Polyhedron Acts::ConeSurface::polyhedronRepresentation(
-    const GeometryContext& gctx, size_t lseg) const {
+    const GeometryContext& gctx, std::size_t lseg) const {
   // Prepare vertices and faces
   std::vector<Vector3> vertices;
   std::vector<Polyhedron::FaceType> faces;
@@ -221,7 +221,7 @@ Acts::Polyhedron Acts::ConeSurface::polyhedronRepresentation(
   }
   for (auto& z : coneSides) {
     // Remember the first vertex
-    size_t firstIv = vertices.size();
+    std::size_t firstIv = vertices.size();
     // Radius and z offset
     double r = std::abs(z) * bounds().tanAlpha();
     Vector3 zoffset(0., 0., z);
@@ -233,8 +233,8 @@ Acts::Polyhedron Acts::ConeSurface::polyhedronRepresentation(
     }
     // Create the faces
     if (tipExists) {
-      for (size_t iv = firstIv + 2; iv < vertices.size() + 1; ++iv) {
-        size_t one = 0, two = iv - 1, three = iv - 2;
+      for (std::size_t iv = firstIv + 2; iv < vertices.size() + 1; ++iv) {
+        std::size_t one = 0, two = iv - 1, three = iv - 2;
         if (z < 0.) {
           std::swap(two, three);
         }
diff --git a/Core/src/Surfaces/ConvexPolygonBounds.cpp b/Core/src/Surfaces/ConvexPolygonBounds.cpp
index ee4fdbbdef6..7a4aaf8242e 100644
--- a/Core/src/Surfaces/ConvexPolygonBounds.cpp
+++ b/Core/src/Surfaces/ConvexPolygonBounds.cpp
@@ -14,7 +14,7 @@
 std::ostream& Acts::ConvexPolygonBoundsBase::toStream(std::ostream& sl) const {
   std::vector<Vector2> vtxs = vertices();
   sl << "Acts::ConvexPolygonBounds<" << vtxs.size() << ">: vertices: [x, y]\n";
-  for (size_t i = 0; i < vtxs.size(); i++) {
+  for (std::size_t i = 0; i < vtxs.size(); i++) {
     const auto& vtx = vtxs[i];
     if (i > 0) {
       sl << ",";
diff --git a/Core/src/Surfaces/CylinderBounds.cpp b/Core/src/Surfaces/CylinderBounds.cpp
index 32c3af01dcd..64d13bb688a 100644
--- a/Core/src/Surfaces/CylinderBounds.cpp
+++ b/Core/src/Surfaces/CylinderBounds.cpp
@@ -139,7 +139,7 @@ std::ostream& Acts::CylinderBounds::toStream(std::ostream& sl) const {
 }
 
 std::vector<Acts::Vector3> Acts::CylinderBounds::createCircles(
-    const Transform3 ctrans, size_t lseg) const {
+    const Transform3 ctrans, std::size_t lseg) const {
   std::vector<Vector3> vertices;
 
   double avgPhi = get(eAveragePhi);
@@ -156,7 +156,7 @@ std::vector<Acts::Vector3> Acts::CylinderBounds::createCircles(
   // Write the two bows/circles on either side
   std::vector<int> sides = {-1, 1};
   for (auto& side : sides) {
-    for (size_t iseg = 0; iseg < phiSegs.size() - 1; ++iseg) {
+    for (std::size_t iseg = 0; iseg < phiSegs.size() - 1; ++iseg) {
       int addon = (iseg == phiSegs.size() - 2 && !fullCylinder) ? 1 : 0;
       /// Helper method to create the segment
       detail::VerticesHelper::createSegment(
diff --git a/Core/src/Surfaces/CylinderSurface.cpp b/Core/src/Surfaces/CylinderSurface.cpp
index 79ec97ba3c1..61e0f61edf1 100644
--- a/Core/src/Surfaces/CylinderSurface.cpp
+++ b/Core/src/Surfaces/CylinderSurface.cpp
@@ -173,7 +173,7 @@ const Acts::CylinderBounds& Acts::CylinderSurface::bounds() const {
 }
 
 Acts::Polyhedron Acts::CylinderSurface::polyhedronRepresentation(
-    const GeometryContext& gctx, size_t lseg) const {
+    const GeometryContext& gctx, std::size_t lseg) const {
   auto ctrans = transform(gctx);
 
   // Prepare vertices and faces
diff --git a/Core/src/Surfaces/DiscSurface.cpp b/Core/src/Surfaces/DiscSurface.cpp
index de4d50283cd..7647deacd5d 100644
--- a/Core/src/Surfaces/DiscSurface.cpp
+++ b/Core/src/Surfaces/DiscSurface.cpp
@@ -146,7 +146,7 @@ const Acts::SurfaceBounds& Acts::DiscSurface::bounds() const {
 }
 
 Acts::Polyhedron Acts::DiscSurface::polyhedronRepresentation(
-    const GeometryContext& gctx, size_t lseg) const {
+    const GeometryContext& gctx, std::size_t lseg) const {
   // Prepare vertices and faces
   std::vector<Vector3> vertices;
   std::vector<Polyhedron::FaceType> faces;
diff --git a/Core/src/Surfaces/PerigeeSurface.cpp b/Core/src/Surfaces/PerigeeSurface.cpp
index 9973d36ed95..f5b6678898d 100644
--- a/Core/src/Surfaces/PerigeeSurface.cpp
+++ b/Core/src/Surfaces/PerigeeSurface.cpp
@@ -58,7 +58,7 @@ std::ostream& Acts::PerigeeSurface::toStream(const GeometryContext& gctx,
 }
 
 Acts::Polyhedron Acts::PerigeeSurface::polyhedronRepresentation(
-    const GeometryContext& gctx, size_t /*lseg*/) const {
+    const GeometryContext& gctx, std::size_t /*lseg*/) const {
   // Prepare vertices and faces
   std::vector<Vector3> vertices;
   std::vector<Polyhedron::FaceType> faces;
diff --git a/Core/src/Surfaces/PlaneSurface.cpp b/Core/src/Surfaces/PlaneSurface.cpp
index 6fd19b95c86..86edf9416d8 100644
--- a/Core/src/Surfaces/PlaneSurface.cpp
+++ b/Core/src/Surfaces/PlaneSurface.cpp
@@ -108,7 +108,7 @@ const Acts::SurfaceBounds& Acts::PlaneSurface::bounds() const {
 }
 
 Acts::Polyhedron Acts::PlaneSurface::polyhedronRepresentation(
-    const GeometryContext& gctx, size_t lseg) const {
+    const GeometryContext& gctx, std::size_t lseg) const {
   // Prepare vertices and faces
   std::vector<Vector3> vertices;
   std::vector<Polyhedron::FaceType> faces;
diff --git a/Core/src/Surfaces/StrawSurface.cpp b/Core/src/Surfaces/StrawSurface.cpp
index 0715cd6e044..61ba65b0576 100644
--- a/Core/src/Surfaces/StrawSurface.cpp
+++ b/Core/src/Surfaces/StrawSurface.cpp
@@ -48,7 +48,7 @@ Acts::StrawSurface& Acts::StrawSurface::operator=(const StrawSurface& other) {
 }
 
 Acts::Polyhedron Acts::StrawSurface::polyhedronRepresentation(
-    const GeometryContext& gctx, size_t lseg) const {
+    const GeometryContext& gctx, std::size_t lseg) const {
   // Prepare vertices and faces
   std::vector<Vector3> vertices;
   std::vector<Polyhedron::FaceType> faces;
@@ -62,7 +62,7 @@ Acts::Polyhedron Acts::StrawSurface::polyhedronRepresentation(
     // Write the two bows/circles on either side
     std::vector<int> sides = {-1, 1};
     for (auto& side : sides) {
-      for (size_t iseg = 0; iseg < phiSegs.size() - 1; ++iseg) {
+      for (std::size_t iseg = 0; iseg < phiSegs.size() - 1; ++iseg) {
         int addon = (iseg == phiSegs.size() - 2) ? 1 : 0;
         /// Helper method to create the segment
         detail::VerticesHelper::createSegment(
@@ -76,7 +76,7 @@ Acts::Polyhedron Acts::StrawSurface::polyhedronRepresentation(
     triangularMesh = facesMesh.second;
   }
 
-  size_t bvertices = vertices.size();
+  std::size_t bvertices = vertices.size();
   Vector3 left(0, 0, -m_bounds->get(LineBounds::eHalfLengthZ));
   Vector3 right(0, 0, m_bounds->get(LineBounds::eHalfLengthZ));
   // The central wire/straw
diff --git a/Core/src/Surfaces/SurfaceArray.cpp b/Core/src/Surfaces/SurfaceArray.cpp
index 45b6bfd4820..df925c47140 100644
--- a/Core/src/Surfaces/SurfaceArray.cpp
+++ b/Core/src/Surfaces/SurfaceArray.cpp
@@ -43,7 +43,7 @@ std::ostream& Acts::SurfaceArray::toStream(const GeometryContext& /*gctx*/,
 
   auto axes = p_gridLookup->getAxes();
 
-  for (size_t j = 0; j < axes.size(); ++j) {
+  for (std::size_t j = 0; j < axes.size(); ++j) {
     detail::AxisBoundaryType bdt = axes.at(j)->getBoundaryType();
     sl << " - axis " << (j + 1) << std::endl;
     sl << "   - boundary type: ";
@@ -63,7 +63,7 @@ std::ostream& Acts::SurfaceArray::toStream(const GeometryContext& /*gctx*/,
     sl << "   - n bins: " << axes.at(j)->getNBins() << std::endl;
     sl << "   - bin edges: [ ";
     auto binEdges = axes.at(j)->getBinEdges();
-    for (size_t i = 0; i < binEdges.size(); ++i) {
+    for (std::size_t i = 0; i < binEdges.size(); ++i) {
       if (i > 0) {
         sl << ", ";
       }
diff --git a/Core/src/Surfaces/VerticesHelper.cpp b/Core/src/Surfaces/VerticesHelper.cpp
index 37af2361de1..a0367936dc9 100644
--- a/Core/src/Surfaces/VerticesHelper.cpp
+++ b/Core/src/Surfaces/VerticesHelper.cpp
@@ -110,7 +110,7 @@ bool Acts::detail::VerticesHelper::onHyperPlane(
   // Create the hyperplane
   auto hyperPlane = Eigen::Hyperplane<ActsScalar, 3>::Through(
       vertices[0], vertices[1], vertices[2]);
-  for (size_t ip = 3; ip < vertices.size(); ++ip) {
+  for (std::size_t ip = 3; ip < vertices.size(); ++ip) {
     if (hyperPlane.absDistance(vertices[ip]) > tolerance) {
       return false;
     }
diff --git a/Core/src/TrackFinding/MeasurementSelector.cpp b/Core/src/TrackFinding/MeasurementSelector.cpp
index 0cd39654d6f..785bb226653 100644
--- a/Core/src/TrackFinding/MeasurementSelector.cpp
+++ b/Core/src/TrackFinding/MeasurementSelector.cpp
@@ -25,7 +25,7 @@ double MeasurementSelector::calculateChi2(
                      false>::Projector projector,
     unsigned int calibratedSize) const {
   return visit_measurement(calibratedSize, [&](auto N) -> double {
-    constexpr size_t kMeasurementSize = decltype(N)::value;
+    constexpr std::size_t kMeasurementSize = decltype(N)::value;
 
     typename TrackStateTraits<kMeasurementSize, true>::Measurement calibrated{
         fullCalibrated};
diff --git a/Core/src/TrackFitting/GainMatrixUpdater.cpp b/Core/src/TrackFitting/GainMatrixUpdater.cpp
index 447ab3c8037..b46ba62dbe5 100644
--- a/Core/src/TrackFitting/GainMatrixUpdater.cpp
+++ b/Core/src/TrackFitting/GainMatrixUpdater.cpp
@@ -29,7 +29,7 @@ std::tuple<double, std::error_code> GainMatrixUpdater::visitMeasurement(
   double chi2 = 0;
 
   visit_measurement(trackState.calibratedSize, [&](auto N) -> bool {
-    constexpr size_t kMeasurementSize = decltype(N)::value;
+    constexpr std::size_t kMeasurementSize = decltype(N)::value;
     using ParametersVector = ActsVector<kMeasurementSize>;
     using CovarianceMatrix = ActsSquareMatrix<kMeasurementSize>;
 
diff --git a/Core/src/TrackFitting/GsfUtils.cpp b/Core/src/TrackFitting/GsfUtils.cpp
index 0ac2bf882eb..7d12418287d 100644
--- a/Core/src/TrackFitting/GsfUtils.cpp
+++ b/Core/src/TrackFitting/GsfUtils.cpp
@@ -23,7 +23,7 @@ ActsScalar calculateDeterminant(
     TrackStateTraits::Covariance predictedCovariance,
     TrackStateTraits::Projector projector, unsigned int calibratedSize) {
   return visit_measurement(calibratedSize, [&](auto N) {
-    constexpr size_t kMeasurementSize = decltype(N)::value;
+    constexpr std::size_t kMeasurementSize = decltype(N)::value;
 
     typename Acts::TrackStateTraits<kMeasurementSize, true>::Measurement
         calibrated{fullCalibrated};
diff --git a/Core/src/Visualization/GeometryView3D.cpp b/Core/src/Visualization/GeometryView3D.cpp
index 1420463a2d4..dfa82c2ca23 100644
--- a/Core/src/Visualization/GeometryView3D.cpp
+++ b/Core/src/Visualization/GeometryView3D.cpp
@@ -316,7 +316,7 @@ void Acts::GeometryView3D::drawTrackingVolume(
         ids.push_back(current->motherVolume()->geometryId().volume());
       }
 
-      for (size_t i = ids.size() - 1; i < ids.size(); --i) {
+      for (std::size_t i = ids.size() - 1; i < ids.size(); --i) {
         vs << "_v" << ids[i];
       }
       vname = vs.str();
@@ -337,7 +337,7 @@ void Acts::GeometryView3D::drawTrackingVolume(
 
   if (tVolume.confinedLayers() != nullptr) {
     const auto& layers = tVolume.confinedLayers()->arrayObjects();
-    size_t il = 0;
+    std::size_t il = 0;
     for (const auto& tl : layers) {
       if (writeIt) {
         lConfig.outputName =
diff --git a/Examples/Algorithms/Alignment/src/AlignmentAlgorithm.cpp b/Examples/Algorithms/Alignment/src/AlignmentAlgorithm.cpp
index 94ae626812c..5cfe1165c43 100644
--- a/Examples/Algorithms/Alignment/src/AlignmentAlgorithm.cpp
+++ b/Examples/Algorithms/Alignment/src/AlignmentAlgorithm.cpp
@@ -70,7 +70,7 @@ ActsExamples::ProcessCode ActsExamples::AlignmentAlgorithm::execute(
   std::vector<std::vector<IndexSourceLink>> sourceLinkTrackContainer;
   sourceLinkTrackContainer.reserve(numTracksUsed);
   std::vector<IndexSourceLink> trackSourceLinks;
-  for (std::size_t itrack = 0; itrack < numTracksUsed; ++itrack) {
+  for (size_t itrack = 0; itrack < numTracksUsed; ++itrack) {
     // The list of hits and the initial start parameters
     const auto& protoTrack = protoTracks[itrack];
 
diff --git a/Examples/Algorithms/AmbiguityResolution/src/GreedyAmbiguityResolutionAlgorithm.cpp b/Examples/Algorithms/AmbiguityResolution/src/GreedyAmbiguityResolutionAlgorithm.cpp
index 79b5cb7acfc..64d3f81ce31 100644
--- a/Examples/Algorithms/AmbiguityResolution/src/GreedyAmbiguityResolutionAlgorithm.cpp
+++ b/Examples/Algorithms/AmbiguityResolution/src/GreedyAmbiguityResolutionAlgorithm.cpp
@@ -35,9 +35,8 @@ Acts::GreedyAmbiguityResolution::Config transformConfig(
   return result;
 }
 
-std::size_t sourceLinkHash(const Acts::SourceLink& a) {
-  return static_cast<std::size_t>(
-      a.get<ActsExamples::IndexSourceLink>().index());
+size_t sourceLinkHash(const Acts::SourceLink& a) {
+  return static_cast<size_t>(a.get<ActsExamples::IndexSourceLink>().index());
 }
 
 bool sourceLinkEquality(const Acts::SourceLink& a, const Acts::SourceLink& b) {
diff --git a/Examples/Algorithms/Digitization/src/DigitizationAlgorithm.cpp b/Examples/Algorithms/Digitization/src/DigitizationAlgorithm.cpp
index cc2fa9bb790..2d7527c99e8 100644
--- a/Examples/Algorithms/Digitization/src/DigitizationAlgorithm.cpp
+++ b/Examples/Algorithms/Digitization/src/DigitizationAlgorithm.cpp
@@ -151,7 +151,7 @@ ActsExamples::ProcessCode ActsExamples::DigitizationAlgorithm::execute(
   auto rng = m_cfg.randomNumbers->spawnGenerator(ctx);
 
   // Some statistics
-  std::size_t skippedHits = 0;
+  size_t skippedHits = 0;
 
   ACTS_DEBUG("Starting loop over modules ...");
   for (const auto& simHitsGroup : groupByModule(simHits)) {
diff --git a/Examples/Algorithms/Digitization/src/PlanarSteppingAlgorithm.cpp b/Examples/Algorithms/Digitization/src/PlanarSteppingAlgorithm.cpp
index be5c5581038..f569fbdca75 100644
--- a/Examples/Algorithms/Digitization/src/PlanarSteppingAlgorithm.cpp
+++ b/Examples/Algorithms/Digitization/src/PlanarSteppingAlgorithm.cpp
@@ -205,8 +205,7 @@ ActsExamples::ProcessCode ActsExamples::PlanarSteppingAlgorithm::execute(
       Acts::Vector3 par(localX, localY, simHit.time());
 
       // create the planar cluster
-      digiSourceLinks.emplace_back(moduleGeoId,
-                                   std::vector<std::size_t>{simHitIdx});
+      digiSourceLinks.emplace_back(moduleGeoId, std::vector<size_t>{simHitIdx});
       Acts::DigitizationSourceLink& digiSourceLink = digiSourceLinks.back();
 
       Acts::PlanarModuleCluster cluster(
diff --git a/Examples/Algorithms/Geant4/include/ActsExamples/Geant4/EventStore.hpp b/Examples/Algorithms/Geant4/include/ActsExamples/Geant4/EventStore.hpp
index c964305a8c7..350521fbe1f 100644
--- a/Examples/Algorithms/Geant4/include/ActsExamples/Geant4/EventStore.hpp
+++ b/Examples/Algorithms/Geant4/include/ActsExamples/Geant4/EventStore.hpp
@@ -48,33 +48,33 @@ struct EventStore {
   std::vector<ActsFatras::Hit> hitBuffer;
 
   /// Some statistics for the step merging
-  std::size_t numberGeantSteps = 0;
-  std::size_t maxStepsForHit = 0;
+  size_t numberGeantSteps = 0;
+  size_t maxStepsForHit = 0;
 
   /// Tracks recorded in material mapping
-  std::unordered_map<std::size_t, Acts::RecordedMaterialTrack> materialTracks;
+  std::unordered_map<size_t, Acts::RecordedMaterialTrack> materialTracks;
 
   /// Particle hit count (for hit indexing)
-  std::unordered_map<SimBarcode, std::size_t> particleHitCount;
+  std::unordered_map<SimBarcode, size_t> particleHitCount;
   /// Geant4 Track ID to Barcode mapping
   std::unordered_map<G4int, SimBarcode> trackIdMapping;
   /// Geant4 Track ID subparticle counter (for subparticle indexing)
-  std::unordered_map<G4int, std::size_t> trackIdSubparticleCount;
+  std::unordered_map<G4int, size_t> trackIdSubparticleCount;
 
   /// Data handles to read particles from the whiteboard
   const ReadDataHandle<SimParticleContainer>* inputParticles{nullptr};
 
   /// Count particle ID collisions
-  std::size_t particleIdCollisionsInitial = 0;
-  std::size_t particleIdCollisionsFinal = 0;
-  std::size_t parentIdNotFound = 0;
+  size_t particleIdCollisionsInitial = 0;
+  size_t particleIdCollisionsFinal = 0;
+  size_t parentIdNotFound = 0;
 
   /// Store subparticle count for {primVertex, secVertex, part, gen}
   /// This is done using a pseudo-barcode that contains all fields but not the
   /// subparticle counter. This can be used as key in a map to store the
   /// subparticle information
   using BarcodeWithoutSubparticle = Acts::MultiIndex<uint64_t, 16, 16, 16, 16>;
-  std::unordered_map<BarcodeWithoutSubparticle, std::size_t> subparticleMap;
+  std::unordered_map<BarcodeWithoutSubparticle, size_t> subparticleMap;
 };
 
 }  // namespace ActsExamples
diff --git a/Examples/Algorithms/Geant4/src/TelescopeG4DetectorConstruction.cpp b/Examples/Algorithms/Geant4/src/TelescopeG4DetectorConstruction.cpp
index f2e78cd859e..8acc3a6cb5e 100644
--- a/Examples/Algorithms/Geant4/src/TelescopeG4DetectorConstruction.cpp
+++ b/Examples/Algorithms/Geant4/src/TelescopeG4DetectorConstruction.cpp
@@ -150,7 +150,7 @@ ActsExamples::Telescope::TelescopeG4DetectorConstruction::Construct() {
                                                     silicon,     // its material
                                                     "Layer Logic");  // its name
 
-  for (std::size_t i = 0; i < m_cfg.positions.size(); ++i) {
+  for (size_t i = 0; i < m_cfg.positions.size(); ++i) {
     new G4PVPlacement(
         nullptr,                                                // no rotation
         G4ThreeVector(0, 0, m_cfg.positions[i] * mm - center),  // at position
diff --git a/Examples/Algorithms/Geometry/include/ActsExamples/Geometry/VolumeAssociationTest.hpp b/Examples/Algorithms/Geometry/include/ActsExamples/Geometry/VolumeAssociationTest.hpp
index 70cf5fa7617..788ba274705 100644
--- a/Examples/Algorithms/Geometry/include/ActsExamples/Geometry/VolumeAssociationTest.hpp
+++ b/Examples/Algorithms/Geometry/include/ActsExamples/Geometry/VolumeAssociationTest.hpp
@@ -31,7 +31,7 @@ class VolumeAssociationTest final : public IAlgorithm {
     /// Name of the object
     std::string name = "VolumeAssociationTets";
     /// Number of tests
-    std::size_t ntests = 1000;
+    size_t ntests = 1000;
     /// The random number service
     std::shared_ptr<const RandomNumbers> randomNumbers = nullptr;
     /// The random number range
diff --git a/Examples/Algorithms/Geometry/src/VolumeAssociationTest.cpp b/Examples/Algorithms/Geometry/src/VolumeAssociationTest.cpp
index b1bb86dd278..883731a83e2 100644
--- a/Examples/Algorithms/Geometry/src/VolumeAssociationTest.cpp
+++ b/Examples/Algorithms/Geometry/src/VolumeAssociationTest.cpp
@@ -51,9 +51,9 @@ ActsExamples::ProcessCode ActsExamples::VolumeAssociationTest::execute(
     return Acts::Vector3(r * cos(phi), r * sin(phi), z);
   };
 
-  std::size_t failedSearch = 0;
-  std::size_t failedAssignment = 0;
-  for (std::size_t it = 0; it < m_cfg.ntests; ++it) {
+  size_t failedSearch = 0;
+  size_t failedAssignment = 0;
+  for (size_t it = 0; it < m_cfg.ntests; ++it) {
     auto pos = testPosition();
     auto dv = m_cfg.detector->findDetectorVolume(ctx.geoContext, pos);
     if (dv == nullptr) {
diff --git a/Examples/Algorithms/Printers/ActsExamples/Printers/TrackParametersPrinter.cpp b/Examples/Algorithms/Printers/ActsExamples/Printers/TrackParametersPrinter.cpp
index 1b90ad08ce0..34db05ae528 100644
--- a/Examples/Algorithms/Printers/ActsExamples/Printers/TrackParametersPrinter.cpp
+++ b/Examples/Algorithms/Printers/ActsExamples/Printers/TrackParametersPrinter.cpp
@@ -36,7 +36,7 @@ ActsExamples::ProcessCode ActsExamples::TrackParametersPrinter::execute(
   ACTS_INFO("event " << ctx.eventNumber << " collection '"
                      << m_cfg.inputTrackParameters << "' contains "
                      << trackParameters.size() << " track parameters");
-  std::size_t i = 0;
+  size_t i = 0;
   for (const auto& params : trackParameters) {
     ACTS_INFO("  track " << i++ << "\n" << params);
   }
diff --git a/Examples/Algorithms/TrackFinding/include/ActsExamples/TrackFinding/TrackFindingAlgorithm.hpp b/Examples/Algorithms/TrackFinding/include/ActsExamples/TrackFinding/TrackFindingAlgorithm.hpp
index 4add3628212..8f5f080f67a 100644
--- a/Examples/Algorithms/TrackFinding/include/ActsExamples/TrackFinding/TrackFindingAlgorithm.hpp
+++ b/Examples/Algorithms/TrackFinding/include/ActsExamples/TrackFinding/TrackFindingAlgorithm.hpp
@@ -158,10 +158,10 @@ void TrackFindingAlgorithm::computeSharedHits(
   // Compute nSharedhits and Update ckf results
   // hit index -> list of multi traj indexes [traj, meas]
 
-  std::vector<std::size_t> firstTrackOnTheHit(
-      sourceLinks.size(), std::numeric_limits<std::size_t>::max());
-  std::vector<std::size_t> firstStateOnTheHit(
-      sourceLinks.size(), std::numeric_limits<std::size_t>::max());
+  std::vector<size_t> firstTrackOnTheHit(sourceLinks.size(),
+                                         std::numeric_limits<size_t>::max());
+  std::vector<size_t> firstStateOnTheHit(sourceLinks.size(),
+                                         std::numeric_limits<size_t>::max());
 
   for (auto track : tracks) {
     for (auto state : track.trackStatesReversed()) {
@@ -169,13 +169,13 @@ void TrackFindingAlgorithm::computeSharedHits(
         continue;
       }
 
-      std::size_t hitIndex = state.getUncalibratedSourceLink()
-                                 .template get<IndexSourceLink>()
-                                 .index();
+      size_t hitIndex = state.getUncalibratedSourceLink()
+                            .template get<IndexSourceLink>()
+                            .index();
 
       // Check if hit not already used
       if (firstTrackOnTheHit.at(hitIndex) ==
-          std::numeric_limits<std::size_t>::max()) {
+          std::numeric_limits<size_t>::max()) {
         firstTrackOnTheHit.at(hitIndex) = track.index();
         firstStateOnTheHit.at(hitIndex) = state.index();
         continue;
diff --git a/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp b/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
index d288ce649c1..ce05454b09e 100644
--- a/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
+++ b/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
@@ -276,11 +276,11 @@ ActsExamples::ProcessCode ActsExamples::SeedingAlgorithm::execute(
       m_cfg.seedFinderConfig.useDetailedDoubleMeasurementInfo);
 
   if (m_cfg.seedFinderConfig.useDetailedDoubleMeasurementInfo) {
-    for (std::size_t grid_glob_bin(0);
+    for (size_t grid_glob_bin(0);
          grid_glob_bin < spacePointsGrouping.grid().size(); ++grid_glob_bin) {
       const auto& collection = spacePointsGrouping.grid().at(grid_glob_bin);
       for (const auto& sp : collection) {
-        std::size_t index = sp->index();
+        size_t index = sp->index();
 
         const float topHalfStripLength =
             m_cfg.seedFinderConfig.getTopHalfStripLength(sp->sp());
diff --git a/Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithm.cpp b/Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithm.cpp
index bebf8711e20..5eda1e539d4 100644
--- a/Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithm.cpp
+++ b/Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithm.cpp
@@ -139,7 +139,7 @@ ActsExamples::ProcessCode ActsExamples::TrackFindingAlgorithm::execute(
 
   unsigned int nSeed = 0;
 
-  for (std::size_t iseed = 0; iseed < initialParameters.size(); ++iseed) {
+  for (size_t iseed = 0; iseed < initialParameters.size(); ++iseed) {
     // Clear trackContainerTemp and trackStateContainerTemp
     tracksTemp.clear();
 
diff --git a/Examples/Algorithms/TrackFinding/src/TrackParamsEstimationAlgorithm.cpp b/Examples/Algorithms/TrackFinding/src/TrackParamsEstimationAlgorithm.cpp
index 34ab7cd9317..0f8d638e50c 100644
--- a/Examples/Algorithms/TrackFinding/src/TrackParamsEstimationAlgorithm.cpp
+++ b/Examples/Algorithms/TrackFinding/src/TrackParamsEstimationAlgorithm.cpp
@@ -58,7 +58,7 @@ ActsExamples::TrackParamsEstimationAlgorithm::TrackParamsEstimationAlgorithm(
   m_outputTracks.maybeInitialize(m_cfg.outputProtoTracks);
 
   // Set up the track parameters covariance (the same for all tracks)
-  for (std::size_t i = Acts::eBoundLoc0; i < Acts::eBoundSize; ++i) {
+  for (size_t i = Acts::eBoundLoc0; i < Acts::eBoundSize; ++i) {
     m_covariance(i, i) = m_cfg.initialVarInflation[i] * m_cfg.initialSigmas[i] *
                          m_cfg.initialSigmas[i];
   }
diff --git a/Examples/Algorithms/TrackFindingExaTrkX/include/ActsExamples/TrackFindingExaTrkX/TrackFindingAlgorithmExaTrkX.hpp b/Examples/Algorithms/TrackFindingExaTrkX/include/ActsExamples/TrackFindingExaTrkX/TrackFindingAlgorithmExaTrkX.hpp
index d6366d25b43..28f16fc416d 100644
--- a/Examples/Algorithms/TrackFindingExaTrkX/include/ActsExamples/TrackFindingExaTrkX/TrackFindingAlgorithmExaTrkX.hpp
+++ b/Examples/Algorithms/TrackFindingExaTrkX/include/ActsExamples/TrackFindingExaTrkX/TrackFindingAlgorithmExaTrkX.hpp
@@ -68,7 +68,7 @@ class TrackFindingAlgorithmExaTrkX final : public IAlgorithm {
     float clusterYScale = 1.f;
 
     /// Target graph properties
-    std::size_t targetMinHits = 3;
+    size_t targetMinHits = 3;
     double targetMinPT = 500 * Acts::UnitConstants::MeV;
   };
 
diff --git a/Examples/Algorithms/TrackFindingExaTrkX/src/PrototracksToParameters.cpp b/Examples/Algorithms/TrackFindingExaTrkX/src/PrototracksToParameters.cpp
index 2b211f66f10..d1c942457fd 100644
--- a/Examples/Algorithms/TrackFindingExaTrkX/src/PrototracksToParameters.cpp
+++ b/Examples/Algorithms/TrackFindingExaTrkX/src/PrototracksToParameters.cpp
@@ -46,7 +46,7 @@ PrototracksToParameters::PrototracksToParameters(Config cfg,
   }
 
   // Set up the track parameters covariance (the same for all tracks)
-  for (std::size_t i = Acts::eBoundLoc0; i < Acts::eBoundSize; ++i) {
+  for (size_t i = Acts::eBoundLoc0; i < Acts::eBoundSize; ++i) {
     m_covariance(i, i) = m_cfg.initialVarInflation[i] * m_cfg.initialSigmas[i] *
                          m_cfg.initialSigmas[i];
   }
@@ -86,7 +86,7 @@ ProcessCode PrototracksToParameters::execute(
   // Loop over the prototracks to make seeds
   ProtoTrack tmpTrack;
   std::vector<const SimSpacePoint *> tmpSps;
-  std::size_t skippedTracks = 0;
+  size_t skippedTracks = 0;
   for (auto &track : prototracks) {
     ACTS_VERBOSE("Try to get seed from prototrack with " << track.size()
                                                          << " hits");
diff --git a/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingAlgorithmExaTrkX.cpp b/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingAlgorithmExaTrkX.cpp
index 4215828d62c..699ca8c3462 100644
--- a/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingAlgorithmExaTrkX.cpp
+++ b/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingAlgorithmExaTrkX.cpp
@@ -26,7 +26,7 @@ namespace {
 
 class ExamplesEdmHook : public Acts::ExaTrkXHook {
   double m_targetPT = 0.5_GeV;
-  std::size_t m_targetSize = 3;
+  size_t m_targetSize = 3;
 
   std::unique_ptr<const Acts::Logger> m_logger;
   std::unique_ptr<Acts::TorchTruthGraphMetricsHook> m_truthGraphHook;
@@ -35,7 +35,7 @@ class ExamplesEdmHook : public Acts::ExaTrkXHook {
   const Acts::Logger& logger() const { return *m_logger; }
 
   struct HitInfo {
-    std::size_t spacePointIndex;
+    size_t spacePointIndex;
     int32_t hitIndex;
   };
 
@@ -43,9 +43,8 @@ class ExamplesEdmHook : public Acts::ExaTrkXHook {
   ExamplesEdmHook(const SimSpacePointContainer& spacepoints,
                   const IndexMultimap<Index>& measHitMap,
                   const SimHitContainer& simhits,
-                  const SimParticleContainer& particles,
-                  std::size_t targetMinHits, double targetMinPT,
-                  const Acts::Logger& logger)
+                  const SimParticleContainer& particles, size_t targetMinHits,
+                  double targetMinPT, const Acts::Logger& logger)
       : m_targetPT(targetMinPT),
         m_targetSize(targetMinHits),
         m_logger(logger.clone("MetricsHook")) {
@@ -160,7 +159,7 @@ ActsExamples::TrackFindingAlgorithmExaTrkX::TrackFindingAlgorithmExaTrkX(
 }
 
 /// Allow access to features with nice names
-enum feat : std::size_t {
+enum feat : size_t {
   eR = 0,
   ePhi,
   eZ,
@@ -190,8 +189,8 @@ ActsExamples::ProcessCode ActsExamples::TrackFindingAlgorithmExaTrkX::execute(
 
   // Convert Input data to a list of size [num_measurements x
   // measurement_features]
-  const std::size_t numSpacepoints = spacepoints.size();
-  const std::size_t numFeatures = clusters ? 7 : 3;
+  const size_t numSpacepoints = spacepoints.size();
+  const size_t numFeatures = clusters ? 7 : 3;
   ACTS_INFO("Received " << numSpacepoints << " spacepoints");
 
   std::vector<float> features(numSpacepoints * numFeatures);
diff --git a/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingFromPrototrackAlgorithm.cpp b/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingFromPrototrackAlgorithm.cpp
index d62ab4de413..ce30b407ee5 100644
--- a/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingFromPrototrackAlgorithm.cpp
+++ b/Examples/Algorithms/TrackFindingExaTrkX/src/TrackFindingFromPrototrackAlgorithm.cpp
@@ -127,10 +127,10 @@ ActsExamples::ProcessCode TrackFindingFromPrototrackAlgorithm::execute(
   tracks.addColumn<unsigned int>("trackGroup");
   Acts::TrackAccessor<unsigned int> seedNumber("trackGroup");
 
-  std::size_t nSeed = 0;
-  std::size_t nFailed = 0;
+  size_t nSeed = 0;
+  size_t nFailed = 0;
 
-  std::vector<std::size_t> nTracksPerSeeds;
+  std::vector<size_t> nTracksPerSeeds;
   nTracksPerSeeds.reserve(initialParameters.size());
 
   for (auto i = 0ul; i < initialParameters.size(); ++i) {
diff --git a/Examples/Algorithms/TrackFitting/include/ActsExamples/TrackFitting/TrackFitterFunction.hpp b/Examples/Algorithms/TrackFitting/include/ActsExamples/TrackFitting/TrackFitterFunction.hpp
index cfbb31c24e4..0e8d4957695 100644
--- a/Examples/Algorithms/TrackFitting/include/ActsExamples/TrackFitting/TrackFitterFunction.hpp
+++ b/Examples/Algorithms/TrackFitting/include/ActsExamples/TrackFitting/TrackFitterFunction.hpp
@@ -87,7 +87,7 @@ using BetheHeitlerApprox = Acts::AtlasBetheHeitlerApprox<6, 5>;
 std::shared_ptr<TrackFitterFunction> makeGsfFitterFunction(
     std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry,
     std::shared_ptr<const Acts::MagneticFieldProvider> magneticField,
-    BetheHeitlerApprox betheHeitlerApprox, std::size_t maxComponents,
+    BetheHeitlerApprox betheHeitlerApprox, size_t maxComponents,
     double weightCutoff, Acts::MixtureReductionMethod finalReductionMethod,
     bool abortOnError, bool disableAllMaterialHandling,
     const Acts::Logger& logger);
diff --git a/Examples/Algorithms/TrackFitting/src/GsfFitterFunction.cpp b/Examples/Algorithms/TrackFitting/src/GsfFitterFunction.cpp
index 757afe59dea..d71d7baffb9 100644
--- a/Examples/Algorithms/TrackFitting/src/GsfFitterFunction.cpp
+++ b/Examples/Algorithms/TrackFitting/src/GsfFitterFunction.cpp
@@ -77,7 +77,7 @@ struct GsfFitterFunctionImpl final : public ActsExamples::TrackFitterFunction {
 
   Acts::GainMatrixUpdater updater;
 
-  std::size_t maxComponents = 0;
+  size_t maxComponents = 0;
   double weightCutoff = 0;
   bool abortOnError = false;
   bool disableAllMaterialHandling = false;
@@ -167,7 +167,7 @@ struct GsfFitterFunctionImpl final : public ActsExamples::TrackFitterFunction {
 std::shared_ptr<TrackFitterFunction> ActsExamples::makeGsfFitterFunction(
     std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry,
     std::shared_ptr<const Acts::MagneticFieldProvider> magneticField,
-    BetheHeitlerApprox betheHeitlerApprox, std::size_t maxComponents,
+    BetheHeitlerApprox betheHeitlerApprox, size_t maxComponents,
     double weightCutoff, Acts::MixtureReductionMethod finalReductionMethod,
     bool abortOnError, bool disableAllMaterialHandling,
     const Acts::Logger& logger) {
diff --git a/Examples/Algorithms/TrackFitting/src/SurfaceSortingAlgorithm.cpp b/Examples/Algorithms/TrackFitting/src/SurfaceSortingAlgorithm.cpp
index 8eb05bd5d03..fe20d3d6171 100644
--- a/Examples/Algorithms/TrackFitting/src/SurfaceSortingAlgorithm.cpp
+++ b/Examples/Algorithms/TrackFitting/src/SurfaceSortingAlgorithm.cpp
@@ -55,7 +55,7 @@ ActsExamples::ProcessCode ActsExamples::SurfaceSortingAlgorithm::execute(
   sortedTracks.reserve(protoTracks.size());
   TrackHitList trackHitList;
 
-  for (std::size_t itrack = 0; itrack < protoTracks.size(); ++itrack) {
+  for (size_t itrack = 0; itrack < protoTracks.size(); ++itrack) {
     const auto& protoTrack = protoTracks[itrack];
 
     ProtoTrack sortedProtoTrack;
diff --git a/Examples/Algorithms/TrackFitting/src/TrackFittingAlgorithm.cpp b/Examples/Algorithms/TrackFitting/src/TrackFittingAlgorithm.cpp
index 280726d9729..99ebd9986e4 100644
--- a/Examples/Algorithms/TrackFitting/src/TrackFittingAlgorithm.cpp
+++ b/Examples/Algorithms/TrackFitting/src/TrackFittingAlgorithm.cpp
@@ -104,7 +104,7 @@ ActsExamples::ProcessCode ActsExamples::TrackFittingAlgorithm::execute(
 
   // Perform the fit for each input track
   std::vector<Acts::SourceLink> trackSourceLinks;
-  for (std::size_t itrack = 0; itrack < protoTracks.size(); ++itrack) {
+  for (size_t itrack = 0; itrack < protoTracks.size(); ++itrack) {
     // Check if you are not in picking mode
     if (m_cfg.pickTrack > -1 && m_cfg.pickTrack != static_cast<int>(itrack)) {
       continue;
diff --git a/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSelector.cpp b/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSelector.cpp
index 5858f41fc57..a6c391df036 100644
--- a/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSelector.cpp
+++ b/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSelector.cpp
@@ -55,7 +55,7 @@ ActsExamples::ParticleSelector::ParticleSelector(const Config& config,
 
   // We only initialize this if we actually select on this
   if (m_cfg.measurementsMin > 0 ||
-      m_cfg.measurementsMax < std::numeric_limits<std::size_t>::max()) {
+      m_cfg.measurementsMax < std::numeric_limits<size_t>::max()) {
     m_inputMap.initialize(m_cfg.inputMeasurementParticlesMap);
     ACTS_DEBUG("selection particle number of measurements ["
                << m_cfg.measurementsMin << "," << m_cfg.measurementsMax << ")");
@@ -76,8 +76,8 @@ ActsExamples::ProcessCode ActsExamples::ParticleSelector::execute(
     particlesMeasMap = invertIndexMultimap(m_inputMap(ctx));
   }
 
-  std::size_t nInvalidCharge = 0;
-  std::size_t nInvalidMeasurementCount = 0;
+  size_t nInvalidCharge = 0;
+  size_t nInvalidMeasurementCount = 0;
 
   // helper functions to select tracks
   auto within = [](auto x, auto min, auto max) {
@@ -94,7 +94,7 @@ ActsExamples::ProcessCode ActsExamples::ParticleSelector::execute(
     const bool validCharge = validNeutral || validCharged;
     const bool validSecondary = !m_cfg.removeSecondaries || !p.isSecondary();
 
-    nInvalidCharge += static_cast<std::size_t>(!validCharge);
+    nInvalidCharge += static_cast<size_t>(!validCharge);
 
     // default valid measurement count to true and only change if we have loaded
     // the measurement particles map
@@ -102,15 +102,14 @@ ActsExamples::ProcessCode ActsExamples::ParticleSelector::execute(
     if (particlesMeasMap) {
       auto [b, e] = particlesMeasMap->equal_range(p.particleId());
       validMeasurementCount =
-          within(static_cast<std::size_t>(std::distance(b, e)),
+          within(static_cast<size_t>(std::distance(b, e)),
                  m_cfg.measurementsMin, m_cfg.measurementsMax);
 
       ACTS_VERBOSE("Found " << std::distance(b, e) << " measurements for "
                             << p.particleId());
     }
 
-    nInvalidMeasurementCount +=
-        static_cast<std::size_t>(!validMeasurementCount);
+    nInvalidMeasurementCount += static_cast<size_t>(!validMeasurementCount);
 
     return validCharge && validSecondary && validMeasurementCount &&
            within(p.transverseMomentum(), m_cfg.ptMin, m_cfg.ptMax) &&
diff --git a/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSelector.hpp b/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSelector.hpp
index d6c9fba3bc9..effa1955811 100644
--- a/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSelector.hpp
+++ b/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSelector.hpp
@@ -60,8 +60,8 @@ class ParticleSelector final : public IAlgorithm {
     double mMin = 0;
     double mMax = std::numeric_limits<double>::infinity();
     /// Measurement number cuts
-    std::size_t measurementsMin = 0;
-    std::size_t measurementsMax = std::numeric_limits<std::size_t>::max();
+    size_t measurementsMin = 0;
+    size_t measurementsMax = std::numeric_limits<size_t>::max();
     /// Remove charged particles.
     bool removeCharged = false;
     /// Remove neutral particles.
diff --git a/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSmearing.cpp b/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSmearing.cpp
index 3642cff8b3d..132173ebd29 100644
--- a/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSmearing.cpp
+++ b/Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSmearing.cpp
@@ -129,7 +129,7 @@ ActsExamples::ProcessCode ActsExamples::ParticleSmearing::execute(
       Acts::BoundSquareMatrix cov = Acts::BoundSquareMatrix::Zero();
       if (m_cfg.initialSigmas) {
         // use the initial sigmas if set
-        for (std::size_t i = Acts::eBoundLoc0; i < Acts::eBoundSize; ++i) {
+        for (size_t i = Acts::eBoundLoc0; i < Acts::eBoundSize; ++i) {
           cov(i, i) = m_cfg.initialVarInflation[i] * (*m_cfg.initialSigmas)[i] *
                       (*m_cfg.initialSigmas)[i];
         }
diff --git a/Examples/Detectors/MuonSpectrometerMockupDetector/src/MockupSectorBuilder.cpp b/Examples/Detectors/MuonSpectrometerMockupDetector/src/MockupSectorBuilder.cpp
index fea71ced2d9..0958f013b6b 100644
--- a/Examples/Detectors/MuonSpectrometerMockupDetector/src/MockupSectorBuilder.cpp
+++ b/Examples/Detectors/MuonSpectrometerMockupDetector/src/MockupSectorBuilder.cpp
@@ -289,7 +289,7 @@ ActsExamples::MockupSectorBuilder::buildSector(
 
   }  // end of number of sectors
 
-  for (std::size_t i = 0; i < cylinderVolumesBounds.size(); ++i) {
+  for (size_t i = 0; i < cylinderVolumesBounds.size(); ++i) {
     detectorCylinderVolumesOfSector.push_back(
         Acts::Experimental::DetectorVolumeFactory::construct(
             Acts::Experimental::defaultPortalAndSubPortalGenerator(), gctx,
diff --git a/Examples/Framework/include/ActsExamples/Framework/Sequencer.hpp b/Examples/Framework/include/ActsExamples/Framework/Sequencer.hpp
index 1abcfbcc3e1..5395afcd80f 100644
--- a/Examples/Framework/include/ActsExamples/Framework/Sequencer.hpp
+++ b/Examples/Framework/include/ActsExamples/Framework/Sequencer.hpp
@@ -59,9 +59,9 @@ class Sequencer {
  public:
   struct FpeMask {
     std::string file;
-    std::pair<std::size_t, std::size_t> lines;
+    std::pair<size_t, size_t> lines;
     Acts::FpeType type;
-    std::size_t count;
+    size_t count;
   };
 
   struct Config {
@@ -88,7 +88,7 @@ class Sequencer {
     bool trackFpes = true;
     std::vector<FpeMask> fpeMasks{};
     bool failOnFirstFpe = false;
-    std::size_t fpeStackTraceLength = 8;
+    size_t fpeStackTraceLength = 8;
   };
 
   Sequencer(const Config &cfg);
@@ -161,7 +161,7 @@ class Sequencer {
   /// Determine range of (requested) events; [SIZE_MAX, SIZE_MAX) for error.
   std::pair<size_t, size_t> determineEventsRange() const;
 
-  std::pair<std::string, std::size_t> fpeMaskCount(
+  std::pair<std::string, size_t> fpeMaskCount(
       const boost::stacktrace::stacktrace &st, Acts::FpeType type) const;
 
   void fpeReport() const;
@@ -182,7 +182,7 @@ class Sequencer {
 
   std::unordered_map<std::string, const DataHandleBase *> m_whiteBoardState;
 
-  std::atomic<std::size_t> m_nUnmaskedFpe = 0;
+  std::atomic<size_t> m_nUnmaskedFpe = 0;
 
   const Acts::Logger &logger() const { return *m_logger; }
 };
diff --git a/Examples/Framework/include/ActsExamples/Framework/WhiteBoard.hpp b/Examples/Framework/include/ActsExamples/Framework/WhiteBoard.hpp
index e827ad5e27b..7d7cfcaf17e 100644
--- a/Examples/Framework/include/ActsExamples/Framework/WhiteBoard.hpp
+++ b/Examples/Framework/include/ActsExamples/Framework/WhiteBoard.hpp
@@ -64,7 +64,7 @@ class WhiteBoard {
   /// Find similar names for suggestions with levenshtein-distance
   std::vector<std::string_view> similarNames(const std::string_view& name,
                                              int distThreshold,
-                                             std::size_t maxNumber) const;
+                                             size_t maxNumber) const;
 
   // type-erased value holder for move-constructible types
   struct IHolder {
@@ -132,7 +132,7 @@ inline const T& ActsExamples::WhiteBoard::get(const std::string& name) const {
     std::stringstream ss;
     if (!names.empty()) {
       ss << ", similar ones are: [ ";
-      for (std::size_t i = 0; i < std::min(3ul, names.size()); ++i) {
+      for (size_t i = 0; i < std::min(3ul, names.size()); ++i) {
         ss << "'" << names[i] << "' ";
       }
       ss << "]";
diff --git a/Examples/Framework/include/ActsExamples/Utilities/Range.hpp b/Examples/Framework/include/ActsExamples/Utilities/Range.hpp
index 2ce5db9684e..5953317db9f 100644
--- a/Examples/Framework/include/ActsExamples/Utilities/Range.hpp
+++ b/Examples/Framework/include/ActsExamples/Utilities/Range.hpp
@@ -36,7 +36,7 @@ class Range {
   Iterator begin() const { return m_begin; }
   Iterator end() const { return m_end; }
   bool empty() const { return m_begin == m_end; }
-  std::size_t size() const { return std::distance(m_begin, m_end); }
+  size_t size() const { return std::distance(m_begin, m_end); }
 
  private:
   Iterator m_begin;
diff --git a/Examples/Framework/src/Framework/Sequencer.cpp b/Examples/Framework/src/Framework/Sequencer.cpp
index f6fa9fb5d06..46cd9fea910 100644
--- a/Examples/Framework/src/Framework/Sequencer.cpp
+++ b/Examples/Framework/src/Framework/Sequencer.cpp
@@ -289,7 +289,7 @@ std::vector<std::string> Sequencer::listAlgorithmNames() const {
   return names;
 }
 
-std::pair<std::size_t, std::size_t> Sequencer::determineEventsRange() const {
+std::pair<size_t, size_t> Sequencer::determineEventsRange() const {
   constexpr auto kInvalidEventsRange = std::make_pair(SIZE_MAX, SIZE_MAX);
 
   // Note on skipping events:
@@ -395,7 +395,7 @@ struct TimingInfo {
 };
 
 void storeTiming(const std::vector<std::string>& identifiers,
-                 const std::vector<Duration>& durations, std::size_t numEvents,
+                 const std::vector<Duration>& durations, size_t numEvents,
                  const std::string& path) {
   dfe::NamedTupleTsvWriter<TimingInfo> writer(path, 4);
   for (size_t i = 0; i < identifiers.size(); ++i) {
@@ -652,7 +652,7 @@ void Sequencer::fpeReport() const {
   }
 }
 
-std::pair<std::string, std::size_t> Sequencer::fpeMaskCount(
+std::pair<std::string, size_t> Sequencer::fpeMaskCount(
     const boost::stacktrace::stacktrace& st, Acts::FpeType type) const {
   for (const auto& frame : st) {
     std::string loc = Acts::FpeMonitor::getSourceLocation(frame);
diff --git a/Examples/Framework/src/Framework/WhiteBoard.cpp b/Examples/Framework/src/Framework/WhiteBoard.cpp
index b7e53eaeda5..a7fb7c222ec 100644
--- a/Examples/Framework/src/Framework/WhiteBoard.cpp
+++ b/Examples/Framework/src/Framework/WhiteBoard.cpp
@@ -25,19 +25,19 @@ inline int levenshteinDistance(const std::string_view &a,
 
   // source prefixes can be transformed into empty string by
   // dropping all characters
-  for (std::size_t i = 1; i < a.size() + 1; ++i) {
+  for (size_t i = 1; i < a.size() + 1; ++i) {
     d(i, 0) = i;
   }
 
   // target prefixes can be reached from empty source prefix
   // by inserting every character
-  for (std::size_t j = 1; j < b.size() + 1; ++j) {
+  for (size_t j = 1; j < b.size() + 1; ++j) {
     d(0, j) = j;
   }
 
   // Fill matrix
-  for (std::size_t j = 1; j < b.size() + 1; ++j) {
-    for (std::size_t i = 1; i < a.size() + 1; ++i) {
+  for (size_t j = 1; j < b.size() + 1; ++j) {
+    for (size_t i = 1; i < a.size() + 1; ++i) {
       const auto substitutionCost = a[i] == b[j] ? 0 : 1;
 
       std::array<int, 3> possibilities = {{
@@ -58,8 +58,7 @@ inline int levenshteinDistance(const std::string_view &a,
 }  // namespace
 
 std::vector<std::string_view> ActsExamples::WhiteBoard::similarNames(
-    const std::string_view &name, int distThreshold,
-    std::size_t maxNumber) const {
+    const std::string_view &name, int distThreshold, size_t maxNumber) const {
   std::vector<std::pair<int, std::string_view>> names;
   for (const auto &[n, h] : m_store) {
     if (const auto d = levenshteinDistance(n, name); d < distThreshold) {
@@ -71,7 +70,7 @@ std::vector<std::string_view> ActsExamples::WhiteBoard::similarNames(
             [&](const auto &a, const auto &b) { return a.first < b.first; });
 
   std::vector<std::string_view> selected_names;
-  for (std::size_t i = 0; i < std::min(names.size(), maxNumber); ++i) {
+  for (size_t i = 0; i < std::min(names.size(), maxNumber); ++i) {
     selected_names.push_back(names[i].second);
   }
 
diff --git a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvBFieldWriter.hpp b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvBFieldWriter.hpp
index 84b5f288ae9..61e90515865 100644
--- a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvBFieldWriter.hpp
+++ b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvBFieldWriter.hpp
@@ -59,7 +59,7 @@ class CsvBFieldWriter {
     ///
     /// Set the number of scalars in our coordinates to 3 if we have 3D
     /// Cartesian coordinates, or 2 for cylindrical.
-    static constexpr std::size_t NDims = Coord == CoordinateType::RZ ? 2 : 3;
+    static constexpr size_t NDims = Coord == CoordinateType::RZ ? 2 : 3;
 
     /// @brief Output file to write the magnetic field to.
     std::string fileName = "bfield.csv";
@@ -75,7 +75,7 @@ class CsvBFieldWriter {
     ///
     /// The same logic as above holds for the ranges, use the user-supplied
     /// value if available, otherwise use the value from the grid.
-    std::array<Functor<std::size_t>, NDims> bins{};
+    std::array<Functor<size_t>, NDims> bins{};
 
     /// @brief Magnetic field to read from.
     ///
diff --git a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackingGeometryWriter.hpp b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackingGeometryWriter.hpp
index f407c253a9d..6fdd23eb1e1 100644
--- a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackingGeometryWriter.hpp
+++ b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackingGeometryWriter.hpp
@@ -45,7 +45,7 @@ class CsvTrackingGeometryWriter : public IWriter {
     /// Where to place output files.
     std::string outputDir;
     /// Number of decimal digits for floating point precision in output.
-    std::size_t outputPrecision = std::numeric_limits<float>::max_digits10;
+    size_t outputPrecision = std::numeric_limits<float>::max_digits10;
     /// Write sensitive surfaces
     bool writeSensitive = true;
     /// Write boundary surfaces
diff --git a/Examples/Io/Csv/src/CsvBFieldWriter.cpp b/Examples/Io/Csv/src/CsvBFieldWriter.cpp
index eca5f14ec61..78c187b5933 100644
--- a/Examples/Io/Csv/src/CsvBFieldWriter.cpp
+++ b/Examples/Io/Csv/src/CsvBFieldWriter.cpp
@@ -54,7 +54,7 @@ void CsvBFieldWriter::run(const Config<Coord, Grid>& config,
   // We proceed by finding the number of bins, as well as the minimum and
   // maximum coordinates. This process depends quite heavily on the structure
   // of the magnetic field, so we need some compile-time conditionals.
-  std::array<std::size_t, ConfigType::NDims> bins{};
+  std::array<size_t, ConfigType::NDims> bins{};
   Vector min, max;
 
   if constexpr (Grid) {
@@ -69,7 +69,7 @@ void CsvBFieldWriter::run(const Config<Coord, Grid>& config,
     // If our magnetic field is grid-like, we know that it has a built-in size
     // and bin count. We can use these, but the user may want to override the
     // values with custom values.
-    for (std::size_t i = 0; i < ConfigType::NDims; ++i) {
+    for (size_t i = 0; i < ConfigType::NDims; ++i) {
       // For each dimension, we first get the corresponding value from the
       // grid-based vector field...
       bins[i] = field.getNBins()[i];
@@ -93,7 +93,7 @@ void CsvBFieldWriter::run(const Config<Coord, Grid>& config,
     // If the vector field is not grid based, then there is no side and we are
     // forced to use the user-supplied data. Remember that in this case, the
     // values are not optional.
-    for (std::size_t i = 0; i < ConfigType::NDims; ++i) {
+    for (size_t i = 0; i < ConfigType::NDims; ++i) {
       bins[i] = config.bins[i];
       min[i] = config.range[i][0];
       max[i] = config.range[i][1];
@@ -103,7 +103,7 @@ void CsvBFieldWriter::run(const Config<Coord, Grid>& config,
   // Next, we calculate the size (in physical space) of each bin.
   Vector delta;
 
-  for (std::size_t i = 0; i < ConfigType::NDims; ++i) {
+  for (size_t i = 0; i < ConfigType::NDims; ++i) {
     delta[i] = (max[i] - min[i]) / (bins[i] - 1);
   }
 
@@ -120,14 +120,14 @@ void CsvBFieldWriter::run(const Config<Coord, Grid>& config,
                                            << " x " << bins[2] << " to file "
                                            << config.fileName << "...");
 
-    std::size_t total_items = bins[0] * bins[1] * bins[2];
+    size_t total_items = bins[0] * bins[1] * bins[2];
 
     // For Cartesian coordinates, iterate over bins in the x, y, and z
     // directions. Note that we iterate one additional time because we are
     // writing the _edges_ of the bins, and the final bin needs to be closed.
-    for (std::size_t x = 0; x < bins[0]; ++x) {
-      for (std::size_t y = 0; y < bins[1]; ++y) {
-        for (std::size_t z = 0; z < bins[2]; ++z) {
+    for (size_t x = 0; x < bins[0]; ++x) {
+      for (size_t y = 0; y < bins[1]; ++y) {
+        for (size_t z = 0; z < bins[2]; ++z) {
           // Compute the geometric position of this bin, then request the
           // magnetic field vector at that position.
           Acts::Vector3 pos = {x * delta[0] + min[0], y * delta[1] + min[1],
@@ -164,7 +164,7 @@ void CsvBFieldWriter::run(const Config<Coord, Grid>& config,
           // This final part is some diagnostic to convince the user that the
           // program is still running. We periodically provide the user with
           // some useful data.
-          std::size_t idx = (x * bins[1] * bins[2]) + (y * bins[2]) + z + 1;
+          size_t idx = (x * bins[1] * bins[2]) + (y * bins[2]) + z + 1;
 
           if (idx % 10000 == 0 || idx == total_items) {
             ACTS_VERBOSE("Wrote " << idx << " out of " << total_items
@@ -179,13 +179,13 @@ void CsvBFieldWriter::run(const Config<Coord, Grid>& config,
                                           << " to file " << config.fileName
                                           << "...");
 
-    std::size_t total_items = bins[0] * bins[1];
+    size_t total_items = bins[0] * bins[1];
 
     // For cylindrical coordinates, we only need to iterate over the r and z
     // coordinates, because we assume rotational cylindrical symmetry. This
     // makes the procedure quite a bit faster, too. Great!
-    for (std::size_t r = 0; r < bins[0]; ++r) {
-      for (std::size_t z = 0; z < bins[1]; ++z) {
+    for (size_t r = 0; r < bins[0]; ++r) {
+      for (size_t z = 0; z < bins[1]; ++z) {
         // Calculate the position (still in three dimensions), assuming that
         // the phi coordinate is zero. Then grab the field.
         Acts::Vector3 pos(min[0] + r * delta[0], 0.f, min[1] + z * delta[1]);
@@ -218,7 +218,7 @@ void CsvBFieldWriter::run(const Config<Coord, Grid>& config,
 
         // As before, print some progress reports for the user to enjoy while
         // they wait.
-        std::size_t idx = (r * bins[1]) + z + 1;
+        size_t idx = (r * bins[1]) + z + 1;
 
         if (idx % 10000 == 0 || idx == total_items) {
           ACTS_VERBOSE("Wrote " << idx << " out of " << total_items
diff --git a/Examples/Io/Csv/src/CsvMeasurementReader.cpp b/Examples/Io/Csv/src/CsvMeasurementReader.cpp
index 67b905e81d7..5bdaf4a4296 100644
--- a/Examples/Io/Csv/src/CsvMeasurementReader.cpp
+++ b/Examples/Io/Csv/src/CsvMeasurementReader.cpp
@@ -130,9 +130,8 @@ std::vector<ActsExamples::MeasurementData> readMeasurementsByGeometryId(
 }
 
 ActsExamples::ClusterContainer makeClusters(
-    const std::unordered_multimap<std::size_t, ActsExamples::CellData>&
-        cellDataMap,
-    std::size_t nMeasurements) {
+    const std::unordered_multimap<size_t, ActsExamples::CellData>& cellDataMap,
+    size_t nMeasurements) {
   using namespace ActsExamples;
   ClusterContainer clusters;
 
@@ -328,7 +327,7 @@ ActsExamples::ProcessCode ActsExamples::CsvMeasurementReader::read(
                    fromLegacy);
   }
 
-  std::unordered_multimap<std::size_t, ActsExamples::CellData> cellDataMap;
+  std::unordered_multimap<size_t, ActsExamples::CellData> cellDataMap;
   for (const auto& cd : cellData) {
     cellDataMap.emplace(cd.measurement_id, cd);
   }
diff --git a/Examples/Io/Csv/src/CsvOutputData.hpp b/Examples/Io/Csv/src/CsvOutputData.hpp
index 2eb166104c6..1ec2c4b30a6 100644
--- a/Examples/Io/Csv/src/CsvOutputData.hpp
+++ b/Examples/Io/Csv/src/CsvOutputData.hpp
@@ -307,7 +307,7 @@ struct TrackParameterData {
 };
 
 struct ProtoTrackData {
-  std::size_t trackId;
+  size_t trackId;
   Index measurementId;
   double x, y, z;
 
diff --git a/Examples/Io/Csv/src/CsvPlanarClusterReader.cpp b/Examples/Io/Csv/src/CsvPlanarClusterReader.cpp
index da78dcb9e81..531e15af46b 100644
--- a/Examples/Io/Csv/src/CsvPlanarClusterReader.cpp
+++ b/Examples/Io/Csv/src/CsvPlanarClusterReader.cpp
@@ -188,7 +188,7 @@ ActsExamples::ProcessCode ActsExamples::CsvPlanarClusterReader::read(
     Acts::GeometryIdentifier geoId = extractGeometryId(hit);
 
     // find associated truth/ simulation hits
-    std::vector<std::size_t> simHitIndices;
+    std::vector<size_t> simHitIndices;
     {
       auto range = makeRange(std::equal_range(truths.begin(), truths.end(),
                                               hit.hit_id, CompareHitId{}));
diff --git a/Examples/Io/EDM4hep/include/ActsExamples/Io/EDM4hep/EDM4hepUtil.hpp b/Examples/Io/EDM4hep/include/ActsExamples/Io/EDM4hep/EDM4hepUtil.hpp
index 4574b0c0407..fb6430b143a 100644
--- a/Examples/Io/EDM4hep/include/ActsExamples/Io/EDM4hep/EDM4hepUtil.hpp
+++ b/Examples/Io/EDM4hep/include/ActsExamples/Io/EDM4hep/EDM4hepUtil.hpp
@@ -114,7 +114,7 @@ void writeMeasurement(const Measurement& from,
 /// - relation to the particles
 void writeTrajectory(const Acts::GeometryContext& gctx, double Bz,
                      const Trajectories& from, edm4hep::MutableTrack to,
-                     std::size_t fromIndex,
+                     size_t fromIndex,
                      const Acts::ParticleHypothesis& particleHypothesis,
                      const IndexMultimap<ActsFatras::Barcode>& hitParticlesMap);
 
diff --git a/Examples/Io/EDM4hep/src/EDM4hepUtil.cpp b/Examples/Io/EDM4hep/src/EDM4hepUtil.cpp
index 7332f3d5796..71f9b7498fd 100644
--- a/Examples/Io/EDM4hep/src/EDM4hepUtil.cpp
+++ b/Examples/Io/EDM4hep/src/EDM4hepUtil.cpp
@@ -252,7 +252,7 @@ void EDM4hepUtil::writeMeasurement(const Measurement& from,
 
 void EDM4hepUtil::writeTrajectory(
     const Acts::GeometryContext& gctx, double Bz, const Trajectories& from,
-    edm4hep::MutableTrack to, std::size_t fromIndex,
+    edm4hep::MutableTrack to, size_t fromIndex,
     const Acts::ParticleHypothesis& particleHypothesis,
     const IndexMultimap<ActsFatras::Barcode>& hitParticlesMap) {
   const auto& multiTrajectory = from.multiTrajectory();
diff --git a/Examples/Io/Json/include/ActsExamples/Io/Json/JsonSurfacesWriter.hpp b/Examples/Io/Json/include/ActsExamples/Io/Json/JsonSurfacesWriter.hpp
index 3e202e14502..b6d9da8eab5 100644
--- a/Examples/Io/Json/include/ActsExamples/Io/Json/JsonSurfacesWriter.hpp
+++ b/Examples/Io/Json/include/ActsExamples/Io/Json/JsonSurfacesWriter.hpp
@@ -45,7 +45,7 @@ class JsonSurfacesWriter : public IWriter {
     /// Where to place output files.
     std::string outputDir;
     /// Number of decimal digits for floating point precision in output.
-    std::size_t outputPrecision = std::numeric_limits<float>::max_digits10;
+    size_t outputPrecision = std::numeric_limits<float>::max_digits10;
     /// Write layer surfaces
     bool writeLayer = false;
     /// Write layer approach
diff --git a/Examples/Io/Performance/ActsExamples/Io/Performance/CKFPerformanceWriter.cpp b/Examples/Io/Performance/ActsExamples/Io/Performance/CKFPerformanceWriter.cpp
index 548ee6dbd69..5f31a9d1c82 100644
--- a/Examples/Io/Performance/ActsExamples/Io/Performance/CKFPerformanceWriter.cpp
+++ b/Examples/Io/Performance/ActsExamples/Io/Performance/CKFPerformanceWriter.cpp
@@ -143,7 +143,7 @@ ActsExamples::ProcessCode ActsExamples::CKFPerformanceWriter::writeT(
   const auto& particles = m_inputParticles(ctx);
   const auto& hitParticlesMap = m_inputMeasurementParticlesMap(ctx);
 
-  std::map<ActsFatras::Barcode, std::size_t> particleTruthHitCount;
+  std::map<ActsFatras::Barcode, size_t> particleTruthHitCount;
   for (const auto& [_, pid] : hitParticlesMap) {
     particleTruthHitCount[pid]++;
   }
diff --git a/Examples/Io/Performance/ActsExamples/Io/Performance/SeedingPerformanceWriter.cpp b/Examples/Io/Performance/ActsExamples/Io/Performance/SeedingPerformanceWriter.cpp
index d63037308ff..b390f9a621f 100644
--- a/Examples/Io/Performance/ActsExamples/Io/Performance/SeedingPerformanceWriter.cpp
+++ b/Examples/Io/Performance/ActsExamples/Io/Performance/SeedingPerformanceWriter.cpp
@@ -113,7 +113,7 @@ ActsExamples::ProcessCode ActsExamples::SeedingPerformanceWriter::writeT(
   size_t nSeeds = seeds.size();
   size_t nMatchedSeeds = 0;
   // Map from particles to how many times they were successfully found by a seed
-  std::unordered_map<ActsFatras::Barcode, std::size_t> truthCount;
+  std::unordered_map<ActsFatras::Barcode, size_t> truthCount;
 
   for (size_t itrack = 0; itrack < seeds.size(); ++itrack) {
     const auto& seed = seeds[itrack];
diff --git a/Examples/Io/Performance/ActsExamples/Io/Performance/TrackFinderPerformanceWriter.cpp b/Examples/Io/Performance/ActsExamples/Io/Performance/TrackFinderPerformanceWriter.cpp
index e4f790b07e3..fd8cecb2ba8 100644
--- a/Examples/Io/Performance/ActsExamples/Io/Performance/TrackFinderPerformanceWriter.cpp
+++ b/Examples/Io/Performance/ActsExamples/Io/Performance/TrackFinderPerformanceWriter.cpp
@@ -157,10 +157,10 @@ struct ActsExamples::TrackFinderPerformanceWriter::Impl {
     // compute the inverse mapping on-the-fly
     const auto& particleHitsMap = invertIndexMultimap(hitParticlesMap);
     // How often a particle was reconstructed.
-    std::unordered_map<ActsFatras::Barcode, std::size_t> reconCount;
+    std::unordered_map<ActsFatras::Barcode, size_t> reconCount;
     reconCount.reserve(particles.size());
     // How often a particle was reconstructed as the majority particle.
-    std::unordered_map<ActsFatras::Barcode, std::size_t> majorityCount;
+    std::unordered_map<ActsFatras::Barcode, size_t> majorityCount;
     majorityCount.reserve(particles.size());
     // For each particle within a track, how many hits did it contribute
     std::vector<ParticleHitCount> particleHitCounts;
diff --git a/Examples/Io/Performance/ActsExamples/Io/Performance/VertexPerformanceWriter.cpp b/Examples/Io/Performance/ActsExamples/Io/Performance/VertexPerformanceWriter.cpp
index 2dc19802c30..87aaf46a983 100644
--- a/Examples/Io/Performance/ActsExamples/Io/Performance/VertexPerformanceWriter.cpp
+++ b/Examples/Io/Performance/ActsExamples/Io/Performance/VertexPerformanceWriter.cpp
@@ -400,7 +400,7 @@ ActsExamples::ProcessCode ActsExamples::VertexPerformanceWriter::writeT(
         // since we expect trackParameters and associatedTruthParticles to
         // align.
         bool foundMatchingParams = false;
-        for (std::size_t i = 0; i < trackParameters.size(); ++i) {
+        for (size_t i = 0; i < trackParameters.size(); ++i) {
           const auto& params = trackParameters[i].parameters();
 
           if (origTrack.parameters() == params) {
@@ -489,7 +489,7 @@ ActsExamples::ProcessCode ActsExamples::VertexPerformanceWriter::writeT(
       auto& innerPullThetaFitted = m_pullThetaFitted.emplace_back();
       auto& innerPullQOverPFitted = m_pullQOverPFitted.emplace_back();
 
-      for (std::size_t j = 0; j < associatedTruthParticles.size(); ++j) {
+      for (size_t j = 0; j < associatedTruthParticles.size(); ++j) {
         const auto& particle = associatedTruthParticles[j];
         int priVtxId = particle.particleId().vertexPrimary();
         int secVtxId = particle.particleId().vertexSecondary();
diff --git a/Examples/Io/Root/include/ActsExamples/Io/Root/RootAthenaNTupleReader.hpp b/Examples/Io/Root/include/ActsExamples/Io/Root/RootAthenaNTupleReader.hpp
index 7b5aa386548..8ee7a09da45 100644
--- a/Examples/Io/Root/include/ActsExamples/Io/Root/RootAthenaNTupleReader.hpp
+++ b/Examples/Io/Root/include/ActsExamples/Io/Root/RootAthenaNTupleReader.hpp
@@ -182,7 +182,7 @@ class RootAthenaNTupleReader : public ActsExamples::IReader {
   std::string name() const final { return "RootAthenaNTupleReader"; }
 
   /// Return the available events range.
-  std::pair<std::size_t, std::size_t> availableEvents() const final {
+  std::pair<size_t, size_t> availableEvents() const final {
     return {0u, m_events};
   }
 
@@ -211,7 +211,7 @@ class RootAthenaNTupleReader : public ActsExamples::IReader {
   std::mutex m_read_mutex;
 
   /// The number of events
-  std::size_t m_events = 0;
+  size_t m_events = 0;
 
   /// The input tree name
   TChain *m_inputChain = nullptr;
diff --git a/Examples/Io/Root/include/ActsExamples/Io/Root/RootSimHitReader.hpp b/Examples/Io/Root/include/ActsExamples/Io/Root/RootSimHitReader.hpp
index e9cd5d11f1b..2d4942fb89f 100644
--- a/Examples/Io/Root/include/ActsExamples/Io/Root/RootSimHitReader.hpp
+++ b/Examples/Io/Root/include/ActsExamples/Io/Root/RootSimHitReader.hpp
@@ -82,7 +82,7 @@ class RootSimHitReader : public IReader {
   std::mutex m_read_mutex;
 
   /// Vector of {eventNr, entryMin, entryMax}
-  std::vector<std::tuple<uint32_t, std::size_t, std::size_t>> m_eventMap;
+  std::vector<std::tuple<uint32_t, size_t, size_t>> m_eventMap;
 
   /// The input tree name
   TChain *m_inputChain = nullptr;
diff --git a/Examples/Io/Root/src/RootMaterialTrackWriter.cpp b/Examples/Io/Root/src/RootMaterialTrackWriter.cpp
index a2efbc56f1c..181df6c5632 100644
--- a/Examples/Io/Root/src/RootMaterialTrackWriter.cpp
+++ b/Examples/Io/Root/src/RootMaterialTrackWriter.cpp
@@ -173,7 +173,7 @@ ActsExamples::ProcessCode ActsExamples::RootMaterialTrackWriter::writeT(
       Acts::Vector3 positionSum = Acts::Vector3::Zero();
       double pathCorrectionSum = 0;
 
-      for (std::size_t start = 0, end = 0; end < materialInteractions.size();
+      for (size_t start = 0, end = 0; end < materialInteractions.size();
            ++end) {
         const auto& mintStart = materialInteractions[start];
         const auto& mintEnd = materialInteractions[end];
diff --git a/Examples/Io/Root/src/RootSimHitReader.cpp b/Examples/Io/Root/src/RootSimHitReader.cpp
index 6431f5fcf1e..32665697025 100644
--- a/Examples/Io/Root/src/RootSimHitReader.cpp
+++ b/Examples/Io/Root/src/RootSimHitReader.cpp
@@ -70,7 +70,7 @@ ActsExamples::RootSimHitReader::RootSimHitReader(
   m_inputChain->SetBranchStatus("*", false);
   m_inputChain->SetBranchStatus("event_id", true);
 
-  auto nEntries = static_cast<std::size_t>(m_inputChain->GetEntriesFast());
+  auto nEntries = static_cast<size_t>(m_inputChain->GetEntriesFast());
 
   // Add the first entry
   m_inputChain->GetEntry(0);
diff --git a/Examples/Python/src/Framework.cpp b/Examples/Python/src/Framework.cpp
index 6f31894b211..4c5fcfa0d96 100644
--- a/Examples/Python/src/Framework.cpp
+++ b/Examples/Python/src/Framework.cpp
@@ -198,7 +198,7 @@ void addFramework(Context& ctx) {
       py::class_<Sequencer::FpeMask>(sequencer, "_FpeMask")
           .def(py::init<>())
           .def(py::init<std::string, std::pair<unsigned int, unsigned int>,
-                        Acts::FpeType, std::size_t>())
+                        Acts::FpeType, size_t>())
           .def("__repr__", [](const Sequencer::FpeMask& self) {
             std::stringstream ss;
             ss << self;
diff --git a/Examples/Python/src/Geometry.cpp b/Examples/Python/src/Geometry.cpp
index f5d37c93996..44e0ee457f6 100644
--- a/Examples/Python/src/Geometry.cpp
+++ b/Examples/Python/src/Geometry.cpp
@@ -220,10 +220,9 @@ void addExperimentalGeometry(Context& ctx) {
     // Be able to construct a proto binning
     py::class_<ProtoBinning>(m, "ProtoBinning")
         .def(py::init<Acts::BinningValue, Acts::detail::AxisBoundaryType,
-                      const std::vector<Acts::ActsScalar>&, std::size_t>())
+                      const std::vector<Acts::ActsScalar>&, size_t>())
         .def(py::init<Acts::BinningValue, Acts::detail::AxisBoundaryType,
-                      Acts::ActsScalar, Acts::ActsScalar, std::size_t,
-                      std::size_t>());
+                      Acts::ActsScalar, Acts::ActsScalar, size_t, size_t>());
   }
 
   {
diff --git a/Examples/Python/src/TrackFitting.cpp b/Examples/Python/src/TrackFitting.cpp
index 6451cba4d45..cdba4a4cb0c 100644
--- a/Examples/Python/src/TrackFitting.cpp
+++ b/Examples/Python/src/TrackFitting.cpp
@@ -112,7 +112,7 @@ void addTrackFitting(Context& ctx) {
         "makeGsfFitterFunction",
         [](std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry,
            std::shared_ptr<const Acts::MagneticFieldProvider> magneticField,
-           BetheHeitlerApprox betheHeitlerApprox, std::size_t maxComponents,
+           BetheHeitlerApprox betheHeitlerApprox, size_t maxComponents,
            double weightCutoff,
            Acts::MixtureReductionMethod finalReductionMethod, bool abortOnError,
            bool disableAllMaterialHandling, Logging::Level level) {
diff --git a/Examples/Scripts/compareRootFiles.C b/Examples/Scripts/compareRootFiles.C
index 864ca332982..ed089d82a75 100644
--- a/Examples/Scripts/compareRootFiles.C
+++ b/Examples/Scripts/compareRootFiles.C
@@ -208,9 +208,9 @@ compareRootFiles(std::string file1,
               << std::endl;
 
     std::cout << "    o Comparing tree-wide metadata..." << std::endl;
-    const std::size_t t1EntryCount = tree1->GetEntries();
+    const size_t t1EntryCount = tree1->GetEntries();
     {
-      const std::size_t t2EntryCount = tree2->GetEntries();
+      const size_t t2EntryCount = tree2->GetEntries();
       CHECK_EQUAL(t1EntryCount,
                   t2EntryCount,
                   "      ~ Number of entries does not match!");
@@ -307,7 +307,7 @@ compareRootFiles(std::string file1,
     }
 
     std::cout << "    o Reading event data..." << std::endl;
-    for (std::size_t i = 0; i < t1EntryCount; ++i) {
+    for (size_t i = 0; i < t1EntryCount; ++i) {
       // Move to the next TTree entry (= next event)
       t1Reader.Next();
       t2Reader.Next();
@@ -322,8 +322,8 @@ compareRootFiles(std::string file1,
     {
       std::cout << "      ~ Defining event comparison operator..." << std::endl;
       IndexComparator t1CompareEvents
-          = [&branchComparisonHarnesses](std::size_t i,
-                                         std::size_t j) -> Ordering {
+          = [&branchComparisonHarnesses](size_t i,
+                                         size_t j) -> Ordering {
         for (auto& branchHarness : branchComparisonHarnesses) {
           const auto order = branchHarness.sortHarness.first.first(i, j);
           if (order != Ordering::EQUAL) { return order; }
@@ -333,7 +333,7 @@ compareRootFiles(std::string file1,
 
       std::cout << "      ~ Defining event swapping operator..." << std::endl;
       IndexSwapper t1SwapEvents
-          = [&branchComparisonHarnesses](std::size_t i, std::size_t j) {
+          = [&branchComparisonHarnesses](size_t i, size_t j) {
               for (auto& branchHarness : branchComparisonHarnesses) {
                 branchHarness.sortHarness.first.second(i, j);
               }
@@ -347,8 +347,8 @@ compareRootFiles(std::string file1,
     {
       std::cout << "      ~ Defining event comparison operator..." << std::endl;
       IndexComparator t2CompareEvents
-          = [&branchComparisonHarnesses](std::size_t i,
-                                         std::size_t j) -> Ordering {
+          = [&branchComparisonHarnesses](size_t i,
+                                         size_t j) -> Ordering {
         for (auto& branchHarness : branchComparisonHarnesses) {
           const auto order = branchHarness.sortHarness.second.first(i, j);
           if (order != Ordering::EQUAL) { return order; }
@@ -358,7 +358,7 @@ compareRootFiles(std::string file1,
 
       std::cout << "      ~ Defining event swapping operator..." << std::endl;
       IndexSwapper t2SwapEvents
-          = [&branchComparisonHarnesses](std::size_t i, std::size_t j) {
+          = [&branchComparisonHarnesses](size_t i, size_t j) {
               for (auto& branchHarness : branchComparisonHarnesses) {
                 branchHarness.sortHarness.second.second(i, j);
               }
diff --git a/Examples/Scripts/compareRootFiles.hpp b/Examples/Scripts/compareRootFiles.hpp
index d22853fec92..aa68978f23c 100644
--- a/Examples/Scripts/compareRootFiles.hpp
+++ b/Examples/Scripts/compareRootFiles.hpp
@@ -130,7 +130,7 @@ Ordering compare(const std::vector<U>& v1, const std::vector<U>& v2) {
   // ...if the size is identical...
   else {
     // ...then try to order by contents of increasing index...
-    for (std::size_t i = 0; i < v1.size(); ++i) {
+    for (size_t i = 0; i < v1.size(); ++i) {
       if (v1[i] < v2[i]) {
         return Ordering::SMALLER;
       } else if (v1[i] > v2[i]) {
@@ -148,12 +148,12 @@ Ordering compare(const std::vector<U>& v1, const std::vector<U>& v2) {
 // The following functions are generic implementations of sorting algorithms,
 // which require only a comparison operator, a swapping operator, and an
 // inclusive range of indices to be sorted in order to operate
-using IndexComparator = std::function<Ordering(std::size_t, std::size_t)>;
-using IndexSwapper = std::function<void(std::size_t, std::size_t)>;
+using IndexComparator = std::function<Ordering(size_t, size_t)>;
+using IndexSwapper = std::function<void(size_t, size_t)>;
 
 // Selection sort has pertty bad asymptotic scaling, but it is non-recursive
 // and in-place, which makes it a good choice for smaller inputs
-void selectionSort(const std::size_t firstIndex, const std::size_t lastIndex,
+void selectionSort(const size_t firstIndex, const size_t lastIndex,
                    const IndexComparator& compare, const IndexSwapper& swap) {
   for (std::size_t targetIndex = firstIndex; targetIndex < lastIndex;
        ++targetIndex) {
@@ -171,11 +171,11 @@ void selectionSort(const std::size_t firstIndex, const std::size_t lastIndex,
 }
 
 // Quick sort is used as the top-level sorting algorithm for our datasets
-void quickSort(const std::size_t firstIndex, const std::size_t lastIndex,
+void quickSort(const size_t firstIndex, const size_t lastIndex,
                const IndexComparator& compare, const IndexSwapper& swap) {
   // We switch to non-recursive selection sort when the range becomes too small.
   // This optimization voids the need for detection of 0- and 1-element input.
-  static const std::size_t NON_RECURSIVE_THRESHOLD = 25;
+  static const size_t NON_RECURSIVE_THRESHOLD = 25;
   if (lastIndex - firstIndex < NON_RECURSIVE_THRESHOLD) {
     selectionSort(firstIndex, lastIndex, compare, swap);
     return;
@@ -184,14 +184,14 @@ void quickSort(const std::size_t firstIndex, const std::size_t lastIndex,
   // We'll use the midpoint as a pivot. Later on, we can switch to more
   // elaborate pivot selection schemes if their usefulness for our use case
   // (pseudorandom events with thread-originated reordering) is demonstrated.
-  std::size_t pivotIndex = firstIndex + (lastIndex - firstIndex) / 2;
+  size_t pivotIndex = firstIndex + (lastIndex - firstIndex) / 2;
 
   // Partition the data around the pivot using Hoare's scheme
-  std::size_t splitIndex = 0;
+  size_t splitIndex = 0;
   {
     // Start with two indices one step beyond each side of the array
-    std::size_t i = firstIndex - 1;
-    std::size_t j = lastIndex + 1;
+    size_t i = firstIndex - 1;
+    size_t j = lastIndex + 1;
     while (true) {
       // Move left index forward at least once, and until an element which is
       // greater than or equal to the pivot is detected.
@@ -276,7 +276,7 @@ struct BranchComparisonHarness {
   struct TreeMetadata {
     TTreeReader& tree1Reader;
     TTreeReader& tree2Reader;
-    const std::size_t entryCount;
+    const size_t entryCount;
   };
 
   // This exception will be thrown if an unsupported branch type is encountered
@@ -363,25 +363,25 @@ struct BranchComparisonHarness {
                             branchName, tree1Data, tree2Data});
 
     // Setup event comparison and swapping for each tree
-    result.sortHarness = std::make_pair(
-        std::make_pair(
-            [&tree1Data](std::size_t i, std::size_t j) -> Ordering {
-              return compare(tree1Data[i], tree1Data[j]);
-            },
-            [&tree1Data](std::size_t i, std::size_t j) {
-              std::swap(tree1Data[i], tree1Data[j]);
-            }),
-        std::make_pair(
-            [&tree2Data](std::size_t i, std::size_t j) -> Ordering {
-              return compare(tree2Data[i], tree2Data[j]);
-            },
-            [&tree2Data](std::size_t i, std::size_t j) {
-              std::swap(tree2Data[i], tree2Data[j]);
-            }));
+    result.sortHarness =
+        std::make_pair(std::make_pair(
+                           [&tree1Data](size_t i, size_t j) -> Ordering {
+                             return compare(tree1Data[i], tree1Data[j]);
+                           },
+                           [&tree1Data](size_t i, size_t j) {
+                             std::swap(tree1Data[i], tree1Data[j]);
+                           }),
+                       std::make_pair(
+                           [&tree2Data](size_t i, size_t j) -> Ordering {
+                             return compare(tree2Data[i], tree2Data[j]);
+                           },
+                           [&tree2Data](size_t i, size_t j) {
+                             std::swap(tree2Data[i], tree2Data[j]);
+                           }));
 
     // Setup order-sensitive tree comparison
     result.eventDataEqual = [&tree1Data, &tree2Data]() -> bool {
-      for (std::size_t i = 0; i < tree1Data.size(); ++i) {
+      for (size_t i = 0; i < tree1Data.size(); ++i) {
         if (compare(tree1Data[i], tree2Data[i]) != Ordering::EQUAL) {
           return false;
         }
@@ -392,7 +392,7 @@ struct BranchComparisonHarness {
     // Add a debugging method to dump event data
     result.dumpEventData = [&tree1Data, &tree2Data] {
       std::cout << "File 1                \tFile 2" << std::endl;
-      for (std::size_t i = 0; i < tree1Data.size(); ++i) {
+      for (size_t i = 0; i < tree1Data.size(); ++i) {
         std::cout << toString(tree1Data[i]) << "      \t"
                   << toString(tree2Data[i]) << std::endl;
       }
diff --git a/Fatras/include/ActsFatras/Kernel/InteractionList.hpp b/Fatras/include/ActsFatras/Kernel/InteractionList.hpp
index 7237b1588ef..69552386c54 100644
--- a/Fatras/include/ActsFatras/Kernel/InteractionList.hpp
+++ b/Fatras/include/ActsFatras/Kernel/InteractionList.hpp
@@ -27,11 +27,11 @@ template <class T, class Tuple>
 struct TupleIndexOf;
 template <class T, class... Types>
 struct TupleIndexOf<T, std::tuple<T, Types...>> {
-  static constexpr std::size_t value = 0u;
+  static constexpr size_t value = 0u;
 };
 template <class T, class U, class... Types>
 struct TupleIndexOf<T, std::tuple<U, Types...>> {
-  static constexpr std::size_t value =
+  static constexpr size_t value =
       1u + TupleIndexOf<T, std::tuple<Types...>>::value;
 };
 
@@ -271,7 +271,7 @@ class InteractionList {
   // for the `runContinuous` call, we need to iterate over all available
   // processes and apply the ones that implement the continuous process
   // interface. this is done using an index-based compile-time recursive call.
-  template <typename generator_t, std::size_t kI0, std::size_t... kIs>
+  template <typename generator_t, size_t kI0, size_t... kIs>
   bool runContinuousImpl(generator_t& rng, const Acts::MaterialSlab& slab,
                          Particle& particle, std::vector<Particle>& generated,
                          std::index_sequence<kI0, kIs...> /*indices*/) const {
@@ -296,7 +296,7 @@ class InteractionList {
   // for the `armPointLike` call, we need to iterate over all available
   // processes and select the ones that generate the smallest limits. this is
   // done using an index-based compile-time recursive call.
-  template <typename generator_t, std::size_t kI0, std::size_t... kIs>
+  template <typename generator_t, size_t kI0, size_t... kIs>
   void armPointLikeImpl(generator_t& rng, const Particle& particle,
                         Selection& selection,
                         std::index_sequence<kI0, kIs...> /*indices*/) const {
diff --git a/Fatras/include/ActsFatras/Kernel/Simulation.hpp b/Fatras/include/ActsFatras/Kernel/Simulation.hpp
index 8399e39dbe7..aec8f4342b9 100644
--- a/Fatras/include/ActsFatras/Kernel/Simulation.hpp
+++ b/Fatras/include/ActsFatras/Kernel/Simulation.hpp
@@ -310,7 +310,7 @@ struct Simulation {
   ///
   template <typename particles_t>
   static void renumberTailParticleIds(particles_t &particles,
-                                      std::size_t lastValid) {
+                                      size_t lastValid) {
     // iterate over adjacent pairs; potentially modify the second element.
     // assume e.g. a primary particle 2 with generation=subparticle=0 that
     // generates two secondaries during simulation. we have the following
diff --git a/Fatras/include/ActsFatras/Selectors/detail/combine_selectors.hpp b/Fatras/include/ActsFatras/Selectors/detail/combine_selectors.hpp
index 6b9c2a36822..d136bd00e65 100644
--- a/Fatras/include/ActsFatras/Selectors/detail/combine_selectors.hpp
+++ b/Fatras/include/ActsFatras/Selectors/detail/combine_selectors.hpp
@@ -51,7 +51,7 @@ class CombineSelectors {
  private:
   std::tuple<Selectors...> m_selectors;
 
-  template <std::size_t... Is, typename... Ts>
+  template <size_t... Is, typename... Ts>
   bool impl(std::index_sequence<Is...> /*indices*/, const Ts &...things) const {
     Combine combine;
     // compute status for all selectors
diff --git a/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp b/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp
index 2218d8acc98..63a0d084f5a 100644
--- a/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp
+++ b/Plugins/ActSVG/include/Acts/Plugins/ActSVG/IndexedSurfacesSvgConverter.hpp
@@ -60,9 +60,8 @@ namespace Svg {
 
 using ProtoSurface = actsvg::proto::surface<std::vector<Vector3>>;
 using ProtoGrid = actsvg::proto::grid;
-using ProtoIndexedSurfaceGrid =
-    std::tuple<std::vector<ProtoSurface>, ProtoGrid,
-               std::vector<std::vector<std::size_t>>>;
+using ProtoIndexedSurfaceGrid = std::tuple<std::vector<ProtoSurface>, ProtoGrid,
+                                           std::vector<std::vector<size_t>>>;
 
 namespace IndexedSurfacesConverter {
 /// Nested options struct
@@ -141,7 +140,7 @@ ProtoIndexedSurfaceGrid convertImpl(const GeometryContext& gctx,
   auto axes = indexGrid.grid.axes();
 
   // Specify the highlight indices
-  std::vector<std::vector<std::size_t>> highlightIndices;
+  std::vector<std::vector<size_t>> highlightIndices;
 
   // 1D connections
   if constexpr (index_grid::grid_type::DIM == 1u) {
@@ -194,7 +193,7 @@ void convert(const GeometryContext& gctx, const surface_container& surfaces,
              const Experimental::SurfaceCandidatesUpdator& delegate,
              [[maybe_unused]] const instance_type& refInstance) {
   using GridType =
-      typename instance_type::template grid_type<std::vector<std::size_t>>;
+      typename instance_type::template grid_type<std::vector<size_t>>;
   // Defining a Delegate type
   using DelegateType = Experimental::IndexedSurfacesAllPortalsImpl<
       GridType, Experimental::IndexedSurfacesImpl>;
@@ -217,7 +216,7 @@ void convert(const GeometryContext& gctx, const surface_container& surfaces,
 /// @brief Unrolling function for catching the right instance
 ///
 /// @note parameters are as of the `convertImpl` method
-template <typename surface_container, typename tuple_type, std::size_t... I>
+template <typename surface_container, typename tuple_type, size_t... I>
 void unrollConvert(const GeometryContext& gctx,
                    const surface_container& surfaces, const Options& cOptions,
                    ProtoIndexedSurfaceGrid& sgi,
@@ -246,7 +245,7 @@ ProtoIndexedSurfaceGrid convert(
   // Prep work what is to be filled
   std::vector<ProtoSurface> pSurfaces;
   ProtoGrid pGrid;
-  std::vector<std::vector<std::size_t>> indices;
+  std::vector<std::vector<size_t>> indices;
   ProtoIndexedSurfaceGrid sgi = {pSurfaces, pGrid, indices};
   // Convert if dynamic cast happens to work
   unrollConvert(
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.hpp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.hpp
index 7735593f0ce..d248a84dc68 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.hpp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.hpp
@@ -59,7 +59,7 @@ class SeedFinder<external_spacepoint_t, Acts::Cuda> {
   std::vector<Seed<external_spacepoint_t> > createSeedsForGroup(
       Acts::SpacePointData& spacePointData,
       Acts::SpacePointGrid<external_spacepoint_t>& grid,
-      const sp_range_t& bottomSPs, const std::size_t middleSPs,
+      const sp_range_t& bottomSPs, const size_t middleSPs,
       const sp_range_t& topSPs) const;
 
  private:
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp
index 8f5446e9bfe..520d0998eac 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp
@@ -49,7 +49,7 @@ std::vector<Seed<external_spacepoint_t>>
 SeedFinder<external_spacepoint_t, Acts::Cuda>::createSeedsForGroup(
     Acts::SpacePointData& spacePointData,
     Acts::SpacePointGrid<external_spacepoint_t>& grid,
-    const sp_range_t& bottomSPs, const std::size_t middleSPs,
+    const sp_range_t& bottomSPs, const size_t middleSPs,
     const sp_range_t& topSPs) const {
   std::vector<Seed<external_spacepoint_t>> outputVec;
 
@@ -100,7 +100,7 @@ SeedFinder<external_spacepoint_t, Acts::Cuda>::createSeedsForGroup(
       bottomSPvec.push_back(sp.get());
     }
   }
-  for (std::size_t idx : topSPs) {
+  for (size_t idx : topSPs) {
     auto& sp_collection = grid.at(idx);
     for (auto& sp : sp_collection) {
       nSpT++;
@@ -308,7 +308,7 @@ SeedFinder<external_spacepoint_t, Acts::Cuda>::createSeedsForGroup(
       std::sort(candidates.begin(), candidates.end(),
                 CandidatesForMiddleSp<const InternalSpacePoint<
                     external_spacepoint_t>>::descendingByQuality);
-      std::size_t numQualitySeeds = 0;  // not used but needs to be fixed
+      size_t numQualitySeeds = 0;  // not used but needs to be fixed
       m_config.seedFilter->filterSeeds_1SpFixed(spacePointData, candidates,
                                                 numQualitySeeds,
                                                 std::back_inserter(outputVec));
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/CountDublets.hpp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/CountDublets.hpp
index bf4ba8ab6ad..a21550d59e9 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/CountDublets.hpp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/CountDublets.hpp
@@ -36,7 +36,7 @@ namespace Details {
 /// @return An object holding all the summary statistics necessary for the
 ///         subsequent steps of GPU execution
 ///
-DubletCounts countDublets(std::size_t maxBlockSize, std::size_t nMiddleSP,
+DubletCounts countDublets(size_t maxBlockSize, size_t nMiddleSP,
                           const device_array<unsigned int>& middleBottomCounts,
                           const device_array<unsigned int>& middleTopCounts);
 
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/FindDublets.hpp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/FindDublets.hpp
index 3bb9b2b7011..f609b484852 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/FindDublets.hpp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/FindDublets.hpp
@@ -26,9 +26,9 @@ namespace Details {
 /// steps of the code.
 ///
 /// Note that @c middleBottomCounts and @c middleTopCounts have type
-/// "unsigned int" instead of "std::size_t", because the GPU code needs to
+/// "unsigned int" instead of "size_t", because the GPU code needs to
 /// execute atomic operations on these arrays. And CUDA does not define such
-/// operations on std::size_t (i.e. unsigned long).
+/// operations on size_t (i.e. unsigned long).
 ///
 /// @param[in] maxBlockSize The maximum block size to use on the GPU
 /// @param[in] nBottomSPs The number of bottom spacepoints in @c bottomSPs
@@ -56,17 +56,16 @@ namespace Details {
 ///             @c nMiddleSPs x @c nTopSPs, holding the top spacepoint
 ///             indices for the identified middle-top dublets
 ///
-void findDublets(std::size_t maxBlockSize, std::size_t nBottomSPs,
-                 const device_array<SpacePoint>& bottomSPs,
-                 std::size_t nMiddleSPs,
-                 const device_array<SpacePoint>& middleSPs, std::size_t nTopSPs,
+void findDublets(size_t maxBlockSize, size_t nBottomSPs,
+                 const device_array<SpacePoint>& bottomSPs, size_t nMiddleSPs,
+                 const device_array<SpacePoint>& middleSPs, size_t nTopSPs,
                  const device_array<SpacePoint>& topSPs, float deltaRMin,
                  float deltaRMax, float cotThetaMax, float collisionRegionMin,
                  float collisionRegionMax,
                  device_array<unsigned int>& middleBottomCounts,
-                 device_array<std::size_t>& middleBottomDublets,
+                 device_array<size_t>& middleBottomDublets,
                  device_array<unsigned int>& middleTopCounts,
-                 device_array<std::size_t>& middleTopDublets);
+                 device_array<size_t>& middleTopDublets);
 
 }  // namespace Details
 }  // namespace Cuda
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/FindTriplets.hpp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/FindTriplets.hpp
index 3fca7899946..054f879c738 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/FindTriplets.hpp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/Details/FindTriplets.hpp
@@ -72,18 +72,18 @@ namespace Details {
 ///         for each middle spacepoint
 ///
 std::vector<std::vector<Triplet> > findTriplets(
-    const Info::Device& device, std::size_t maxBlockSize,
+    const Info::Device& device, size_t maxBlockSize,
     const DubletCounts& dubletCounts, const SeedFilterConfig& seedConfig,
-    const TripletFilterConfig& filterConfig, std::size_t nBottomSPs,
-    const device_array<SpacePoint>& bottomSPs, std::size_t nMiddleSPs,
-    const device_array<SpacePoint>& middleSPs, std::size_t nTopSPs,
+    const TripletFilterConfig& filterConfig, size_t nBottomSPs,
+    const device_array<SpacePoint>& bottomSPs, size_t nMiddleSPs,
+    const device_array<SpacePoint>& middleSPs, size_t nTopSPs,
     const device_array<SpacePoint>& topSPs,
     const device_array<unsigned int>& middleBottomCounts,
-    const device_array<std::size_t>& middleBottomDublets,
+    const device_array<size_t>& middleBottomDublets,
     const device_array<unsigned int>& middleTopCounts,
-    const device_array<std::size_t>& middleTopDublets,
-    float maxScatteringAngle2, float sigmaScattering, float minHelixDiameter2,
-    float pT2perRadius, float impactMax);
+    const device_array<size_t>& middleTopDublets, float maxScatteringAngle2,
+    float sigmaScattering, float minHelixDiameter2, float pT2perRadius,
+    float impactMax);
 
 }  // namespace Details
 }  // namespace Cuda
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.hpp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.hpp
index ee0e3a38b00..391a9b4e704 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.hpp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.hpp
@@ -61,7 +61,7 @@ class SeedFinder {
   std::vector<Seed<external_spacepoint_t> > createSeedsForGroup(
       Acts::SpacePointData& spacePointData,
       Acts::SpacePointGrid<external_spacepoint_t>& grid,
-      const sp_range_t& bottomSPs, const std::size_t middleSPs,
+      const sp_range_t& bottomSPs, const size_t middleSPs,
       const sp_range_t& topSPs) const;
 
   /// set logging instance
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp
index 9568e3209d6..d7a7c7cf483 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp
@@ -68,7 +68,7 @@ SeedFinder<external_spacepoint_t>::SeedFinder(
   }
 
   // Tell the user what CUDA device will be used by the object.
-  if (static_cast<std::size_t>(m_device) < Info::instance().devices().size()) {
+  if (static_cast<size_t>(m_device) < Info::instance().devices().size()) {
     ACTS_DEBUG("Will be using device:\n"
                << Info::instance().devices()[m_device]);
   } else {
@@ -83,7 +83,7 @@ std::vector<Seed<external_spacepoint_t>>
 SeedFinder<external_spacepoint_t>::createSeedsForGroup(
     Acts::SpacePointData& spacePointData,
     Acts::SpacePointGrid<external_spacepoint_t>& grid,
-    const sp_range_t& bottomSPs, const std::size_t middleSPs,
+    const sp_range_t& bottomSPs, const size_t middleSPs,
     const sp_range_t& topSPs) const {
   // Create an empty vector, to be returned already early on when no seeds can
   // be constructed.
@@ -96,7 +96,7 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
   // Create more convenient vectors out of the space point containers.
   auto spVecMaker = [&grid](const sp_range_t& spRange) {
     std::vector<Acts::InternalSpacePoint<external_spacepoint_t>*> result;
-    for (std::size_t idx : spRange) {
+    for (size_t idx : spRange) {
       auto& collection = grid.at(idx);
       for (auto& sp : collection) {
         result.push_back(sp.get());
@@ -132,7 +132,7 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
 
   // Fill these memory blobs.
   auto fillSPArray = [](Details::SpacePoint* array, const auto& spVec) {
-    for (std::size_t i = 0; i < spVec.size(); ++i) {
+    for (size_t i = 0; i < spVec.size(); ++i) {
       array[i].x = spVec[i]->x();
       array[i].y = spVec[i]->y();
       array[i].z = spVec[i]->z();
@@ -172,9 +172,9 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
   // Matrices holding the indices of the viable bottom-middle and middle-top
   // pairs.
   auto middleBottomDublets =
-      make_device_array<std::size_t>(middleSPVec.size() * bottomSPVec.size());
+      make_device_array<size_t>(middleSPVec.size() * bottomSPVec.size());
   auto middleTopDublets =
-      make_device_array<std::size_t>(middleSPVec.size() * topSPVec.size());
+      make_device_array<size_t>(middleSPVec.size() * topSPVec.size());
 
   // Launch the dublet finding code.
   Details::findDublets(
@@ -209,7 +209,7 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
   assert(tripletCandidates.size() == middleSPVec.size());
 
   // Perform the final step of the filtering.
-  std::size_t middleIndex = 0;
+  size_t middleIndex = 0;
   auto triplet_itr = tripletCandidates.begin();
   auto triplet_end = tripletCandidates.end();
   for (; triplet_itr != triplet_end; ++triplet_itr, ++middleIndex) {
@@ -230,7 +230,7 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
         candidates.begin(), candidates.end(),
         CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>::
             descendingByQuality);
-    std::size_t numQualitySeeds = 0;  // not used but needs to be fixed
+    size_t numQualitySeeds = 0;  // not used but needs to be fixed
     m_commonConfig.seedFilter->filterSeeds_1SpFixed(
         spacePointData, candidates, numQualitySeeds,
         std::back_inserter(outputVec));
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/Arrays.hpp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/Arrays.hpp
index c08e480a185..a9cd2638f53 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/Arrays.hpp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/Arrays.hpp
@@ -46,7 +46,7 @@ using device_array = std::unique_ptr<T, Details::DeviceArrayDeleter>;
 
 /// Function creating a primitive array in CUDA device memory
 template <typename T>
-device_array<T> make_device_array(std::size_t size);
+device_array<T> make_device_array(size_t size);
 
 /// Convenience type for using primitive variable arrays on the host
 template <typename T>
@@ -54,27 +54,27 @@ using host_array = std::unique_ptr<T, Details::HostArrayDeleter>;
 
 /// Function creating a primitive array in the host's memory
 template <typename T>
-host_array<T> make_host_array(std::size_t size);
+host_array<T> make_host_array(size_t size);
 
 /// Copy one array from the host to the device
 template <typename T>
 void copyToDevice(device_array<T>& dev, const host_array<T>& host,
-                  std::size_t arraySize);
+                  size_t arraySize);
 
 /// Copy one array from the host to the device asynchronously
 template <typename T>
 void copyToDevice(device_array<T>& dev, const host_array<T>& host,
-                  std::size_t arraySize, const StreamWrapper& stream);
+                  size_t arraySize, const StreamWrapper& stream);
 
 /// Copy one array from the device to the host
 template <typename T>
 void copyToHost(host_array<T>& host, const device_array<T>& dev,
-                std::size_t arraySize);
+                size_t arraySize);
 
 /// Copy one array from the device to the host asynchronously
 template <typename T>
 void copyToHost(host_array<T>& host, const device_array<T>& dev,
-                std::size_t arraySize, const StreamWrapper& stream);
+                size_t arraySize, const StreamWrapper& stream);
 
 }  // namespace Cuda
 }  // namespace Acts
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/Info.hpp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/Info.hpp
index 989aea2e2df..14352725a2d 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/Info.hpp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/Info.hpp
@@ -51,7 +51,7 @@ class Info {
     /// Whether the device supports multiple kernel executions in parallel
     bool concurrentKernels = false;
     /// The total amount of (global) memory on the device
-    std::size_t totalMemory = 0;
+    size_t totalMemory = 0;
   };  // struct Device
 
   /// Get all the available CUDA devices
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/MemoryManager.hpp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/MemoryManager.hpp
index 6225cf4f7a3..746338f3b77 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/MemoryManager.hpp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Utilities/MemoryManager.hpp
@@ -60,7 +60,7 @@ class MemoryManager {
   static MemoryManager& instance();
 
   /// Set the amount of memory to use on a particular device
-  void setMemorySize(std::size_t sizeInBytes, int device = -1);
+  void setMemorySize(size_t sizeInBytes, int device = -1);
 
   /// @}
 
@@ -68,10 +68,10 @@ class MemoryManager {
   /// @{
 
   /// Get the amount of memory still available on a specific device
-  std::size_t availableMemory(int device = -1) const;
+  size_t availableMemory(int device = -1) const;
 
   /// Get a pointer to an available memory block on the device
-  void* allocate(std::size_t sizeInBytes, int device = -1);
+  void* allocate(size_t sizeInBytes, int device = -1);
 
   /// Reset all allocations
   void reset(int device = -1);
@@ -86,7 +86,7 @@ class MemoryManager {
   /// device
   struct DeviceMemory {
     /// The amount of memory allocated on the CUDA device
-    std::size_t m_size = 0;
+    size_t m_size = 0;
     /// Pointer to the beginning of the memory allocation
     char* m_ptr = nullptr;
     /// Pointer to the next available memory block in the "current round"
diff --git a/Plugins/Cuda/src/Seeding2/CountDublets.cu b/Plugins/Cuda/src/Seeding2/CountDublets.cu
index 2d63aa09982..56a2950a9e2 100644
--- a/Plugins/Cuda/src/Seeding2/CountDublets.cu
+++ b/Plugins/Cuda/src/Seeding2/CountDublets.cu
@@ -36,7 +36,7 @@ namespace Kernels {
 /// @param[out] dubletCounts 1-D array of @c Acts::Cuda::Details::DubletCounts
 ///             objects for each execution block
 ///
-__global__ void countDublets(std::size_t nMiddleSPs,
+__global__ void countDublets(size_t nMiddleSPs,
                              const unsigned int* middleBottomCounts,
                              const unsigned int* middleTopCounts,
                              Details::DubletCounts* dubletCounts) {
@@ -101,7 +101,7 @@ __global__ void countDublets(std::size_t nMiddleSPs,
 namespace Details {
 
 DubletCounts countDublets(
-    std::size_t maxBlockSize, std::size_t nMiddleSP,
+    size_t maxBlockSize, size_t nMiddleSP,
     const device_array<unsigned int>& middleBottomCountArray,
     const device_array<unsigned int>& middleTopCountArray) {
   // Calculate the parallelisation for the dublet counting.
diff --git a/Plugins/Cuda/src/Seeding2/FindDublets.cu b/Plugins/Cuda/src/Seeding2/FindDublets.cu
index cec93c50f00..a8b6b96c9c1 100644
--- a/Plugins/Cuda/src/Seeding2/FindDublets.cu
+++ b/Plugins/Cuda/src/Seeding2/FindDublets.cu
@@ -107,16 +107,16 @@ __device__ float getCotTheta<TopSP>(float middleZ, float topZ, float deltaR) {
 ///             the "other" spacepoint indices for the identified dublets
 ///
 template <int SPType>
-__global__ void findDublets(std::size_t nMiddleSPs,
+__global__ void findDublets(size_t nMiddleSPs,
                             const Details::SpacePoint* middleSPs,
-                            std::size_t nOtherSPs,
+                            size_t nOtherSPs,
                             const Details::SpacePoint* otherSPs,
                             float deltaRMin, float deltaRMax, float cotThetaMax,
                             float collisionRegionMin, float collisionRegionMax,
-                            unsigned int* dubletCounts, std::size_t* dublets) {
+                            unsigned int* dubletCounts, size_t* dublets) {
   // Figure out which dublet the kernel operates on.
-  const std::size_t middleIndex = blockIdx.x * blockDim.x + threadIdx.x;
-  const std::size_t otherIndex = blockIdx.y * blockDim.y + threadIdx.y;
+  const size_t middleIndex = blockIdx.x * blockDim.x + threadIdx.x;
+  const size_t otherIndex = blockIdx.y * blockDim.y + threadIdx.y;
 
   // If we're outside of bounds, stop here.
   if ((middleIndex >= nMiddleSPs) || (otherIndex >= nOtherSPs)) {
@@ -150,17 +150,16 @@ __global__ void findDublets(std::size_t nMiddleSPs,
 
 namespace Details {
 
-void findDublets(std::size_t maxBlockSize, std::size_t nBottomSPs,
-                 const device_array<SpacePoint>& bottomSPs,
-                 std::size_t nMiddleSPs,
-                 const device_array<SpacePoint>& middleSPs, std::size_t nTopSPs,
+void findDublets(size_t maxBlockSize, size_t nBottomSPs,
+                 const device_array<SpacePoint>& bottomSPs, size_t nMiddleSPs,
+                 const device_array<SpacePoint>& middleSPs, size_t nTopSPs,
                  const device_array<SpacePoint>& topSPs, float deltaRMin,
                  float deltaRMax, float cotThetaMax, float collisionRegionMin,
                  float collisionRegionMax,
                  device_array<unsigned int>& middleBottomCounts,
-                 device_array<std::size_t>& middleBottomDublets,
+                 device_array<size_t>& middleBottomDublets,
                  device_array<unsigned int>& middleTopCounts,
-                 device_array<std::size_t>& middleTopDublets) {
+                 device_array<size_t>& middleTopDublets) {
   // Calculate the parallelisation for the middle<->bottom spacepoint
   // compatibility flagging.
   const dim3 blockSizeMB(1, maxBlockSize);
diff --git a/Plugins/Cuda/src/Seeding2/FindTriplets.cu b/Plugins/Cuda/src/Seeding2/FindTriplets.cu
index fa20df5faa6..2fa4cf45127 100644
--- a/Plugins/Cuda/src/Seeding2/FindTriplets.cu
+++ b/Plugins/Cuda/src/Seeding2/FindTriplets.cu
@@ -114,13 +114,11 @@ __device__ Details::LinCircle transformCoordinates(
 ///
 __global__ void transformCoordinates(
     unsigned int nDublets, unsigned int maxMBDublets, unsigned int maxMTDublets,
-    std::size_t nBottomSPs, const Details::SpacePoint* bottomSPs,
-    std::size_t nMiddleSPs, const Details::SpacePoint* middleSPs,
-    std::size_t nTopSPs, const Details::SpacePoint* topSPs,
-    const unsigned int* middleBottomCounts,
-    const std::size_t* middleBottomDublets, const unsigned int* middleTopCounts,
-    const std::size_t* middleTopDublets,
-    Details::LinCircle* bottomSPLinTransArray,
+    size_t nBottomSPs, const Details::SpacePoint* bottomSPs, size_t nMiddleSPs,
+    const Details::SpacePoint* middleSPs, size_t nTopSPs,
+    const Details::SpacePoint* topSPs, const unsigned int* middleBottomCounts,
+    const size_t* middleBottomDublets, const unsigned int* middleTopCounts,
+    const size_t* middleTopDublets, Details::LinCircle* bottomSPLinTransArray,
     Details::LinCircle* topSPLinTransArray) {
   // Get the global index.
   const int dubletIndex = blockIdx.x * blockDim.x + threadIdx.x;
@@ -131,7 +129,7 @@ __global__ void transformCoordinates(
   }
 
   // Find the dublet to transform.
-  std::size_t middleIndex = 0;
+  size_t middleIndex = 0;
   int runningIndex = dubletIndex;
   int tmpValue = 0;
   while (runningIndex >= (tmpValue = (middleBottomCounts[middleIndex] +
@@ -142,13 +140,13 @@ __global__ void transformCoordinates(
   }
   const bool transformBottom =
       ((runningIndex < middleBottomCounts[middleIndex]) ? true : false);
-  const std::size_t bottomMatrixIndex = (transformBottom ? runningIndex : 0);
-  const std::size_t topMatrixIndex =
+  const size_t bottomMatrixIndex = (transformBottom ? runningIndex : 0);
+  const size_t topMatrixIndex =
       (transformBottom ? 0 : runningIndex - middleBottomCounts[middleIndex]);
 
   // Perform the transformation.
   if (transformBottom) {
-    const std::size_t bottomIndex =
+    const size_t bottomIndex =
         ACTS_CUDA_MATRIX2D_ELEMENT(middleBottomDublets, nMiddleSPs, nBottomSPs,
                                    middleIndex, bottomMatrixIndex);
     assert(bottomIndex < nBottomSPs);
@@ -157,7 +155,7 @@ __global__ void transformCoordinates(
         transformCoordinates(middleSPs[middleIndex], bottomSPs[bottomIndex],
                              true);
   } else {
-    const std::size_t topIndex = ACTS_CUDA_MATRIX2D_ELEMENT(
+    const size_t topIndex = ACTS_CUDA_MATRIX2D_ELEMENT(
         middleTopDublets, nMiddleSPs, nTopSPs, middleIndex, topMatrixIndex);
     assert(topIndex < nTopSPs);
     ACTS_CUDA_MATRIX2D_ELEMENT(topSPLinTransArray, nMiddleSPs, maxMTDublets,
@@ -220,20 +218,19 @@ __global__ void transformCoordinates(
 ///             candidates
 ///
 __global__ void findTriplets(
-    std::size_t middleIndexStart, unsigned int maxMBDublets,
+    size_t middleIndexStart, unsigned int maxMBDublets,
     unsigned int maxMTDublets, unsigned int maxTriplets,
-    std::size_t nParallelMiddleSPs, std::size_t nMiddleSPsProcessed,
-    std::size_t nBottomSPs, const Details::SpacePoint* bottomSPs,
-    std::size_t nMiddleSPs, const Details::SpacePoint* middleSPs,
-    std::size_t nTopSPs, const Details::SpacePoint* topSPs,
-    const unsigned int* middleBottomCounts,
-    const std::size_t* middleBottomDublets, const unsigned int* middleTopCounts,
-    const std::size_t* middleTopDublets,
+    size_t nParallelMiddleSPs, size_t nMiddleSPsProcessed, size_t nBottomSPs,
+    const Details::SpacePoint* bottomSPs, size_t nMiddleSPs,
+    const Details::SpacePoint* middleSPs, size_t nTopSPs,
+    const Details::SpacePoint* topSPs, const unsigned int* middleBottomCounts,
+    const size_t* middleBottomDublets, const unsigned int* middleTopCounts,
+    const size_t* middleTopDublets,
     const Details::LinCircle* bottomSPLinTransArray,
     const Details::LinCircle* topSPLinTransArray, float maxScatteringAngle2,
     float sigmaScattering, float minHelixDiameter2, float pT2perRadius,
     float impactMax, float impactWeightFactor,
-    unsigned int* tripletsPerBottomDublet, std::size_t* tripletIndices,
+    unsigned int* tripletsPerBottomDublet, size_t* tripletIndices,
     unsigned int* maxTripletsPerSpB, unsigned int* tripletCount,
     Details::Triplet* triplets) {
   // A sanity check.
@@ -439,18 +436,17 @@ __global__ void findTriplets(
 __global__ void filterTriplets2Sp(
     TripletFilterConfig::seedWeightFunc_t seedWeight,
     TripletFilterConfig::singleSeedCutFunc_t singleSeedCut,
-    std::size_t middleIndexStart, unsigned int maxMBDublets,
+    size_t middleIndexStart, unsigned int maxMBDublets,
     unsigned int maxMTDublets, unsigned int maxTriplets,
-    unsigned int nAllTriplets, std::size_t nParallelMiddleSPs,
-    std::size_t nMiddleSPsProcessed, unsigned int* middleBottomCounts,
-    std::size_t nBottomSPs, const Details::SpacePoint* bottomSPs,
-    std::size_t nMiddleSPs, const Details::SpacePoint* middleSPs,
-    std::size_t nTopSPs, const Details::SpacePoint* topSPs,
-    const unsigned int* tripletsPerBottomDublet,
-    const std::size_t* tripletIndices, const Details::Triplet* allTriplets,
-    float deltaInvHelixDiameter, float deltaRMin, float compatSeedWeight,
-    std::size_t compatSeedLimit, unsigned int* nFilteredTriplets,
-    Details::Triplet* filteredTriplets) {
+    unsigned int nAllTriplets, size_t nParallelMiddleSPs,
+    size_t nMiddleSPsProcessed, unsigned int* middleBottomCounts,
+    size_t nBottomSPs, const Details::SpacePoint* bottomSPs, size_t nMiddleSPs,
+    const Details::SpacePoint* middleSPs, size_t nTopSPs,
+    const Details::SpacePoint* topSPs,
+    const unsigned int* tripletsPerBottomDublet, const size_t* tripletIndices,
+    const Details::Triplet* allTriplets, float deltaInvHelixDiameter,
+    float deltaRMin, float compatSeedWeight, size_t compatSeedLimit,
+    unsigned int* nFilteredTriplets, Details::Triplet* filteredTriplets) {
   // Sanity checks.
   assert(seedWeight != nullptr);
   assert(singleSeedCut != nullptr);
@@ -482,7 +478,7 @@ __global__ void filterTriplets2Sp(
   }
 
   // Get the index of this triplet.
-  const std::size_t triplet1Index = ACTS_CUDA_MATRIX3D_ELEMENT(
+  const size_t triplet1Index = ACTS_CUDA_MATRIX3D_ELEMENT(
       tripletIndices, nParallelMiddleSPs, maxMBDublets, maxMTDublets,
       middleIndexOffset, bottomDubletIndex, tripletCandidateIndex);
   assert(triplet1Index < nAllTriplets);
@@ -499,20 +495,20 @@ __global__ void filterTriplets2Sp(
   // limit is coming from @c compatSeedLimit anyway, this could potentially be
   // re-written with an array allocation, instead of statically defining the
   // array's size.
-  static constexpr std::size_t MAX_TOP_SP = 10;
+  static constexpr size_t MAX_TOP_SP = 10;
   assert(compatSeedLimit < MAX_TOP_SP);
   float compatibleSeedR[MAX_TOP_SP];
-  std::size_t nCompatibleSeedR = 0;
+  size_t nCompatibleSeedR = 0;
 
   // Loop over all the other triplets found for this bottom-middle dublet.
-  for (std::size_t i = 0; i < nTripletsForMiddleBottom; ++i) {
+  for (size_t i = 0; i < nTripletsForMiddleBottom; ++i) {
     // Don't consider the same triplet that the thread is evaluating in the
     // first place.
     if (i == tripletCandidateIndex) {
       continue;
     }
     // Get the index of the second triplet.
-    const std::size_t triplet2Index = ACTS_CUDA_MATRIX3D_ELEMENT(
+    const size_t triplet2Index = ACTS_CUDA_MATRIX3D_ELEMENT(
         tripletIndices, nParallelMiddleSPs, maxMBDublets, maxMTDublets,
         middleIndexOffset, bottomDubletIndex, i);
     assert(triplet2Index < nAllTriplets);
@@ -540,7 +536,7 @@ __global__ void filterTriplets2Sp(
     }
 
     bool newCompSeed = true;
-    for (std::size_t k = 0; k < nCompatibleSeedR; ++k) {
+    for (size_t k = 0; k < nCompatibleSeedR; ++k) {
       // original ATLAS code uses higher min distance for 2nd found compatible
       // seed (20mm instead of 5mm)
       // add new compatible seed only if distance larger than rmin to all
@@ -581,18 +577,18 @@ __global__ void filterTriplets2Sp(
 namespace Details {
 
 std::vector<std::vector<Triplet>> findTriplets(
-    const Info::Device& device, std::size_t maxBlockSize,
+    const Info::Device& device, size_t maxBlockSize,
     const DubletCounts& dubletCounts, const SeedFilterConfig& seedConfig,
-    const TripletFilterConfig& filterConfig, std::size_t nBottomSPs,
-    const device_array<SpacePoint>& bottomSPs, std::size_t nMiddleSPs,
-    const device_array<SpacePoint>& middleSPs, std::size_t nTopSPs,
+    const TripletFilterConfig& filterConfig, size_t nBottomSPs,
+    const device_array<SpacePoint>& bottomSPs, size_t nMiddleSPs,
+    const device_array<SpacePoint>& middleSPs, size_t nTopSPs,
     const device_array<SpacePoint>& topSPs,
     const device_array<unsigned int>& middleBottomCounts,
-    const device_array<std::size_t>& middleBottomDublets,
+    const device_array<size_t>& middleBottomDublets,
     const device_array<unsigned int>& middleTopCounts,
-    const device_array<std::size_t>& middleTopDublets,
-    float maxScatteringAngle2, float sigmaScattering, float minHelixDiameter2,
-    float pT2perRadius, float impactMax) {
+    const device_array<size_t>& middleTopDublets, float maxScatteringAngle2,
+    float sigmaScattering, float minHelixDiameter2, float pT2perRadius,
+    float impactMax) {
   // Calculate the parallelisation for the parameter transformation.
   const int numBlocksLT =
       (dubletCounts.nDublets + maxBlockSize - 1) / maxBlockSize;
@@ -618,20 +614,19 @@ std::vector<std::vector<Triplet>> findTriplets(
   // finding/filtering.
 
   // For one middle spacepoint we need the following amount:
-  const std::size_t memorySizePerMiddleSP =
+  const size_t memorySizePerMiddleSP =
       // First let's consider the storage of the triplet objects themselves.
       2 * dubletCounts.maxTriplets * sizeof(Triplet) +
       // Then the objects holding indices to the triplets per middle-bottom
       // dublet.
       dubletCounts.maxMBDublets * sizeof(unsigned int) +
-      dubletCounts.maxMBDublets * dubletCounts.maxMTDublets *
-          sizeof(std::size_t) +
+      dubletCounts.maxMBDublets * dubletCounts.maxMTDublets * sizeof(size_t) +
       // Finally the array holding the filtered triplet counts per middle
       // spacepoint.
       sizeof(unsigned int);
 
   // See how many we can fit into the (still) available memory.
-  const std::size_t nParallelMiddleSPs =
+  const size_t nParallelMiddleSPs =
       std::min(MemoryManager::instance().availableMemory(device.id) /
                    memorySizePerMiddleSP,
                nMiddleSPs);
@@ -673,9 +668,9 @@ std::vector<std::vector<Triplet>> findTriplets(
 
   // Allocate the array holding the indices of the triplets found for a given
   // bottom-middle spacepoint combination.
-  auto tripletIndices = make_device_array<std::size_t>(
-      nParallelMiddleSPs * dubletCounts.maxMBDublets *
-      dubletCounts.maxMTDublets);
+  auto tripletIndices =
+      make_device_array<size_t>(nParallelMiddleSPs * dubletCounts.maxMBDublets *
+                                dubletCounts.maxMTDublets);
 
   // Allocate and initialise the arrays holding the per-middle-spacepoint
   // filtered triplet counts.
@@ -689,7 +684,7 @@ std::vector<std::vector<Triplet>> findTriplets(
       make_device_array<unsigned int>(nParallelMiddleSPs);
 
   // Block size used in the triplet finding.
-  const std::size_t blockSize = std::sqrt(maxBlockSize);
+  const size_t blockSize = std::sqrt(maxBlockSize);
 
   // Create the result object.
   std::vector<std::vector<Triplet>> result(nMiddleSPs);
@@ -702,7 +697,7 @@ std::vector<std::vector<Triplet>> findTriplets(
 
   // Execute the triplet finding and filtering in the maximal allowed groups of
   // middle spacepoints.
-  for (std::size_t middleIndex = 0; middleIndex < nMiddleSPs;
+  for (size_t middleIndex = 0; middleIndex < nMiddleSPs;
        middleIndex += nParallelMiddleSPs) {
     // Reset the device arrays.
     copyToDevice(objectCounts, objectCountsHostNull, NObjectCountTypes);
@@ -710,7 +705,7 @@ std::vector<std::vector<Triplet>> findTriplets(
                  nParallelMiddleSPs * dubletCounts.maxMBDublets);
 
     // The number of middle spacepoints to process in this iteration.
-    const std::size_t nMiddleSPsProcessed =
+    const size_t nMiddleSPsProcessed =
         std::min(nParallelMiddleSPs, nMiddleSPs - middleIndex);
 
     // Calculate the parallelisation for the triplet finding for this collection
@@ -805,7 +800,7 @@ std::vector<std::vector<Triplet>> findTriplets(
         nFilteredTriplets * sizeof(Triplet), cudaMemcpyDeviceToHost));
 
     // Fill the output variable.
-    for (std::size_t i = 0; i < nFilteredTriplets; ++i) {
+    for (size_t i = 0; i < nFilteredTriplets; ++i) {
       // Access the triplet.
       const Triplet& triplet = filteredTripletsHost.get()[i];
       // Put it into the output object.
diff --git a/Plugins/Cuda/src/Utilities/Arrays.cu b/Plugins/Cuda/src/Utilities/Arrays.cu
index 4418c44ae4b..dc6ad2add6b 100644
--- a/Plugins/Cuda/src/Utilities/Arrays.cu
+++ b/Plugins/Cuda/src/Utilities/Arrays.cu
@@ -44,7 +44,7 @@ void HostArrayDeleter::operator()(void* ptr) {
 }  // namespace Details
 
 template <typename T>
-device_array<T> make_device_array(std::size_t size) {
+device_array<T> make_device_array(size_t size) {
   // Allocate the memory.
   T* ptr = nullptr;
   if (size != 0) {
@@ -55,7 +55,7 @@ device_array<T> make_device_array(std::size_t size) {
 }
 
 template <typename T>
-host_array<T> make_host_array(std::size_t size) {
+host_array<T> make_host_array(size_t size) {
   // Allocate the memory.
   T* ptr = nullptr;
   if (size != 0) {
@@ -67,7 +67,7 @@ host_array<T> make_host_array(std::size_t size) {
 
 template <typename T>
 void copyToDevice(device_array<T>& dev, const host_array<T>& host,
-                  std::size_t arraySize) {
+                  size_t arraySize) {
   ACTS_CUDA_ERROR_CHECK(cudaMemcpy(dev.get(), host.get(), arraySize * sizeof(T),
                                    cudaMemcpyHostToDevice));
   return;
@@ -75,7 +75,7 @@ void copyToDevice(device_array<T>& dev, const host_array<T>& host,
 
 template <typename T>
 void copyToDevice(device_array<T>& dev, const host_array<T>& host,
-                  std::size_t arraySize, const StreamWrapper& stream) {
+                  size_t arraySize, const StreamWrapper& stream) {
   ACTS_CUDA_ERROR_CHECK(
       cudaMemcpyAsync(dev.get(), host.get(), arraySize * sizeof(T),
                       cudaMemcpyHostToDevice, getStreamFrom(stream)));
@@ -84,7 +84,7 @@ void copyToDevice(device_array<T>& dev, const host_array<T>& host,
 
 template <typename T>
 void copyToHost(host_array<T>& host, const device_array<T>& dev,
-                std::size_t arraySize) {
+                size_t arraySize) {
   ACTS_CUDA_ERROR_CHECK(cudaMemcpy(host.get(), dev.get(), arraySize * sizeof(T),
                                    cudaMemcpyDeviceToHost));
   return;
@@ -92,7 +92,7 @@ void copyToHost(host_array<T>& host, const device_array<T>& dev,
 
 template <typename T>
 void copyToHost(host_array<T>& host, const device_array<T>& dev,
-                std::size_t arraySize, const StreamWrapper& stream) {
+                size_t arraySize, const StreamWrapper& stream) {
   ACTS_CUDA_ERROR_CHECK(
       cudaMemcpyAsync(host.get(), dev.get(), arraySize * sizeof(T),
                       cudaMemcpyDeviceToHost, getStreamFrom(stream)));
@@ -112,26 +112,26 @@ void copyToHost(host_array<T>& host, const device_array<T>& dev,
   template class std::unique_ptr<TYPE,                                         \
                                  Acts::Cuda::Details::DeviceArrayDeleter>;     \
   template std::unique_ptr<TYPE, Acts::Cuda::Details::DeviceArrayDeleter>      \
-      Acts::Cuda::make_device_array<TYPE>(std::size_t);                        \
+      Acts::Cuda::make_device_array<TYPE>(size_t);                             \
   template class std::unique_ptr<TYPE, Acts::Cuda::Details::HostArrayDeleter>; \
   template std::unique_ptr<TYPE, Acts::Cuda::Details::HostArrayDeleter>        \
-      Acts::Cuda::make_host_array<TYPE>(std::size_t);                          \
+      Acts::Cuda::make_host_array<TYPE>(size_t);                               \
   template void Acts::Cuda::copyToDevice<TYPE>(                                \
       std::unique_ptr<TYPE, Acts::Cuda::Details::DeviceArrayDeleter>&,         \
       const std::unique_ptr<TYPE, Acts::Cuda::Details::HostArrayDeleter>&,     \
-      std::size_t);                                                            \
+      size_t);                                                                 \
   template void Acts::Cuda::copyToDevice<TYPE>(                                \
       std::unique_ptr<TYPE, Acts::Cuda::Details::DeviceArrayDeleter>&,         \
       const std::unique_ptr<TYPE, Acts::Cuda::Details::HostArrayDeleter>&,     \
-      std::size_t, const Acts::Cuda::StreamWrapper&);                          \
+      size_t, const Acts::Cuda::StreamWrapper&);                               \
   template void Acts::Cuda::copyToHost<TYPE>(                                  \
       std::unique_ptr<TYPE, Acts::Cuda::Details::HostArrayDeleter>&,           \
       const std::unique_ptr<TYPE, Acts::Cuda::Details::DeviceArrayDeleter>&,   \
-      std::size_t);                                                            \
+      size_t);                                                                 \
   template void Acts::Cuda::copyToHost<TYPE>(                                  \
       std::unique_ptr<TYPE, Acts::Cuda::Details::HostArrayDeleter>&,           \
       const std::unique_ptr<TYPE, Acts::Cuda::Details::DeviceArrayDeleter>&,   \
-      std::size_t, const Acts::Cuda::StreamWrapper&)
+      size_t, const Acts::Cuda::StreamWrapper&)
 
 // Instantiate the templated functions for all primitive types.
 INST_ARRAY_FOR_TYPE(char);
diff --git a/Plugins/Cuda/src/Utilities/Info.cu b/Plugins/Cuda/src/Utilities/Info.cu
index 3ca375b6f47..1a5e460de8e 100644
--- a/Plugins/Cuda/src/Utilities/Info.cu
+++ b/Plugins/Cuda/src/Utilities/Info.cu
@@ -53,8 +53,8 @@ std::ostream& operator<<(std::ostream& out, const Info::Device& device) {
       << std::string(
              (39 > device.name.length() ? 39 - device.name.length() : 0), ' ')
       << "|" << std::endl;
-  const std::size_t threadDigits =
-      static_cast<std::size_t>(std::log10(device.maxThreadsPerBlock)) + 1;
+  const size_t threadDigits =
+      static_cast<size_t>(std::log10(device.maxThreadsPerBlock)) + 1;
   out << " | Max. threads per block: " << device.maxThreadsPerBlock
       << std::string((21 > threadDigits ? 21 - threadDigits : 0), ' ') << "|"
       << std::endl;
@@ -63,8 +63,7 @@ std::ostream& operator<<(std::ostream& out, const Info::Device& device) {
       << "|" << std::endl;
   static constexpr double MEGABYTES = 1.0 / (1024 * 1024);
   const double totalMem = device.totalMemory * MEGABYTES;
-  const std::size_t memDigits =
-      static_cast<std::size_t>(std::log10(totalMem)) + 1;
+  const size_t memDigits = static_cast<size_t>(std::log10(totalMem)) + 1;
   out << " | Total memory: " << totalMem << " MB"
       << std::string((25 > memDigits ? 25 - memDigits : 0), ' ') << "|"
       << std::endl;
diff --git a/Plugins/Cuda/src/Utilities/MemoryManager.cu b/Plugins/Cuda/src/Utilities/MemoryManager.cu
index ae623be672d..3929d14e21e 100644
--- a/Plugins/Cuda/src/Utilities/MemoryManager.cu
+++ b/Plugins/Cuda/src/Utilities/MemoryManager.cu
@@ -36,7 +36,7 @@ MemoryManager& MemoryManager::instance() {
   return mm;
 }
 
-void MemoryManager::setMemorySize(std::size_t sizeInBytes, int device) {
+void MemoryManager::setMemorySize(size_t sizeInBytes, int device) {
   // If the user didn't ask for a specific device, use the one currently used by
   // CUDA.
   if (device == -1) {
@@ -44,7 +44,7 @@ void MemoryManager::setMemorySize(std::size_t sizeInBytes, int device) {
   }
 
   // Make sure that the internal storage variable is large enough.
-  if (static_cast<std::size_t>(device) >= m_memory.size()) {
+  if (static_cast<size_t>(device) >= m_memory.size()) {
     m_memory.resize(device + 1);
   }
 
@@ -66,7 +66,7 @@ void MemoryManager::setMemorySize(std::size_t sizeInBytes, int device) {
   return;
 }
 
-std::size_t MemoryManager::availableMemory(int device) const {
+size_t MemoryManager::availableMemory(int device) const {
   // If the user didn't ask for a specific device, use the one currently used by
   // CUDA.
   if (device == -1) {
@@ -74,7 +74,7 @@ std::size_t MemoryManager::availableMemory(int device) const {
   }
 
   // Make sure that memory was allocated on the requested device.
-  if (m_memory.size() <= static_cast<std::size_t>(device)) {
+  if (m_memory.size() <= static_cast<size_t>(device)) {
     throw std::bad_alloc();
   }
   const DeviceMemory& mem = m_memory[device];
@@ -83,7 +83,7 @@ std::size_t MemoryManager::availableMemory(int device) const {
   return (mem.m_size - (mem.m_nextAllocation - mem.m_ptr));
 }
 
-void* MemoryManager::allocate(std::size_t sizeInBytes, int device) {
+void* MemoryManager::allocate(size_t sizeInBytes, int device) {
   // If the user didn't ask for a specific device, use the one currently used by
   // CUDA.
   if (device == -1) {
@@ -91,7 +91,7 @@ void* MemoryManager::allocate(std::size_t sizeInBytes, int device) {
   }
 
   // Make sure that memory was allocated on the requested device.
-  if (m_memory.size() <= static_cast<std::size_t>(device)) {
+  if (m_memory.size() <= static_cast<size_t>(device)) {
     throw std::bad_alloc();
   }
   DeviceMemory& mem = m_memory[device];
@@ -100,9 +100,9 @@ void* MemoryManager::allocate(std::size_t sizeInBytes, int device) {
   void* result = mem.m_nextAllocation;
 
   // Make sure that all addresses given out are 8-byte aligned.
-  static constexpr std::size_t ALIGN_SIZE = 8;
-  const std::size_t misalignment = sizeInBytes % ALIGN_SIZE;
-  const std::size_t padding =
+  static constexpr size_t ALIGN_SIZE = 8;
+  const size_t misalignment = sizeInBytes % ALIGN_SIZE;
+  const size_t padding =
       ((misalignment != 0) ? (ALIGN_SIZE - misalignment) : 0);
 
   // Increment the internal pointer.
@@ -124,7 +124,7 @@ void MemoryManager::reset(int device) {
   }
 
   // Make sure that memory was allocated on the requested device.
-  if (m_memory.size() <= static_cast<std::size_t>(device)) {
+  if (m_memory.size() <= static_cast<size_t>(device)) {
     throw std::bad_alloc();
   }
   DeviceMemory& mem = m_memory[device];
diff --git a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepDetectorSurfaceFactory.hpp b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepDetectorSurfaceFactory.hpp
index 5bb080acfea..18a4861b1c6 100644
--- a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepDetectorSurfaceFactory.hpp
+++ b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepDetectorSurfaceFactory.hpp
@@ -54,9 +54,9 @@ class DD4hepDetectorSurfaceFactory {
     /// The created non-const surfaces - for further processing,
     std::vector<DD4hepPassiveSurface> passiveSurfaces;
     /// matching and conversion statistics: surfaces
-    std::size_t convertedSurfaces = 0;
+    size_t convertedSurfaces = 0;
     /// matching and conversion statistics: materials
-    std::size_t convertedMaterials = 0;
+    size_t convertedMaterials = 0;
     /// The collected binnings
     std::vector<Experimental::ProtoBinning> binnings = {};
     /// The collected supports
diff --git a/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/OnnxMetricLearning.hpp b/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/OnnxMetricLearning.hpp
index 26af6fb3619..1856339a236 100644
--- a/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/OnnxMetricLearning.hpp
+++ b/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/OnnxMetricLearning.hpp
@@ -35,7 +35,7 @@ class OnnxMetricLearning final : public Acts::GraphConstructionBase {
   ~OnnxMetricLearning();
 
   std::tuple<std::any, std::any> operator()(std::vector<float>& inputValues,
-                                            std::size_t numNodes,
+                                            size_t numNodes,
                                             int deviceHint = -1) override;
 
   Config config() const { return m_cfg; }
diff --git a/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/Stages.hpp b/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/Stages.hpp
index 048f56bfd3c..64d146d9391 100644
--- a/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/Stages.hpp
+++ b/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/Stages.hpp
@@ -29,7 +29,7 @@ class GraphConstructionBase {
   ///
   /// @return (node_tensor, edge_tensore)
   virtual std::tuple<std::any, std::any> operator()(
-      std::vector<float> &inputValues, std::size_t numNodes,
+      std::vector<float> &inputValues, size_t numNodes,
       int deviceHint = -1) = 0;
 
   virtual ~GraphConstructionBase() = default;
diff --git a/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/TorchMetricLearning.hpp b/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/TorchMetricLearning.hpp
index 886687787cf..9a86ab4f11f 100644
--- a/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/TorchMetricLearning.hpp
+++ b/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/TorchMetricLearning.hpp
@@ -38,7 +38,7 @@ class TorchMetricLearning final : public Acts::GraphConstructionBase {
   ~TorchMetricLearning();
 
   std::tuple<std::any, std::any> operator()(std::vector<float> &inputValues,
-                                            std::size_t numNodes,
+                                            size_t numNodes,
                                             int deviceHint = -1) override;
 
   Config config() const { return m_cfg; }
diff --git a/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/detail/TensorVectorConversion.hpp b/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/detail/TensorVectorConversion.hpp
index 4f5de7009f2..d5d8a1c9a8a 100644
--- a/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/detail/TensorVectorConversion.hpp
+++ b/Plugins/ExaTrkX/include/Acts/Plugins/ExaTrkX/detail/TensorVectorConversion.hpp
@@ -57,7 +57,7 @@ struct TorchTypeMap<double> {
 /// @Note Tensor does not take ownership! `.clone()` afterwards to get
 /// ownership of the data
 template <typename T>
-at::Tensor vectorToTensor2D(std::vector<T> &vec, std::size_t cols) {
+at::Tensor vectorToTensor2D(std::vector<T> &vec, size_t cols) {
   assert(vec.size() % cols == 0);
 
   auto opts =
diff --git a/Plugins/ExaTrkX/src/BoostTrackBuilding.cpp b/Plugins/ExaTrkX/src/BoostTrackBuilding.cpp
index 01e80930960..4bd743867c3 100644
--- a/Plugins/ExaTrkX/src/BoostTrackBuilding.cpp
+++ b/Plugins/ExaTrkX/src/BoostTrackBuilding.cpp
@@ -57,7 +57,7 @@ std::vector<std::vector<int>> BoostTrackBuilding::operator()(
   assert(edgeTensor.size(1) == edgeWeightTensor.size(0));
 
   const auto numSpacepoints = spacepointIDs.size();
-  const auto numEdges = static_cast<std::size_t>(edgeWeightTensor.size(0));
+  const auto numEdges = static_cast<size_t>(edgeWeightTensor.size(0));
 
   if (numEdges == 0) {
     ACTS_WARNING("No edges remained after edge classification");
diff --git a/Plugins/ExaTrkX/src/OnnxMetricLearning.cpp b/Plugins/ExaTrkX/src/OnnxMetricLearning.cpp
index 9e59d5639ab..62b8492c545 100644
--- a/Plugins/ExaTrkX/src/OnnxMetricLearning.cpp
+++ b/Plugins/ExaTrkX/src/OnnxMetricLearning.cpp
@@ -57,7 +57,7 @@ void OnnxMetricLearning::buildEdgesWrapper(std::vector<float>& embedFeatures,
 }
 
 std::tuple<std::any, std::any> OnnxMetricLearning::operator()(
-    std::vector<float>& inputValues, std::size_t, int) {
+    std::vector<float>& inputValues, size_t, int) {
   Ort::AllocatorWithDefaultOptions allocator;
   auto memoryInfo = Ort::MemoryInfo::CreateCpu(
       OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault);
diff --git a/Plugins/ExaTrkX/src/TorchMetricLearning.cpp b/Plugins/ExaTrkX/src/TorchMetricLearning.cpp
index 6ffda448587..41ac2b19444 100644
--- a/Plugins/ExaTrkX/src/TorchMetricLearning.cpp
+++ b/Plugins/ExaTrkX/src/TorchMetricLearning.cpp
@@ -46,7 +46,7 @@ TorchMetricLearning::TorchMetricLearning(const Config &cfg,
 TorchMetricLearning::~TorchMetricLearning() {}
 
 std::tuple<std::any, std::any> TorchMetricLearning::operator()(
-    std::vector<float> &inputValues, std::size_t numNodes, int deviceHint) {
+    std::vector<float> &inputValues, size_t numNodes, int deviceHint) {
   ACTS_DEBUG("Start graph construction");
   c10::InferenceMode guard(true);
   const torch::Device device(m_deviceType, deviceHint);
diff --git a/Plugins/ExaTrkX/src/printCudaMemInfo.hpp b/Plugins/ExaTrkX/src/printCudaMemInfo.hpp
index 739c89c7921..41cb36265bf 100644
--- a/Plugins/ExaTrkX/src/printCudaMemInfo.hpp
+++ b/Plugins/ExaTrkX/src/printCudaMemInfo.hpp
@@ -27,7 +27,7 @@ inline void printCudaMemInfo(const Acts::Logger& logger) {
     constexpr float mb = kb * kb;
 
     int device;
-    std::size_t free, total;
+    size_t free, total;
     cudaMemGetInfo(&free, &total);
     cudaGetDevice(&device);
 
diff --git a/Plugins/FpeMonitoring/include/Acts/Plugins/FpeMonitoring/FpeMonitor.hpp b/Plugins/FpeMonitoring/include/Acts/Plugins/FpeMonitoring/FpeMonitor.hpp
index be26a113cac..c1f06ce38b6 100644
--- a/Plugins/FpeMonitoring/include/Acts/Plugins/FpeMonitoring/FpeMonitor.hpp
+++ b/Plugins/FpeMonitoring/include/Acts/Plugins/FpeMonitoring/FpeMonitor.hpp
@@ -40,7 +40,7 @@ std::ostream &operator<<(std::ostream &os, FpeType type);
 class FpeMonitor {
  public:
   struct Buffer {
-    Buffer(std::size_t bufferSize)
+    Buffer(size_t bufferSize)
         : m_data{std::make_unique<std::byte[]>(bufferSize)},
           m_size{bufferSize} {}
 
@@ -53,35 +53,35 @@ class FpeMonitor {
       other.m_offset = 0;
     }
 
-    std::pair<void *, std::size_t> next() {
+    std::pair<void *, size_t> next() {
       return {m_data.get() + m_offset, m_size - m_offset};
     }
 
-    void pushOffset(std::size_t offset) {
+    void pushOffset(size_t offset) {
       assert(m_offset + offset < m_size);
       m_offset = offset;
     }
 
     void reset() { m_offset = 0; }
 
-    std::size_t size() const { return m_size; }
-    std::size_t offset() const { return m_offset; }
+    size_t size() const { return m_size; }
+    size_t offset() const { return m_offset; }
 
     std::byte *data() { return m_data.get(); }
 
    private:
     std::unique_ptr<std::byte[]> m_data;
-    std::size_t m_size{};
-    std::size_t m_offset{};
+    size_t m_size{};
+    size_t m_offset{};
   };
 
   struct Result {
     struct FpeInfo {
-      std::size_t count;
+      size_t count;
       FpeType type;
       std::shared_ptr<const boost::stacktrace::stacktrace> st;
 
-      FpeInfo(std::size_t countIn, FpeType typeIn,
+      FpeInfo(size_t countIn, FpeType typeIn,
               std::shared_ptr<const boost::stacktrace::stacktrace> stIn);
       ~FpeInfo();
     };
@@ -99,15 +99,14 @@ class FpeMonitor {
 
     bool contains(FpeType type, const boost::stacktrace::stacktrace &st) const;
 
-    void summary(
-        std::ostream &os,
-        std::size_t depth = std::numeric_limits<std::size_t>::max()) const;
+    void summary(std::ostream &os,
+                 size_t depth = std::numeric_limits<size_t>::max()) const;
 
     Result() = default;
 
     operator bool() const { return !m_stracktraces.empty(); }
 
-    void add(Acts::FpeType type, void *stackPtr, std::size_t bufferSize);
+    void add(Acts::FpeType type, void *stackPtr, size_t bufferSize);
 
    private:
     std::vector<FpeInfo> m_stracktraces;
@@ -128,7 +127,7 @@ class FpeMonitor {
   void rearm();
 
   static std::string stackTraceToString(const boost::stacktrace::stacktrace &st,
-                                        std::size_t depth);
+                                        size_t depth);
   static std::string getSourceLocation(const boost::stacktrace::frame &frame);
 
  private:
@@ -152,7 +151,7 @@ class FpeMonitor {
 
   Buffer m_buffer{65536};
 
-  boost::container::static_vector<std::tuple<FpeType, void *, std::size_t>, 128>
+  boost::container::static_vector<std::tuple<FpeType, void *, size_t>, 128>
       m_recorded;
 };
 
diff --git a/Plugins/FpeMonitoring/src/FpeMonitor.cpp b/Plugins/FpeMonitoring/src/FpeMonitor.cpp
index a4bc1e079c1..6f1286f8a35 100644
--- a/Plugins/FpeMonitoring/src/FpeMonitor.cpp
+++ b/Plugins/FpeMonitoring/src/FpeMonitor.cpp
@@ -50,7 +50,7 @@ bool areFpesEquivalent(
 FpeMonitor::Result::FpeInfo::~FpeInfo() = default;
 
 FpeMonitor::Result::FpeInfo::FpeInfo(
-    std::size_t countIn, FpeType typeIn,
+    size_t countIn, FpeType typeIn,
     std::shared_ptr<const boost::stacktrace::stacktrace> stIn)
     : count{countIn}, type{typeIn}, st{std::move(stIn)} {}
 
@@ -82,8 +82,7 @@ void FpeMonitor::Result::merge(const Result &with) {
   deduplicate();
 }
 
-void FpeMonitor::Result::add(FpeType type, void *stackPtr,
-                             std::size_t bufferSize) {
+void FpeMonitor::Result::add(FpeType type, void *stackPtr, size_t bufferSize) {
   auto st = std::make_unique<boost::stacktrace::stacktrace>(
       boost::stacktrace::stacktrace::from_dump(stackPtr, bufferSize));
 
@@ -142,7 +141,7 @@ bool FpeMonitor::Result::encountered(FpeType type) const {
   return count(type) > 0;
 }
 
-void FpeMonitor::Result::summary(std::ostream &os, std::size_t depth) const {
+void FpeMonitor::Result::summary(std::ostream &os, size_t depth) const {
   os << "FPE result summary:\n";
   static const std::vector<FpeType> types = {
       FpeType::INTDIV, FpeType::INTOVF, FpeType::FLTDIV, FpeType::FLTOVF,
@@ -205,8 +204,8 @@ void FpeMonitor::signalHandler(int /*signal*/, siginfo_t *si, void *ctx) {
     // collect stack trace skipping 2 frames, which should be the signal handler
     // and the calling facility. This might be platform specific, not sure
     auto [buffer, remaining] = fpe.m_buffer.next();
-    std::size_t depth = boost::stacktrace::safe_dump_to(2, buffer, remaining);
-    std::size_t stored =
+    size_t depth = boost::stacktrace::safe_dump_to(2, buffer, remaining);
+    size_t stored =
         depth * sizeof(boost::stacktrace::frame::native_frame_ptr_t);
     fpe.m_buffer.pushOffset(stored);  // record how much storage was consumed
     fpe.m_recorded.emplace_back(
@@ -325,7 +324,7 @@ std::ostream &operator<<(std::ostream &os, FpeType type) {
 }
 
 std::string FpeMonitor::stackTraceToString(
-    const boost::stacktrace::stacktrace &st, std::size_t depth) {
+    const boost::stacktrace::stacktrace &st, size_t depth) {
   return boost::stacktrace::detail::to_string(st.as_vector().data(),
                                               std::min(depth, st.size()));
 }
diff --git a/Plugins/Geant4/include/Acts/Plugins/Geant4/Geant4DetectorSurfaceFactory.hpp b/Plugins/Geant4/include/Acts/Plugins/Geant4/Geant4DetectorSurfaceFactory.hpp
index 2dd866acc39..a78981143ee 100644
--- a/Plugins/Geant4/include/Acts/Plugins/Geant4/Geant4DetectorSurfaceFactory.hpp
+++ b/Plugins/Geant4/include/Acts/Plugins/Geant4/Geant4DetectorSurfaceFactory.hpp
@@ -52,11 +52,11 @@ class Geant4DetectorSurfaceFactory {
     /// The created non-const surfaces - for further processing,
     std::vector<Geant4PassiveSurface> passiveSurfaces;
     /// matching and conversion statistics: volumes
-    std::size_t matchedG4Volumes = 0;
+    size_t matchedG4Volumes = 0;
     /// matching and conversion statistics: surfaces
-    std::size_t convertedSurfaces = 0;
+    size_t convertedSurfaces = 0;
     /// matching and conversion statistics: materials
-    std::size_t convertedMaterials = 0;
+    size_t convertedMaterials = 0;
   };
 
   /// Nested option struct that allows per call changeable configuration
diff --git a/Plugins/Geant4/src/Geant4Converters.cpp b/Plugins/Geant4/src/Geant4Converters.cpp
index eaee932ecb8..8ece4d79a7d 100644
--- a/Plugins/Geant4/src/Geant4Converters.cpp
+++ b/Plugins/Geant4/src/Geant4Converters.cpp
@@ -153,7 +153,7 @@ Acts::Geant4ShapeConverter::rectangleBounds(const G4Box& g4Box) {
       static_cast<ActsScalar>(g4Box.GetZHalfLength())};
 
   auto minAt = std::min_element(hG4XYZ.begin(), hG4XYZ.end());
-  std::size_t minPos = std::distance(hG4XYZ.begin(), minAt);
+  size_t minPos = std::distance(hG4XYZ.begin(), minAt);
   ActsScalar thickness = 2. * hG4XYZ[minPos];
 
   std::array<int, 2u> rAxes = {};
@@ -191,7 +191,7 @@ Acts::Geant4ShapeConverter::trapezoidBounds(const G4Trd& g4Trd) {
                                   hlZ};
 
   auto minAt = std::min_element(dXYZ.begin(), dXYZ.end());
-  std::size_t minPos = std::distance(dXYZ.begin(), minAt);
+  size_t minPos = std::distance(dXYZ.begin(), minAt);
   ActsScalar thickness = 2. * dXYZ[minPos];
 
   ActsScalar halfLengthXminY = 0.;
diff --git a/Plugins/Geant4/src/Geant4DetectorSurfaceFactory.cpp b/Plugins/Geant4/src/Geant4DetectorSurfaceFactory.cpp
index 0b018e434ee..23c2f1f4c2c 100644
--- a/Plugins/Geant4/src/Geant4DetectorSurfaceFactory.cpp
+++ b/Plugins/Geant4/src/Geant4DetectorSurfaceFactory.cpp
@@ -34,8 +34,8 @@ void Acts::Geant4DetectorSurfaceFactory::construct(
 
   // Get the logical volume
   auto g4LogicalVolume = g4PhysVol.GetLogicalVolume();
-  std::size_t nDaughters = g4LogicalVolume->GetNoDaughters();
-  for (std::size_t d = 0; d < nDaughters; ++d) {
+  size_t nDaughters = g4LogicalVolume->GetNoDaughters();
+  for (size_t d = 0; d < nDaughters; ++d) {
     auto daughter = g4LogicalVolume->GetDaughter(d);
     construct(cache, newToGlobal, *daughter, option);
   }
diff --git a/Plugins/Json/include/Acts/Plugins/Json/GeometryHierarchyMapJsonConverter.hpp b/Plugins/Json/include/Acts/Plugins/Json/GeometryHierarchyMapJsonConverter.hpp
index bf6a6c4776f..ca27d2fd9c1 100644
--- a/Plugins/Json/include/Acts/Plugins/Json/GeometryHierarchyMapJsonConverter.hpp
+++ b/Plugins/Json/include/Acts/Plugins/Json/GeometryHierarchyMapJsonConverter.hpp
@@ -152,7 +152,7 @@ nlohmann::json GeometryHierarchyMapJsonConverter<value_t, decorator_t>::toJson(
   encoded[kHeaderKey]["value-identifier"] = m_valueIdentifier;
   // encode entries
   nlohmann::json entries = nlohmann::json::array();
-  for (std::size_t i = 0; i < container.size(); ++i) {
+  for (size_t i = 0; i < container.size(); ++i) {
     auto entry = encodeIdentifier(container.idAt(i));
     auto value_json = nlohmann::json(container.valueAt(i));
     if constexpr (!std::is_same<decorator_t, void>::value) {
diff --git a/Plugins/Json/include/Acts/Plugins/Json/GridJsonConverter.hpp b/Plugins/Json/include/Acts/Plugins/Json/GridJsonConverter.hpp
index 8c6c2b92d3d..63b5d449ef2 100644
--- a/Plugins/Json/include/Acts/Plugins/Json/GridJsonConverter.hpp
+++ b/Plugins/Json/include/Acts/Plugins/Json/GridJsonConverter.hpp
@@ -87,22 +87,22 @@ template <typename axis_generator_type>
 auto fromJson(const nlohmann::json& jGrid,
               const axis_generator_type& aGenerator) {
   // Generate the grid
-  using GridType = typename axis_generator_type::template grid_type<
-      std::vector<std::size_t>>;
+  using GridType =
+      typename axis_generator_type::template grid_type<std::vector<size_t>>;
   GridType grid(aGenerator());
   nlohmann::json jData = jGrid["data"];
   // Index filling
   if constexpr (GridType::DIM == 1u) {
     for (const auto& jd : jData) {
-      std::array<std::size_t, 1u> lbin = jd[0u];
-      std::vector<std::size_t> values = jd[1u];
+      std::array<size_t, 1u> lbin = jd[0u];
+      std::vector<size_t> values = jd[1u];
       grid.atLocalBins(lbin) = values;
     }
   }
   if constexpr (GridType::DIM == 2u) {
     for (const auto& jd : jData) {
-      std::array<std::size_t, 2u> lbin = jd[0u];
-      std::vector<std::size_t> values = jd[1u];
+      std::array<size_t, 2u> lbin = jd[0u];
+      std::vector<size_t> values = jd[1u];
       grid.atLocalBins(lbin) = values;
     }
   }
diff --git a/Plugins/Json/include/Acts/Plugins/Json/IndexedSurfacesJsonConverter.hpp b/Plugins/Json/include/Acts/Plugins/Json/IndexedSurfacesJsonConverter.hpp
index a99e579fb78..827e443b7d7 100644
--- a/Plugins/Json/include/Acts/Plugins/Json/IndexedSurfacesJsonConverter.hpp
+++ b/Plugins/Json/include/Acts/Plugins/Json/IndexedSurfacesJsonConverter.hpp
@@ -87,7 +87,7 @@ void convert(nlohmann::json& jIndexedSurfaces,
              const Experimental::SurfaceCandidatesUpdator& delegate,
              [[maybe_unused]] const instance_type& refInstance) {
   using GridType =
-      typename instance_type::template grid_type<std::vector<std::size_t>>;
+      typename instance_type::template grid_type<std::vector<size_t>>;
   // Defining a Delegate type
   using DelegateType = Experimental::IndexedSurfacesAllPortalsImpl<
       GridType, Experimental::IndexedSurfacesImpl>;
@@ -110,7 +110,7 @@ void convert(nlohmann::json& jIndexedSurfaces,
 /// @param axesTuple the tuple of axes to be unrolled
 ///
 /// @note parameters are as of the `convertImpl` method
-template <typename tuple_type, std::size_t... I>
+template <typename tuple_type, size_t... I>
 void unrollConvert(nlohmann::json& jIndexedSurfaces,
                    const Experimental::SurfaceCandidatesUpdator& delegate,
                    const tuple_type& axesTuple,
diff --git a/Plugins/Json/include/Acts/Plugins/Json/PortalJsonConverter.hpp b/Plugins/Json/include/Acts/Plugins/Json/PortalJsonConverter.hpp
index 7caab3476e8..fbf8125af95 100644
--- a/Plugins/Json/include/Acts/Plugins/Json/PortalJsonConverter.hpp
+++ b/Plugins/Json/include/Acts/Plugins/Json/PortalJsonConverter.hpp
@@ -62,8 +62,8 @@ nlohmann::json toJson(
 ///
 /// @return a json object
 std::vector<nlohmann::json> toJsonDetray(
-    const GeometryContext& gctx, const Experimental::Portal& portal,
-    std::size_t ip, const Experimental::DetectorVolume& volume,
+    const GeometryContext& gctx, const Experimental::Portal& portal, size_t ip,
+    const Experimental::DetectorVolume& volume,
     const OrientedSurfaces& orientedSurfaces,
     const std::vector<const Experimental::DetectorVolume*>& detectorVolumes,
     const Options& options = Options{});
diff --git a/Plugins/Json/src/DetectorJsonConverter.cpp b/Plugins/Json/src/DetectorJsonConverter.cpp
index bcfab95c99b..19d7a183038 100644
--- a/Plugins/Json/src/DetectorJsonConverter.cpp
+++ b/Plugins/Json/src/DetectorJsonConverter.cpp
@@ -32,7 +32,7 @@ nlohmann::json Acts::DetectorJsonConverter::toJson(
 
   nlohmann::json jDetector;
 
-  std::size_t nSurfaces = 0;
+  size_t nSurfaces = 0;
   std::vector<const Experimental::Portal*> portals;
 
   for (const auto* volume : detector.volumes()) {
@@ -93,7 +93,7 @@ nlohmann::json Acts::DetectorJsonConverter::toJsonDetray(
   nlohmann::json jDetector;
   nlohmann::json jData;
 
-  std::size_t nSurfaces = 0;
+  size_t nSurfaces = 0;
 
   auto volumes = detector.volumes();
 
@@ -115,7 +115,7 @@ nlohmann::json Acts::DetectorJsonConverter::toJsonDetray(
   nlohmann::json jVolumeGrid;
   nlohmann::json jVolumeGridAxes;
   jVolumeGrid["axes"] = jVolumeGridAxes;
-  jVolumeGrid["entries"] = std::vector<std::size_t>{};
+  jVolumeGrid["entries"] = std::vector<size_t>{};
   jVolumeGridParent["grid"] = jVolumeGrid;
   jData["volume_grid"] = jVolumeGridParent;
 
@@ -162,7 +162,7 @@ Acts::DetectorJsonConverter::fromJson(const GeometryContext& gctx,
   for (auto [iv, v] : enumerate(volumes)) {
     // Get the Volumes and update the portals with the loaded ones
     auto jVolume = jVolumes[iv];
-    std::vector<std::size_t> portalLinks = jVolume["portal_links"];
+    std::vector<size_t> portalLinks = jVolume["portal_links"];
     for (auto [ip, ipl] : enumerate(portalLinks)) {
       auto portal = portals[ipl];
       v->updatePortal(portal, ip);
diff --git a/Plugins/Json/src/IndexedSurfacesJsonConverter.cpp b/Plugins/Json/src/IndexedSurfacesJsonConverter.cpp
index 5bf4f33c8be..6958194224e 100644
--- a/Plugins/Json/src/IndexedSurfacesJsonConverter.cpp
+++ b/Plugins/Json/src/IndexedSurfacesJsonConverter.cpp
@@ -63,9 +63,9 @@ Acts::IndexedSurfacesJsonConverter::fromJson(
 
   // Helper extractor
   auto eqExtractor = [](const nlohmann::json& jAxis)
-      -> std::tuple<std::array<ActsScalar, 2u>, std::size_t> {
+      -> std::tuple<std::array<ActsScalar, 2u>, size_t> {
     std::array<ActsScalar, 2u> range = jAxis["range"];
-    std::size_t bins = jAxis["bins"];
+    size_t bins = jAxis["bins"];
     return std::make_tuple(range, bins);
   };
 
diff --git a/Plugins/Json/src/PortalJsonConverter.cpp b/Plugins/Json/src/PortalJsonConverter.cpp
index 594129eefcd..99b79c38095 100644
--- a/Plugins/Json/src/PortalJsonConverter.cpp
+++ b/Plugins/Json/src/PortalJsonConverter.cpp
@@ -67,8 +67,8 @@ nlohmann::json Acts::PortalJsonConverter::toJson(
 }
 
 std::vector<nlohmann::json> Acts::PortalJsonConverter::toJsonDetray(
-    const GeometryContext& gctx, const Experimental::Portal& portal,
-    std::size_t ip, const Experimental::DetectorVolume& volume,
+    const GeometryContext& gctx, const Experimental::Portal& portal, size_t ip,
+    const Experimental::DetectorVolume& volume,
     const OrientedSurfaces& orientedSurfaces,
     const std::vector<const Experimental::DetectorVolume*>& detectorVolumes,
     const Options& option) {
@@ -78,7 +78,7 @@ std::vector<nlohmann::json> Acts::PortalJsonConverter::toJsonDetray(
   const auto& volumeLinks = portal.detectorVolumeUpdators();
 
   // First assumption for outside link (along direction)
-  std::size_t outside = 1u;
+  size_t outside = 1u;
 
   // Find out if you need to take the outside or inside volume
   // for planar surfaces that's easy
@@ -116,7 +116,7 @@ std::vector<nlohmann::json> Acts::PortalJsonConverter::toJsonDetray(
   // in order to make sure the size is adjusted
   if (singleLink != nullptr) {
     // Single link can be written out
-    std::size_t vLink = findVolume(singleLink->dVolume, detectorVolumes);
+    size_t vLink = findVolume(singleLink->dVolume, detectorVolumes);
     auto jPortal = SurfaceJsonConverter::toJsonDetray(gctx, *surfaceAdjusted,
                                                       surfaceOptions);
     DetrayJsonHelper::addVolumeLink(jPortal["mask"], vLink);
diff --git a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp
index 75ffacd313c..c2e3232ad34 100644
--- a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp
+++ b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp
@@ -164,7 +164,7 @@ class MutablePodioTrackContainer : public PodioTrackContainerBase {
     return m_dynamic.find(key) != m_dynamic.end();
   }
 
-  std::size_t size_impl() const { return m_collection->size(); }
+  size_t size_impl() const { return m_collection->size(); }
   // END INTERFACE HELPER
 
   const Surface* referenceSurface_impl(IndexType itrack) const {
@@ -295,7 +295,7 @@ class ConstPodioTrackContainer : public PodioTrackContainerBase {
 
     for (const auto& col : available) {
       std::string prefix = tracksKey + "_extra__";
-      std::size_t p = col.find(prefix);
+      size_t p = col.find(prefix);
       if (p == std::string::npos) {
         continue;
       }
@@ -341,7 +341,7 @@ class ConstPodioTrackContainer : public PodioTrackContainerBase {
     return m_dynamic.find(key) != m_dynamic.end();
   }
 
-  std::size_t size_impl() const { return m_collection->size(); }
+  size_t size_impl() const { return m_collection->size(); }
 
   const Surface* referenceSurface_impl(IndexType itrack) const {
     return m_surfaces.at(itrack).get();
diff --git a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp
index 1dc8c505b28..e4e2bde8527 100644
--- a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp
+++ b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp
@@ -246,7 +246,7 @@ class ConstPodioTrackStateContainer final
 
     for (const auto& col : available) {
       std::string prefix = trackStatesKey + "_extra__";
-      std::size_t p = col.find(prefix);
+      size_t p = col.find(prefix);
       if (p == std::string::npos) {
         continue;
       }
diff --git a/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.hpp b/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.hpp
index bc82b98d49f..168f97cd0e9 100644
--- a/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.hpp
+++ b/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.hpp
@@ -51,7 +51,7 @@ class SeedFinder {
   std::vector<Seed<external_spacepoint_t>> createSeedsForGroup(
       Acts::SpacePointData& spacePointData,
       Acts::SpacePointGrid<external_spacepoint_t>& grid,
-      const sp_range_t& bottomSPs, const std::size_t middleSPs,
+      const sp_range_t& bottomSPs, const size_t middleSPs,
       const sp_range_t& topSPs) const;
 
  private:
diff --git a/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.ipp b/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.ipp
index 7d1c9bab29e..703393eaf63 100644
--- a/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.ipp
+++ b/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.ipp
@@ -65,7 +65,7 @@ std::vector<Acts::Seed<external_spacepoint_t>>
 SeedFinder<external_spacepoint_t>::createSeedsForGroup(
     Acts::SpacePointData& spacePointData,
     Acts::SpacePointGrid<external_spacepoint_t>& grid,
-    const sp_range_t& bottomSPs, const std::size_t middleSPs,
+    const sp_range_t& bottomSPs, const size_t middleSPs,
     const sp_range_t& topSPs) const {
   std::vector<Seed<external_spacepoint_t>> outputVec;
 
@@ -83,7 +83,7 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
   std::vector<Acts::InternalSpacePoint<external_spacepoint_t>*> middleSPvec;
   std::vector<Acts::InternalSpacePoint<external_spacepoint_t>*> topSPvec;
 
-  for (std::size_t SPidx : bottomSPs) {
+  for (size_t SPidx : bottomSPs) {
     auto& sp_collection = grid.at(SPidx);
     for (auto& SP : sp_collection) {
       bottomSPvec.push_back(SP.get());
@@ -147,7 +147,7 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
         candidates.begin(), candidates.end(),
         CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>::
             descendingByQuality);
-    std::size_t numQualitySeeds = 0;  // not used but needs to be fixed
+    size_t numQualitySeeds = 0;  // not used but needs to be fixed
     m_config.seedFilter->filterSeeds_1SpFixed(spacePointData, candidates,
                                               numQualitySeeds,
                                               std::back_inserter(outputVec));
diff --git a/Plugins/Sycl/src/Seeding/CreateSeedsForGroupSycl.cpp b/Plugins/Sycl/src/Seeding/CreateSeedsForGroupSycl.cpp
index 5f95ee1fdf8..b1422085b25 100644
--- a/Plugins/Sycl/src/Seeding/CreateSeedsForGroupSycl.cpp
+++ b/Plugins/Sycl/src/Seeding/CreateSeedsForGroupSycl.cpp
@@ -140,12 +140,12 @@ void createSeedsForGroupSycl(
 
     midBotDupletBuffer =
         std::make_unique<vecmem::data::jagged_vector_buffer<uint32_t>>(
-            std::vector<std::size_t>(M, 0), std::vector<std::size_t>(M, B),
+            std::vector<size_t>(M, 0), std::vector<size_t>(M, B),
             (device_resource ? *device_resource : resource),
             (device_resource ? &resource : nullptr));
     midTopDupletBuffer =
         std::make_unique<vecmem::data::jagged_vector_buffer<uint32_t>>(
-            std::vector<std::size_t>(M, 0), std::vector<std::size_t>(M, T),
+            std::vector<size_t>(M, 0), std::vector<size_t>(M, T),
             (device_resource ? *device_resource : resource),
             (device_resource ? &resource : nullptr));
     copy.setup(*midBotDupletBuffer);
diff --git a/Plugins/Sycl/src/Utilities/Arrays.hpp b/Plugins/Sycl/src/Utilities/Arrays.hpp
index 0c4f141d744..961bca48fbe 100644
--- a/Plugins/Sycl/src/Utilities/Arrays.hpp
+++ b/Plugins/Sycl/src/Utilities/Arrays.hpp
@@ -44,7 +44,7 @@ using device_array = std::unique_ptr<T, detail::DeviceArrayDeleter>;
 
 /// Function creating a primitive array in SYCL device memory
 template <typename T>
-device_array<T> make_device_array(std::size_t size, cl::sycl::queue& queue) {
+device_array<T> make_device_array(size_t size, cl::sycl::queue& queue) {
   return device_array<T>(cl::sycl::malloc_device<T>(size, queue),
                          detail::DeviceArrayDeleter(queue));
 }
diff --git a/Tests/CommonHelpers/Acts/Tests/CommonHelpers/WhiteBoardUtilities.hpp b/Tests/CommonHelpers/Acts/Tests/CommonHelpers/WhiteBoardUtilities.hpp
index 461f90759d5..dc54da390ba 100644
--- a/Tests/CommonHelpers/Acts/Tests/CommonHelpers/WhiteBoardUtilities.hpp
+++ b/Tests/CommonHelpers/Acts/Tests/CommonHelpers/WhiteBoardUtilities.hpp
@@ -49,7 +49,7 @@ struct GenericReadWriteTool {
   val_tuple_t tuple;
   str_tuple_t strings;
 
-  constexpr static std::size_t kSize = std::tuple_size_v<val_tuple_t>;
+  constexpr static size_t kSize = std::tuple_size_v<val_tuple_t>;
   static_assert(kSize == std::tuple_size_v<str_tuple_t>);
 
   template <typename T>
@@ -65,24 +65,24 @@ struct GenericReadWriteTool {
   }
 
   template <typename writer_t>
-  auto write(writer_t &writer, std::size_t eventId = 0) {
+  auto write(writer_t &writer, size_t eventId = 0) {
     ActsExamples::WhiteBoard board;
     ActsExamples::AlgorithmContext ctx(0, eventId, board);
 
     auto add = [&](auto &self, auto N) {
       if constexpr (N() < kSize) {
         addToWhiteBoard(std::get<N()>(strings), std::get<N()>(tuple), board);
-        self(self, std::integral_constant<std::size_t, N() + 1>{});
+        self(self, std::integral_constant<size_t, N() + 1>{});
       }
     };
 
-    add(add, std::integral_constant<std::size_t, 0>{});
+    add(add, std::integral_constant<size_t, 0>{});
 
     writer.internalExecute(ctx);
   }
 
   template <typename reader_t>
-  auto read(reader_t &reader, std::size_t eventId = 0) {
+  auto read(reader_t &reader, size_t eventId = 0) {
     ActsExamples::WhiteBoard board;
     ActsExamples::AlgorithmContext ctx(0, eventId, board);
 
@@ -93,13 +93,13 @@ struct GenericReadWriteTool {
         using T = std::tuple_element_t<N(), val_tuple_t>;
         auto val = getFromWhiteBoard<T>(std::get<N()>(strings), board);
         return self(self, std::tuple_cat(res, std::make_tuple(val)),
-                    std::integral_constant<std::size_t, N() + 1>{});
+                    std::integral_constant<size_t, N() + 1>{});
       } else {
         return res;
       }
     };
 
-    return get(get, std::tuple<>{}, std::integral_constant<std::size_t, 0>{});
+    return get(get, std::tuple<>{}, std::integral_constant<size_t, 0>{});
   }
 };
 }  // namespace Acts::Test
diff --git a/Tests/IntegrationTests/Fatras/FatrasSimulationTests.cpp b/Tests/IntegrationTests/Fatras/FatrasSimulationTests.cpp
index 37b20f92d27..2ba782b0e1f 100644
--- a/Tests/IntegrationTests/Fatras/FatrasSimulationTests.cpp
+++ b/Tests/IntegrationTests/Fatras/FatrasSimulationTests.cpp
@@ -209,7 +209,7 @@ BOOST_DATA_TEST_CASE(FatrasSimulation, dataset, pdg, phi, eta, p,
 
   // ensure simulated particle containers have consistent content
   BOOST_CHECK_EQUAL(simulatedInitial.size(), simulatedFinal.size());
-  for (std::size_t i = 0; i < simulatedInitial.size(); ++i) {
+  for (size_t i = 0; i < simulatedInitial.size(); ++i) {
     const auto& initialParticle = simulatedInitial[i];
     const auto& finalParticle = simulatedFinal[i];
     // particle identify should not change during simulation
diff --git a/Tests/UnitTests/Core/Detector/IndexedSurfaceGridFillerTests.cpp b/Tests/UnitTests/Core/Detector/IndexedSurfaceGridFillerTests.cpp
index 5171dfd400e..b5230f25475 100644
--- a/Tests/UnitTests/Core/Detector/IndexedSurfaceGridFillerTests.cpp
+++ b/Tests/UnitTests/Core/Detector/IndexedSurfaceGridFillerTests.cpp
@@ -48,9 +48,9 @@ namespace {
 
 /// Helper method to count how many bins are not empty
 template <typename indexed_surface_grid>
-std::size_t countBins(const indexed_surface_grid& isGrid) {
-  std::size_t nonEmptyBins = 0u;
-  for (std::size_t igb = 0u; igb < isGrid.grid.size(); ++igb) {
+size_t countBins(const indexed_surface_grid& isGrid) {
+  size_t nonEmptyBins = 0u;
+  for (size_t igb = 0u; igb < isGrid.grid.size(); ++igb) {
     const auto& gb = isGrid.grid.at(igb);
     if (!gb.empty()) {
       ++nonEmptyBins;
@@ -69,7 +69,7 @@ BOOST_AUTO_TEST_CASE(BinSequence) {
 
   // Test standard bound local bin sequence
   auto seq48e0b10B = binSequence({4u, 8u}, 0u, 10u, AxisBoundaryType::Bound);
-  std::vector<std::size_t> reference = {4u, 5u, 6u, 7u, 8u};
+  std::vector<size_t> reference = {4u, 5u, 6u, 7u, 8u};
   BOOST_CHECK(seq48e0b10B == reference);
 
   // Test bound local bin sequence with expansion 1u
@@ -143,7 +143,7 @@ BOOST_AUTO_TEST_CASE(IndexGridXYOneSurfaceCenter) {
   // Fill the surface
   filler.fill(tContext, indexedGridXY, surfaces, generator);
 
-  std::size_t nonEmptyBins = countBins<decltype(indexedGridXY)>(indexedGridXY);
+  size_t nonEmptyBins = countBins<decltype(indexedGridXY)>(indexedGridXY);
   // Check the correct number of filled bins
   ACTS_INFO("- filled " << nonEmptyBins << " bins of the grid.");
   BOOST_CHECK(nonEmptyBins == 1u);
@@ -180,7 +180,7 @@ BOOST_AUTO_TEST_CASE(IndexGridXYOneSurfaceBinValue) {
   // Fill the surface
   filler.fill(tContext, indexedGridXY, surfaces, generator);
 
-  std::size_t nonEmptyBins = countBins<decltype(indexedGridXY)>(indexedGridXY);
+  size_t nonEmptyBins = countBins<decltype(indexedGridXY)>(indexedGridXY);
   ACTS_INFO("- filled " << nonEmptyBins << " bins of the grid.");
   BOOST_CHECK(nonEmptyBins == 1u);
 }
@@ -217,7 +217,7 @@ BOOST_AUTO_TEST_CASE(IndexGridXYOneSurfacePolyhedron) {
   // Fill the surface
   filler.fill(tContext, indexedGridXY, surfaces, generator);
 
-  std::size_t nonEmptyBins = countBins<decltype(indexedGridXY)>(indexedGridXY);
+  size_t nonEmptyBins = countBins<decltype(indexedGridXY)>(indexedGridXY);
   ACTS_INFO("- filled " << nonEmptyBins << " bins of the grid.");
   BOOST_CHECK(nonEmptyBins == 25u);
 }
@@ -254,7 +254,7 @@ BOOST_AUTO_TEST_CASE(IndexGridXYOneSurfacePolyhedronBinExpansion) {
   // Fill the surface
   filler.fill(tContext, indexedGridXY, surfaces, generator);
 
-  std::size_t nonEmptyBins = countBins<decltype(indexedGridXY)>(indexedGridXY);
+  size_t nonEmptyBins = countBins<decltype(indexedGridXY)>(indexedGridXY);
   ACTS_INFO("- filled " << nonEmptyBins << " bins of the grid.");
   BOOST_CHECK(nonEmptyBins == 49u);
 }
@@ -291,8 +291,7 @@ BOOST_AUTO_TEST_CASE(IndexGridZPhiYOneSurfacePolyhedronBinExpansion) {
   // Fill the surface
   filler.fill(tContext, indexedGridZPhi, surfaces, generator);
 
-  std::size_t nonEmptyBins =
-      countBins<decltype(indexedGridZPhi)>(indexedGridZPhi);
+  size_t nonEmptyBins = countBins<decltype(indexedGridZPhi)>(indexedGridZPhi);
   ACTS_INFO("- filled " << nonEmptyBins << " bins of the grid.");
   BOOST_CHECK(nonEmptyBins == 6u);
 }
@@ -327,8 +326,7 @@ BOOST_AUTO_TEST_CASE(IndexGridZPhiYOneSurfaceMPIPolyhedronBinExpansion) {
   // Fill the surface
   filler.fill(tContext, indexedGridZPhi, surfaces, generator);
 
-  std::size_t nonEmptyBins =
-      countBins<decltype(indexedGridZPhi)>(indexedGridZPhi);
+  size_t nonEmptyBins = countBins<decltype(indexedGridZPhi)>(indexedGridZPhi);
   ACTS_INFO("- filled " << nonEmptyBins << " bins of the grid.");
   BOOST_CHECK(nonEmptyBins == 9u);
 }
diff --git a/Tests/UnitTests/Core/Detector/IndexedSurfacesGeneratorTests.cpp b/Tests/UnitTests/Core/Detector/IndexedSurfacesGeneratorTests.cpp
index 90bb710f6bf..3b4caba0e51 100644
--- a/Tests/UnitTests/Core/Detector/IndexedSurfacesGeneratorTests.cpp
+++ b/Tests/UnitTests/Core/Detector/IndexedSurfacesGeneratorTests.cpp
@@ -60,7 +60,7 @@ BOOST_AUTO_TEST_CASE(RingDisc1D) {
 
   auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
 
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
+  using GridType = decltype(aGenerator)::grid_type<std::vector<size_t>>;
   using DelegateType =
       IndexedSurfacesAllPortalsImpl<GridType, IndexedSurfacesImpl>;
 
@@ -105,7 +105,7 @@ BOOST_AUTO_TEST_CASE(RingDisc1DWithSupport) {
 
   auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
 
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
+  using GridType = decltype(aGenerator)::grid_type<std::vector<size_t>>;
 
   using DelegateType =
       IndexedSurfacesAllPortalsImpl<GridType, IndexedSurfacesImpl>;
@@ -153,7 +153,7 @@ BOOST_AUTO_TEST_CASE(RingDisc2D) {
 
   auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
 
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
+  using GridType = decltype(aGenerator)::grid_type<std::vector<size_t>>;
 
   using DelegateType =
       IndexedSurfacesAllPortalsImpl<GridType, IndexedSurfacesImpl>;
@@ -200,7 +200,7 @@ BOOST_AUTO_TEST_CASE(RingDisc2DFine) {
 
   auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
 
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
+  using GridType = decltype(aGenerator)::grid_type<std::vector<size_t>>;
 
   using DelegateType =
       IndexedSurfacesAllPortalsImpl<GridType, IndexedSurfacesImpl>;
@@ -246,7 +246,7 @@ BOOST_AUTO_TEST_CASE(RingDisc2DFineExpanded) {
 
   auto indexedRing = irSurfaces(tContext, aGenerator, rGenerator);
 
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
+  using GridType = decltype(aGenerator)::grid_type<std::vector<size_t>>;
   using DelegateType =
       IndexedSurfacesAllPortalsImpl<GridType, IndexedSurfacesImpl>;
 
@@ -280,7 +280,7 @@ BOOST_AUTO_TEST_CASE(Cylinder2D) {
 
   auto indexedCylinder = icSurfaces(tContext, aGenerator, rGenerator);
 
-  using GridType = decltype(aGenerator)::grid_type<std::vector<std::size_t>>;
+  using GridType = decltype(aGenerator)::grid_type<std::vector<size_t>>;
   using DelegateType =
       IndexedSurfacesAllPortalsImpl<GridType, IndexedSurfacesImpl>;
 
diff --git a/Tests/UnitTests/Core/Detector/MultiWireStructureBuilderTests.cpp b/Tests/UnitTests/Core/Detector/MultiWireStructureBuilderTests.cpp
index e7d202e8b19..df591a52c76 100644
--- a/Tests/UnitTests/Core/Detector/MultiWireStructureBuilderTests.cpp
+++ b/Tests/UnitTests/Core/Detector/MultiWireStructureBuilderTests.cpp
@@ -38,8 +38,8 @@ BOOST_AUTO_TEST_CASE(Multi_Wire_Structure_Builder_StrawSurfacesCreation) {
 
   // Set the number of surfaces along each dimension of the multi wire structure
   // aligned along z axis
-  std::size_t nSurfacesY = 3;
-  std::size_t nSurfacesX = 15;
+  size_t nSurfacesY = 3;
+  size_t nSurfacesX = 15;
 
   double radius = 15.;
   double halfZ = 250.;
@@ -52,8 +52,8 @@ BOOST_AUTO_TEST_CASE(Multi_Wire_Structure_Builder_StrawSurfacesCreation) {
   Vector3 pos = ipos;
 
   // Generate the surfaces
-  for (std::size_t i = 0; i < nSurfacesY; i++) {
-    for (std::size_t j = 0; j < nSurfacesX; j++) {
+  for (size_t i = 0; i < nSurfacesY; i++) {
+    for (size_t j = 0; j < nSurfacesX; j++) {
       auto surface = Surface::makeShared<StrawSurface>(
           Transform3(Translation3(pos)), radius, halfZ);
       strawSurfaces.push_back(surface);
diff --git a/Tests/UnitTests/Core/EventData/TrackTests.cpp b/Tests/UnitTests/Core/EventData/TrackTests.cpp
index 3a086b0a1a9..8e0c497250c 100644
--- a/Tests/UnitTests/Core/EventData/TrackTests.cpp
+++ b/Tests/UnitTests/Core/EventData/TrackTests.cpp
@@ -580,7 +580,7 @@ BOOST_AUTO_TEST_CASE(ForwardIteration) {
   {
     // let's create an unrelated track first
     auto t = tc.getTrack(tc.addTrack());
-    for (std::size_t i = 0; i < 10; i++) {
+    for (size_t i = 0; i < 10; i++) {
       t.appendTrackState();
     }
   }
diff --git a/Tests/UnitTests/Core/Navigation/DetectorVolumeFindersTests.cpp b/Tests/UnitTests/Core/Navigation/DetectorVolumeFindersTests.cpp
index f9cda170725..2c041939761 100644
--- a/Tests/UnitTests/Core/Navigation/DetectorVolumeFindersTests.cpp
+++ b/Tests/UnitTests/Core/Navigation/DetectorVolumeFindersTests.cpp
@@ -96,7 +96,7 @@ BOOST_AUTO_TEST_CASE(RootVolumeFinder) {
 BOOST_AUTO_TEST_CASE(IndexedDetectorVolumeFinder) {
   nState.currentDetector = det012.get();
 
-  using SingleIndex = std::size_t;
+  using SingleIndex = size_t;
 
   using Axis = Acts::detail::Axis<Acts::detail::AxisType::Variable,
                                   Acts::detail::AxisBoundaryType::Bound>;
diff --git a/Tests/UnitTests/Core/Navigation/MultiWireNavigationTests.cpp b/Tests/UnitTests/Core/Navigation/MultiWireNavigationTests.cpp
index 92b2f34d812..57386119277 100644
--- a/Tests/UnitTests/Core/Navigation/MultiWireNavigationTests.cpp
+++ b/Tests/UnitTests/Core/Navigation/MultiWireNavigationTests.cpp
@@ -44,8 +44,8 @@ BOOST_AUTO_TEST_CASE(Navigation_in_Indexed_Surfaces) {
 
   // Set the number of surfaces along each dimension of the multi wire structure
   // aligned along z axis
-  std::size_t nSurfacesY = 4;
-  std::size_t nSurfacesX = 15;
+  size_t nSurfacesY = 4;
+  size_t nSurfacesX = 15;
 
   double radius = 15.;
   double halfZ = 250.;
@@ -57,8 +57,8 @@ BOOST_AUTO_TEST_CASE(Navigation_in_Indexed_Surfaces) {
   Vector3 pos = ipos;
 
   // Generate the surfaces
-  for (std::size_t i = 0; i < nSurfacesY; i++) {
-    for (std::size_t j = 0; j < nSurfacesX; j++) {
+  for (size_t i = 0; i < nSurfacesY; i++) {
+    for (size_t j = 0; j < nSurfacesX; j++) {
       pos.x() = ipos.x() + 2 * j * radius;
 
       auto surface = Surface::makeShared<StrawSurface>(
diff --git a/Tests/UnitTests/Core/Propagator/MultiStepperTests.cpp b/Tests/UnitTests/Core/Propagator/MultiStepperTests.cpp
index 772cdbc9395..f4d48ee2ff8 100644
--- a/Tests/UnitTests/Core/Propagator/MultiStepperTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/MultiStepperTests.cpp
@@ -74,7 +74,7 @@ const auto particleHypothesis = ParticleHypothesis::pion();
 struct Options {
   double stepTolerance = 1e-4;
   double stepSizeCutOff = 0.0;
-  std::size_t maxRungeKuttaStepTrials = 10;
+  size_t maxRungeKuttaStepTrials = 10;
   Direction direction = defaultNDir;
   const Acts::Logger &logger = Acts::getDummyLogger();
 };
@@ -107,7 +107,7 @@ using components_t = typename T::components;
 // Makes random bound parameters and covariance and a plane surface at {0,0,0}
 // with normal {1,0,0}. Optionally some external fixed bound parameters can be
 // supplied
-auto makeDefaultBoundPars(bool cov = true, std::size_t n = 4,
+auto makeDefaultBoundPars(bool cov = true, size_t n = 4,
                           std::optional<BoundVector> ext_pars = std::nullopt) {
   std::vector<std::tuple<double, BoundVector, std::optional<BoundSquareMatrix>>>
       cmps;
@@ -138,7 +138,7 @@ void test_multi_stepper_state() {
   using MultiState = typename multi_stepper_t::State;
   using MultiStepper = multi_stepper_t;
 
-  constexpr std::size_t N = 4;
+  constexpr size_t N = 4;
   const auto multi_pars = makeDefaultBoundPars(Cov, N, BoundVector::Ones());
 
   MultiState state(geoCtx, magCtx, defaultBField, multi_pars, defaultStepSize);
diff --git a/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp b/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp
index ddedd078f4d..fa1237a46cd 100644
--- a/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp
+++ b/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp
@@ -83,9 +83,9 @@ ATLASCuts<SpacePoint>::cutPerMiddleSP(
   }
 
   newSeedsVector.push_back(std::move(seedCandidates[0]));
-  std::size_t itLength = std::min(seedCandidates.size(), std::size_t(5));
+  size_t itLength = std::min(seedCandidates.size(), size_t(5));
   // don't cut first element
-  for (std::size_t i(1); i < itLength; i++) {
+  for (size_t i(1); i < itLength; i++) {
     float weight = seedCandidates[i].weight;
     const auto& bottom = seedCandidates[i].bottom;
     if (weight > 200. || bottom->radius() > 43.) {
diff --git a/Tests/UnitTests/Core/TrackFitting/GsfComponentMergingTests.cpp b/Tests/UnitTests/Core/TrackFitting/GsfComponentMergingTests.cpp
index 20816bb7d70..12b2c9cd746 100644
--- a/Tests/UnitTests/Core/TrackFitting/GsfComponentMergingTests.cpp
+++ b/Tests/UnitTests/Core/TrackFitting/GsfComponentMergingTests.cpp
@@ -87,7 +87,7 @@ class MultivariateNormalDistribution {
 // Sample data from a multi-component multivariate distribution
 template <int D>
 auto sampleFromMultivariate(const std::vector<DummyComponent<D>> &cmps,
-                            std::size_t n_samples, std::mt19937 &gen) {
+                            size_t n_samples, std::mt19937 &gen) {
   using MultiNormal = MultivariateNormalDistribution<double, D>;
 
   std::vector<MultiNormal> dists;
diff --git a/Tests/UnitTests/Core/TrackFitting/GsfMixtureReductionTests.cpp b/Tests/UnitTests/Core/TrackFitting/GsfMixtureReductionTests.cpp
index e7775686d84..0b4dcf13fde 100644
--- a/Tests/UnitTests/Core/TrackFitting/GsfMixtureReductionTests.cpp
+++ b/Tests/UnitTests/Core/TrackFitting/GsfMixtureReductionTests.cpp
@@ -48,7 +48,7 @@ BOOST_AUTO_TEST_CASE(test_distance_matrix_masking) {
       {1. / 3., BoundVector::Constant(+4.), BoundSquareMatrix::Identity()}};
 
   const auto proj = [](auto &a) -> decltype(auto) { return a; };
-  const std::size_t cmp_to_mask = 2;
+  const size_t cmp_to_mask = 2;
 
   detail::SymmetricKLDistanceMatrix mat_full(cmps, proj);
   mat_full.maskAssociatedDistances(cmp_to_mask);
@@ -118,7 +118,7 @@ BOOST_AUTO_TEST_CASE(test_mixture_reduction) {
   // Assume that the components are on a generic plane surface
   auto surface = Acts::Surface::makeShared<PlaneSurface>(Vector3{0, 0, 0},
                                                          Vector3{1, 0, 0});
-  const std::size_t NComps = 4;
+  const size_t NComps = 4;
   std::vector<GsfComponent> cmps;
 
   for (auto i = 0ul; i < NComps; ++i) {
diff --git a/Tests/UnitTests/Core/Utilities/HelpersTests.cpp b/Tests/UnitTests/Core/Utilities/HelpersTests.cpp
index 2a98e4121a0..53d1298b0ab 100644
--- a/Tests/UnitTests/Core/Utilities/HelpersTests.cpp
+++ b/Tests/UnitTests/Core/Utilities/HelpersTests.cpp
@@ -182,7 +182,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(BlockedMatrixMultiplication, Matrices,
   using B = typename Matrices::second_type;
   using C = ActsMatrix<A::RowsAtCompileTime, B::ColsAtCompileTime>;
 
-  for (std::size_t i = 0; i < 100; ++i) {
+  for (size_t i = 0; i < 100; ++i) {
     A a = A::Random();
     B b = B::Random();
 
diff --git a/Tests/UnitTests/Core/Utilities/KDTreeTests.cpp b/Tests/UnitTests/Core/Utilities/KDTreeTests.cpp
index fc4453c366a..0db3acc49b5 100644
--- a/Tests/UnitTests/Core/Utilities/KDTreeTests.cpp
+++ b/Tests/UnitTests/Core/Utilities/KDTreeTests.cpp
@@ -595,11 +595,11 @@ BOOST_AUTO_TEST_CASE(range_search_many_same) {
 
   std::vector<std::pair<std::array<double, 3>, int>> points;
 
-  for (std::size_t i = 0; i < 50; ++i) {
+  for (size_t i = 0; i < 50; ++i) {
     points.push_back({{64.0, 64.0, 64.0}, q++});
   }
 
-  for (std::size_t i = 0; i < 50; ++i) {
+  for (size_t i = 0; i < 50; ++i) {
     points.push_back({{-64.0, -64.0, -64.0}, q++});
   }
 
diff --git a/Tests/UnitTests/Core/Utilities/MultiIndexTests.cpp b/Tests/UnitTests/Core/Utilities/MultiIndexTests.cpp
index a3a9c48e9d3..d6484fb5cb4 100644
--- a/Tests/UnitTests/Core/Utilities/MultiIndexTests.cpp
+++ b/Tests/UnitTests/Core/Utilities/MultiIndexTests.cpp
@@ -78,7 +78,7 @@ BOOST_AUTO_TEST_CASE(index32_set_overflow) {
       (1u << 8u) - 1u,
   };
   // check that values above max are truncated
-  std::size_t lvl = 0;
+  size_t lvl = 0;
   for (auto maxValue : maxValues) {
     BOOST_CHECK_EQUAL(Index32::Zeros().set(lvl, maxValue + 1),
                       Index32::Zeros().set(lvl, 0u));
@@ -95,7 +95,7 @@ BOOST_AUTO_TEST_CASE(index64_set_overflow) {
       (1u << 13u) - 1u,
   };
   // check that values above max are truncated
-  std::size_t lvl = 0;
+  size_t lvl = 0;
   for (auto maxValue : maxValues) {
     BOOST_CHECK_EQUAL(Index64::Zeros().set(lvl, maxValue + 1),
                       Index64::Zeros().set(lvl, 0u));
diff --git a/Tests/UnitTests/Core/Utilities/SubspaceTests.cpp b/Tests/UnitTests/Core/Utilities/SubspaceTests.cpp
index 07655743103..6175f0867f3 100644
--- a/Tests/UnitTests/Core/Utilities/SubspaceTests.cpp
+++ b/Tests/UnitTests/Core/Utilities/SubspaceTests.cpp
@@ -53,7 +53,7 @@ using ScalarsAndFixedSizeSubspaces = std::tuple<
 // clang-format on
 
 /// Construct a random vector of the specified size.
-template <typename scalar_t, std::size_t kSize>
+template <typename scalar_t, size_t kSize>
 Eigen::Matrix<scalar_t, kSize, 1> makeRandomVector() {
   Eigen::Matrix<scalar_t, kSize, 1> vec;
   vec.setRandom();
@@ -61,17 +61,17 @@ Eigen::Matrix<scalar_t, kSize, 1> makeRandomVector() {
 }
 
 /// Construct a vector w/ monotonically inceasing values starting at 0.
-std::vector<std::size_t> makeMonotonicIndices(std::size_t n) {
-  std::vector<std::size_t> indices(n);
+std::vector<size_t> makeMonotonicIndices(size_t n) {
+  std::vector<size_t> indices(n);
   std::iota(indices.begin(), indices.end(), 0u);
   return indices;
 }
 
 /// Build a sorted array from the first kSize indices.
-template <std::size_t kSize>
-std::array<std::size_t, kSize> selectFixedIndices(
-    const std::vector<std::size_t>& fullIndices) {
-  std::array<std::size_t, kSize> indices{};
+template <size_t kSize>
+std::array<size_t, kSize> selectFixedIndices(
+    const std::vector<size_t>& fullIndices) {
+  std::array<size_t, kSize> indices{};
   for (auto i = 0u; i < kSize; ++i) {
     indices[i] = fullIndices[i];
   }
diff --git a/Tests/UnitTests/Examples/Io/Csv/MeasurementReaderWriterTests.cpp b/Tests/UnitTests/Examples/Io/Csv/MeasurementReaderWriterTests.cpp
index 7c09c027ccb..98774a0285f 100644
--- a/Tests/UnitTests/Examples/Io/Csv/MeasurementReaderWriterTests.cpp
+++ b/Tests/UnitTests/Examples/Io/Csv/MeasurementReaderWriterTests.cpp
@@ -36,7 +36,7 @@ BOOST_AUTO_TEST_CASE(CsvMeasurementRoundTrip) {
   ////////////////////////////
   // Create some dummy data //
   ////////////////////////////
-  const std::size_t nMeasurements = 3;
+  const size_t nMeasurements = 3;
   Acts::GeometryIdentifier someGeoId{298453};
 
   std::mt19937 gen(23);
diff --git a/Tests/UnitTests/Examples/Io/Root/SimhitReaderWriterTests.cpp b/Tests/UnitTests/Examples/Io/Root/SimhitReaderWriterTests.cpp
index ab321185b5b..a5859986066 100644
--- a/Tests/UnitTests/Examples/Io/Root/SimhitReaderWriterTests.cpp
+++ b/Tests/UnitTests/Examples/Io/Root/SimhitReaderWriterTests.cpp
@@ -24,7 +24,7 @@ using namespace Acts::Test;
 
 std::mt19937 gen(23);
 
-auto makeTestSimhits(std::size_t nSimHits) {
+auto makeTestSimhits(size_t nSimHits) {
   std::uniform_int_distribution<uint64_t> distIds(
       1, std::numeric_limits<uint64_t>::max());
   std::uniform_int_distribution<int32_t> distIndex(1, 20);
diff --git a/Tests/UnitTests/Plugins/ActSVG/PortalSvgConverterTests.cpp b/Tests/UnitTests/Plugins/ActSVG/PortalSvgConverterTests.cpp
index 3bd86c3caa8..9b00b631557 100644
--- a/Tests/UnitTests/Plugins/ActSVG/PortalSvgConverterTests.cpp
+++ b/Tests/UnitTests/Plugins/ActSVG/PortalSvgConverterTests.cpp
@@ -68,7 +68,7 @@ BOOST_AUTO_TEST_CASE(CylinderPortalsSvg) {
 
   // rz view
   std::vector<actsvg::svg::object> zrPortals;
-  std::size_t ip = 0;
+  size_t ip = 0;
   std::for_each(protoPortals.begin(), protoPortals.end(), [&](const auto& p) {
     zrPortals.push_back(
         Acts::Svg::View::zr(p, "Portal_zr" + std::to_string(ip++)));
@@ -147,7 +147,7 @@ BOOST_AUTO_TEST_CASE(CylinderContainerPortalsSvg) {
   }
   // rz view
   std::vector<actsvg::svg::object> zrPortals;
-  std::size_t ip = 0;
+  size_t ip = 0;
   std::for_each(protoPortals.begin(), protoPortals.end(), [&](const auto& p) {
     zrPortals.push_back(
         Acts::Svg::View::zr(p, "Portal_zr" + std::to_string(ip++)));
diff --git a/Tests/UnitTests/Plugins/Cuda/Seeding/ATLASCuts.hpp b/Tests/UnitTests/Plugins/Cuda/Seeding/ATLASCuts.hpp
index be619bdfef2..ec886207995 100644
--- a/Tests/UnitTests/Plugins/Cuda/Seeding/ATLASCuts.hpp
+++ b/Tests/UnitTests/Plugins/Cuda/Seeding/ATLASCuts.hpp
@@ -82,9 +82,9 @@ ATLASCuts<SpacePoint>::cutPerMiddleSP(
   }
 
   newSeedsVector.push_back(std::move(seedCandidates[0]));
-  std::size_t itLength = std::min(seedCandidates.size(), std::size_t(5));
+  size_t itLength = std::min(seedCandidates.size(), size_t(5));
   // don't cut first element
-  for (std::size_t i(1); i < itLength; i++) {
+  for (size_t i(1); i < itLength; i++) {
     float weight = seedCandidates[i].weight;
     const auto& bottom = seedCandidates[i].bottom;
     if (weight > 200. || bottom->radius() > 43.) {
diff --git a/Tests/UnitTests/Plugins/Cuda/Seeding2/CommandLineArguments.hpp b/Tests/UnitTests/Plugins/Cuda/Seeding2/CommandLineArguments.hpp
index 6050daf6486..14598c6719f 100644
--- a/Tests/UnitTests/Plugins/Cuda/Seeding2/CommandLineArguments.hpp
+++ b/Tests/UnitTests/Plugins/Cuda/Seeding2/CommandLineArguments.hpp
@@ -22,7 +22,7 @@ struct CommandLineArguments {
   /// Run the seed finding using only the GPU implementation
   bool onlyGPU = false;
   /// The number of groups to process as a maximum
-  std::size_t groupsToIterate = 500;
+  size_t groupsToIterate = 500;
   /// Look for spacepoint duplicates in the received input file, and remove them
   bool filterDuplicates = false;
 
@@ -30,7 +30,7 @@ struct CommandLineArguments {
   int cudaDevice = 0;
   /// Memory to use on the CUDA device in megabytes (by default it's 80% of the
   /// available)
-  std::size_t cudaDeviceMemory = 0;
+  size_t cudaDeviceMemory = 0;
 
   /// Interpret the command line arguments of the test executable
   void interpret(int argc, char* argv[]);
diff --git a/Tests/UnitTests/Plugins/Cuda/Seeding2/ReadSeedFile.cpp b/Tests/UnitTests/Plugins/Cuda/Seeding2/ReadSeedFile.cpp
index 0de5b7385fe..e37459f9370 100644
--- a/Tests/UnitTests/Plugins/Cuda/Seeding2/ReadSeedFile.cpp
+++ b/Tests/UnitTests/Plugins/Cuda/Seeding2/ReadSeedFile.cpp
@@ -30,7 +30,7 @@ std::vector<std::unique_ptr<TestSpacePoint> > readSeedFile(
 
   // Read the file's lines one by one, and create spacepoint objects out of
   // them.
-  std::size_t duplicatesFound = 0;
+  size_t duplicatesFound = 0;
   while (!spFile.eof()) {
     std::string line;
     std::getline(spFile, line);
diff --git a/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.cpp b/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.cpp
index fddf549488d..cdf58c47b77 100644
--- a/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.cpp
+++ b/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.cpp
@@ -44,9 +44,9 @@ TestHostCuts::cutPerMiddleSP(
   }
 
   newSeedsVector.push_back(std::move(seedCandidates[0]));
-  std::size_t itLength = std::min(seedCandidates.size(), std::size_t(5));
+  size_t itLength = std::min(seedCandidates.size(), size_t(5));
   // don't cut first element
-  for (std::size_t i(1); i < itLength; i++) {
+  for (size_t i(1); i < itLength; i++) {
     float weight = seedCandidates[i].weight;
     const auto& bottom = seedCandidates[i].bottom;
     if (weight > 200. or bottom->radius() > 43.) {
diff --git a/Tests/UnitTests/Plugins/Cuda/Seeding2/main.cpp b/Tests/UnitTests/Plugins/Cuda/Seeding2/main.cpp
index f3c63a4bfc1..5f51dffceb1 100644
--- a/Tests/UnitTests/Plugins/Cuda/Seeding2/main.cpp
+++ b/Tests/UnitTests/Plugins/Cuda/Seeding2/main.cpp
@@ -133,13 +133,13 @@ int main(int argc, char* argv[]) {
 
   // Allocate memory on the selected CUDA device.
   if (Acts::Cuda::Info::instance().devices().size() <=
-      static_cast<std::size_t>(cmdl.cudaDevice)) {
+      static_cast<size_t>(cmdl.cudaDevice)) {
     std::cerr << "Invalid CUDA device (" << cmdl.cudaDevice << ") requested"
               << std::endl;
     return 1;
   }
-  static constexpr std::size_t MEGABYTES = 1024l * 1024l;
-  std::size_t deviceMemoryAllocation = cmdl.cudaDeviceMemory * MEGABYTES;
+  static constexpr size_t MEGABYTES = 1024l * 1024l;
+  size_t deviceMemoryAllocation = cmdl.cudaDeviceMemory * MEGABYTES;
   if (deviceMemoryAllocation == 0) {
     deviceMemoryAllocation =
         Acts::Cuda::Info::instance().devices()[cmdl.cudaDevice].totalMemory *
@@ -177,7 +177,7 @@ int main(int argc, char* argv[]) {
   // Perform the seed finding.
   if (!cmdl.onlyGPU) {
     decltype(seedFinder_host)::SeedingState state;
-    for (std::size_t i = 0; i < cmdl.groupsToIterate; ++i) {
+    for (size_t i = 0; i < cmdl.groupsToIterate; ++i) {
       auto spGroup_itr = Acts::BinnedSPGroupIterator(spGroup, i);
       if (spGroup_itr == spGroup.end()) {
         break;
@@ -213,7 +213,7 @@ int main(int argc, char* argv[]) {
   spacePointData.resize(spView.size());
 
   // Perform the seed finding.
-  for (std::size_t i = 0; i < cmdl.groupsToIterate; ++i) {
+  for (size_t i = 0; i < cmdl.groupsToIterate; ++i) {
     auto spGroup_itr = Acts::BinnedSPGroupIterator(spGroup, i);
     if (spGroup_itr == spGroup_end) {
       break;
@@ -236,7 +236,7 @@ int main(int argc, char* argv[]) {
   //
 
   // Count the total number of reconstructed seeds.
-  std::size_t nSeeds_host = 0, nSeeds_device = 0;
+  size_t nSeeds_host = 0, nSeeds_device = 0;
   for (const auto& seeds : seeds_host) {
     nSeeds_host += seeds.size();
   }
@@ -246,7 +246,7 @@ int main(int argc, char* argv[]) {
 
   // Count how many seeds, reconstructed on the host, can be matched with seeds
   // reconstructed on the accelerator.
-  std::size_t nMatch = 0;
+  size_t nMatch = 0;
   double matchPercentage = 0.0;
   if (!cmdl.onlyGPU) {
     assert(seeds_host.size() == seeds_device.size());
diff --git a/Tests/UnitTests/Plugins/Sycl/Seeding/ATLASCuts.hpp b/Tests/UnitTests/Plugins/Sycl/Seeding/ATLASCuts.hpp
index f59f1e7c698..0cdcb66deb5 100644
--- a/Tests/UnitTests/Plugins/Sycl/Seeding/ATLASCuts.hpp
+++ b/Tests/UnitTests/Plugins/Sycl/Seeding/ATLASCuts.hpp
@@ -83,9 +83,9 @@ ATLASCuts<SpacePoint>::cutPerMiddleSP(
   }
 
   newSeedsVector.push_back(std::move(seedCandidates[0]));
-  std::size_t itLength = std::min(seedCandidates.size(), std::size_t(5));
+  size_t itLength = std::min(seedCandidates.size(), size_t(5));
   // don't cut first element
-  for (std::size_t i(1); i < itLength; i++) {
+  for (size_t i(1); i < itLength; i++) {
     float weight = seedCandidates[i].weight;
     const auto& bottom = seedCandidates[i].bottom;
     if (weight > 200. || bottom->radius() > 43.) {