diff --git a/core/include/detray/core/concepts.hpp b/core/include/detray/core/concepts.hpp
index 0118f0833..1de7c8a83 100644
--- a/core/include/detray/core/concepts.hpp
+++ b/core/include/detray/core/concepts.hpp
@@ -9,6 +9,7 @@
 
 // Project include(s)
 #include "detray/core/detail/type_traits.hpp"
+#include "detray/geometry/mask.hpp"
 
 namespace detray::concepts {
 
@@ -43,4 +44,11 @@ template <class detector_t>
 concept has_material_maps =
     detail::contains_material_maps_v<typename detector_t::materials>;
 
+/// Check whether the detector defines the shape type @tparam shape_t
+template <class detector_t, class shape_t>
+concept has_mask =
+    types::contains<typename detector_t::masks,
+                    mask<shape_t, typename detector_t::algebra_type,
+                         typename detector_t::surface_type::navigation_link>>;
+
 }  // namespace detray::concepts
diff --git a/core/include/detray/definitions/detail/qualifiers.hpp b/core/include/detray/definitions/detail/qualifiers.hpp
index 2c69d2b3f..4b1ed1c2d 100644
--- a/core/include/detray/definitions/detail/qualifiers.hpp
+++ b/core/include/detray/definitions/detail/qualifiers.hpp
@@ -26,6 +26,12 @@
 #define DETRAY_HOST_DEVICE
 #endif
 
+#if defined(__CUDACC__) || defined(__HIP__)
+#define DETRAY_SYNC_WARP __syncwarp();
+#else
+#define DETRAY_SYNC_WARP
+#endif
+
 #if defined(__CUDACC__) || defined(__HIP__)
 #define DETRAY_ALIGN(x) __align__(x)
 #else
diff --git a/core/include/detray/navigation/caching_navigator.hpp b/core/include/detray/navigation/caching_navigator.hpp
index 1d0bef203..711f75f9c 100644
--- a/core/include/detray/navigation/caching_navigator.hpp
+++ b/core/include/detray/navigation/caching_navigator.hpp
@@ -140,7 +140,7 @@ class caching_navigator
                                   : navigation::trust_level::e_fair);
         }
 
-        private:
+        // private:
         /// Insert a new element @param new_candidate before position @param pos
         DETRAY_HOST_DEVICE
         constexpr void insert(candidate_const_itr_t pos,
diff --git a/core/include/detray/navigation/detail/intersection_kernel_new.hpp b/core/include/detray/navigation/detail/intersection_kernel_new.hpp
new file mode 100644
index 000000000..63a8a00e3
--- /dev/null
+++ b/core/include/detray/navigation/detail/intersection_kernel_new.hpp
@@ -0,0 +1,356 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2021-2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/core/concepts.hpp"
+#include "detray/definitions/algebra.hpp"
+#include "detray/definitions/algorithms.hpp"
+#include "detray/definitions/detail/qualifiers.hpp"
+#include "detray/definitions/units.hpp"
+#include "detray/geometry/concepts.hpp"
+#include "detray/geometry/shapes/concentric_cylinder2D.hpp"
+#include "detray/geometry/shapes/cylinder2D.hpp"
+#include "detray/geometry/shapes/rectangle2D.hpp"
+#include "detray/navigation/intersection/intersection.hpp"
+#include "detray/navigation/intersection/intersection_config.hpp"
+#include "detray/tracks/ray.hpp"
+#include "detray/utils/invalid_values.hpp"
+#include "detray/utils/ranges.hpp"
+
+namespace detray::intersection {
+
+namespace detail {
+
+/// Filter the possible intersector types by the underlying geometry of the
+/// detector surfaces (deduced from the mask shapes)
+template <template <typename, typename, bool> class intersector_t,
+          bool do_debug = !intersection::contains_pos>
+struct select_intersector {
+    // For a planar object, always assume a cartesian frame (e.g. rectangle
+    // shape)
+    template <typename mask_t>
+    using type = std::conditional_t<
+        concepts::planar_object<mask_t>,
+        intersector_t<rectangle2D, typename mask_t::algebra_type, do_debug>,
+        intersector_t<typename mask_t::shape, typename mask_t::algebra_type,
+                      do_debug>>;
+};
+
+template <std::size_t N>
+struct initialize {
+
+    template <typename mask_group_t, typename mask_range_t,
+              typename is_container_t, typename result_t, typename traj_t,
+              typename surface_t, detray::concepts::transform3D transform_t,
+              detray::concepts::scalar scalar_t>
+    DETRAY_HOST_DEVICE DETRAY_INLINE constexpr void operator()(
+        const mask_group_t &mask_group, const mask_range_t &mask_range,
+        is_container_t &is_container, const result_t &result,
+        const traj_t &traj, const surface_t &sf_desc, const transform_t &ctf,
+        const intersection::config &cfg,
+        const scalar_t external_mask_tolerance = 0.f) const {
+
+        using intersection_t = typename is_container_t::value_type;
+
+        // Resolve the masks that belong to the surface
+        for (const auto &mask :
+             detray::ranges::subrange(mask_group, mask_range)) {
+
+            intersection_t is{};
+
+            // Build the resulting intersecion(s) from the intersection point
+            if constexpr (N > 1) {
+                std::uint8_t n_found{0u};
+
+                for (std::size_t i = 0u; i < N; ++i) {
+                    resolve_mask(is, traj, result[i], sf_desc, mask, ctf, cfg,
+                                 external_mask_tolerance);
+
+                    if (is.is_probably_inside()) {
+                        insert_sorted(is, is_container);
+                        ++n_found;
+                    }
+                    if (n_found == N) {
+                        return;
+                    }
+                }
+            } else {
+                resolve_mask(is, traj, result, sf_desc, mask, ctf, cfg,
+                             external_mask_tolerance);
+
+                if (is.is_probably_inside()) {
+                    insert_sorted(is, is_container);
+                    return;
+                }
+            }
+        }
+    }
+
+    template <typename intersection_t>
+    DETRAY_HOST_DEVICE constexpr void insert_sorted(
+        const intersection_t &sfi,
+        std::vector<intersection_t> &intersections) const {
+
+        auto itr_pos = detray::upper_bound(intersections.cbegin(),
+                                           intersections.cend(), sfi);
+
+        intersections.insert(itr_pos, sfi);
+    }
+
+    /// Specialization for the navigation state cache
+    template <typename nav_state_t>
+    DETRAY_HOST_DEVICE constexpr void insert_sorted(
+        const typename nav_state_t::value_type &sfi,
+        nav_state_t &intersections) const {
+
+        auto itr_pos{intersections.cbegin()};
+
+        // For just two candidates int the cache, the navigation state keeps
+        // the first as the previouly visited candidate -> no sorting needed
+        if constexpr (nav_state_t::capacity() > 2u) {
+            itr_pos = detray::upper_bound(intersections.cbegin(),
+                                          intersections.cend(), sfi);
+        }
+
+        intersections.insert(itr_pos, sfi);
+    }
+};
+
+struct visitor {
+    /// Operator function to calculate surface intersections
+    ///
+    /// @tparam intersector_t the intersector type corresponding to
+    ///                       the surface mask shape id
+    ///
+    /// @param traj is the input trajectory
+    /// @param surface is the input surface descriptor
+    /// @param det is the detector data
+    /// @param ctx is the geometry context
+    /// @param cfg the config data for the intersector
+    ///
+    /// @return the number of valid intersections
+    template <typename intersector_t, typename traj_t, typename is_container_t,
+              typename detector_t>
+    DETRAY_HOST_DEVICE DETRAY_INLINE constexpr auto operator()(
+        const intersector_t & /*intersector*/, const traj_t &traj,
+        const typename detector_t::surface_type &sf_desc,
+        const typename detector_t::transform3_type &ctf,
+        is_container_t &is_container, const detector_t &det,
+        const intersection::config &cfg,
+        const typename detector_t::scalar_type external_mask_tolerance =
+            0.f) const {
+
+        // Run the intersector
+        constexpr const intersector_t intersector{};
+        typename intersector_t::result_type result =
+            intersector.point_of_intersection(traj, ctf,
+                                              cfg.overstep_tolerance);
+
+        // Check if any valid solutions were found
+        if constexpr (intersector_t::n_solutions > 1) {
+            bool found_any{false};
+            for (const auto &ip : result) {
+                if (ip.is_valid()) {
+                    found_any = true;
+                }
+            }
+            if (!found_any) [[unlikely]] {
+                return;
+            }
+        } else {
+            if (!result.is_valid()) [[unlikely]] {
+                return;
+            }
+        }
+
+        // Branch by mask
+        det.mask_store()
+            .template visit<detail::initialize<intersector_t::n_solutions>>(
+                sf_desc.mask(), is_container, result, traj, sf_desc, ctf, cfg,
+                external_mask_tolerance);
+    }
+
+    /// Specialization for the cylinder2D shape
+    template <typename intersector_t, typename traj_t, typename is_container_t,
+              typename detector_t>
+        requires(
+            std::same_as<typename intersector_t::frame_type,
+                         cylindrical2D<typename detector_t::algebra_type>> &&
+            detray::concepts::has_mask<detector_t, cylinder2D>)
+    DETRAY_HOST_DEVICE DETRAY_INLINE constexpr auto operator()(
+        const intersector_t & /*intersector*/, const traj_t &traj,
+        const typename detector_t::surface_type &sf_desc,
+        const typename detector_t::transform3_type &ctf,
+        is_container_t &is_container, const detector_t &det,
+        const intersection::config &cfg,
+        const typename detector_t::scalar_type external_mask_tolerance =
+            0.f) const {
+
+        const auto &mask_coll =
+            det.mask_store().template get<detector_t::masks::id::e_cylinder2>();
+
+        const auto result = intersect_with_mask<intersector_t>(
+            traj, ctf, sf_desc.mask().index(), mask_coll, cfg);
+
+        // Check if any valid solutions were found
+        bool found_any{false};
+        for (const auto &ip : result) {
+            if (ip.is_valid()) {
+                found_any = true;
+            }
+        }
+        if (!found_any) [[unlikely]] {
+            return;
+        }
+
+        initialize<intersector_t::n_solutions>{}(
+            mask_coll, sf_desc.mask().index(), is_container, result, traj,
+            sf_desc, ctf, cfg, external_mask_tolerance);
+    }
+
+    /// Specialization for the concentric cylinder2D shape (cylinder portal)
+    template <typename intersector_t, typename traj_t, typename is_container_t,
+              typename detector_t>
+        requires(
+            std::same_as<
+                typename intersector_t::frame_type,
+                concentric_cylindrical2D<typename detector_t::algebra_type>> &&
+            detray::concepts::has_mask<detector_t, concentric_cylinder2D>)
+    DETRAY_HOST_DEVICE DETRAY_INLINE constexpr auto operator()(
+        const intersector_t & /*intersector*/, const traj_t &traj,
+        const typename detector_t::surface_type &sf_desc,
+        const typename detector_t::transform3_type &ctf,
+        is_container_t &is_container, const detector_t &det,
+        const intersection::config &cfg,
+        const typename detector_t::scalar_type external_mask_tolerance =
+            0.f) const {
+
+        const auto &mask_coll =
+            det.mask_store()
+                .template get<detector_t::masks::id::e_portal_cylinder2>();
+
+        const auto result = intersect_with_mask<intersector_t>(
+            traj, ctf, sf_desc.mask().index(), mask_coll, cfg);
+
+        // Check if any valid solutions were found
+        if (!result.is_valid()) [[unlikely]] {
+            return;
+        }
+
+        initialize<intersector_t::n_solutions>{}(
+            mask_coll, sf_desc.mask().index(), is_container, result, traj,
+            sf_desc, ctf, cfg, external_mask_tolerance);
+    }
+
+    private:
+    /// Operator function to calculate surface intersections with portal
+    /// cylinders
+    template <typename intersector_t, typename traj_t,
+              detray::concepts::transform3D transform_t, typename mask_range_t,
+              typename mask_coll_t>
+    DETRAY_HOST_DEVICE DETRAY_INLINE constexpr auto intersect_with_mask(
+        const traj_t &traj, const transform_t &ctf,
+        const mask_range_t mask_range, const mask_coll_t &mask_coll,
+        const intersection::config &cfg) const {
+
+        // Get the mask index in this detector
+        std::size_t mask_idx{detray::detail::invalid_value<std::size_t>()};
+        if constexpr (detray::concepts::interval<mask_range_t>) {
+            mask_idx = mask_range.lower();
+        } else {
+            mask_idx = mask_range;
+        }
+
+        assert(mask_idx < maks_coll.size());
+
+        constexpr const intersector_t intersector{};
+        return intersector.point_of_intersection(traj, ctf, mask_coll[mask_idx],
+                                                 cfg.overstep_tolerance);
+    }
+};
+
+template <template <typename, typename, bool> class intersector_t,
+          bool do_debug = !intersection::contains_pos, typename traj_t,
+          typename detector_t>
+DETRAY_HOST_DEVICE DETRAY_INLINE constexpr auto calculate_intersection(
+    const traj_t &traj, const typename detector_t::surface_type &sf_desc,
+    const typename detector_t::transform3_type &ctf, const detector_t &det,
+    const typename detector_t::geometry_context &ctx,
+    const intersection::config &cfg) {
+    // Filter the effective intersector types needed for the different
+    // mask shapes and match them to the detector mask ids at compile-time
+    using intersector_registry_t = types::mapped_registry<
+        typename detector_t::masks,
+        detail::select_intersector<intersector_t, do_debug>>;
+
+    /*types::print<types::list<typename intersector_registry_t::type_list>>();
+
+    for (auto i : intersector_registry_t::index_map()) {
+        DETRAY_INFO_HOST(i);
+    }
+
+    types::print<types::list<typename detector_t::masks::type_list>>();*/
+
+    static_assert(types::size<intersector_registry_t> <=
+                  types::size<typename detector_t::masks>);
+
+    // Visit only one of the intersectors according to the mask id
+    return types::visit<intersector_registry_t, visitor>(
+        sf_desc.mask().id(), traj, sf_desc, ctf, det, cfg);
+}
+
+}  // namespace detail
+
+template <template <typename, typename, bool> class intersector_t,
+          bool do_debug = !intersection::contains_pos, typename is_container_t,
+          typename traj_t, typename detector_t>
+DETRAY_HOST_DEVICE DETRAY_INLINE constexpr void intersect(
+    const traj_t &traj, const typename detector_t::surface_type &sf_desc,
+    is_container_t &is_container, const detector_t &det,
+    const typename detector_t::geometry_context &ctx,
+    const intersection::config &cfg,
+    const typename detector_t::scalar_type external_mask_tolerance = 0.f) {
+
+    const auto &ctf = det.transform_store().at(sf_desc.transform(), ctx);
+
+    // Filter the effective intersector types needed for the different
+    // mask shapes and match them to the detector mask ids at compile-time
+    using intersector_registry_t = types::mapped_registry<
+        typename detector_t::masks,
+        detail::select_intersector<intersector_t, do_debug>>;
+
+    static_assert(types::size<intersector_registry_t> <=
+                  types::size<typename detector_t::masks>);
+
+    // Visit only one of the intersectors according to the mask id
+    types::visit<intersector_registry_t, detail::visitor>(
+        sf_desc.mask().id(), traj, sf_desc, ctf, is_container, det, cfg,
+        external_mask_tolerance);
+}
+
+/*template <template <typename, typename, bool> class intersector_t,
+          bool do_debug = !intersection::contains_pos, typename intersection_t,
+          typename traj_t, typename detector_t>
+update(const traj_t &traj, intersection_t &is, const detector_t &det,
+       const typename detector_t::geometry_context &ctx,
+       const intersection::config &cfg,
+       const typename detector_t::scalar_type external_mask_tolerance = 0.f) {
+
+    // Branch by intersector
+    const bool success =
+        detail::calculate_intersection<intersector_t, do_debug>(
+            traj, is.sf_desc, det, ctx, cfg);
+
+    // Branch by mask
+    if (success) {
+        det.masks().template visit<update>();
+    }
+}*/
+
+}  // namespace detray::intersection
diff --git a/core/include/detray/navigation/detail/navigation_functions.hpp b/core/include/detray/navigation/detail/navigation_functions.hpp
index a695db473..16c3d5775 100644
--- a/core/include/detray/navigation/detail/navigation_functions.hpp
+++ b/core/include/detray/navigation/detail/navigation_functions.hpp
@@ -13,6 +13,7 @@
 #include "detray/geometry/surface.hpp"
 #include "detray/geometry/tracking_volume.hpp"
 #include "detray/navigation/detail/intersection_kernel.hpp"
+#include "detray/navigation/detail/intersection_kernel_new.hpp"
 #include "detray/navigation/intersection/ray_intersector.hpp"
 #include "detray/navigation/navigation_config.hpp"
 #include "detray/tracks/ray.hpp"
@@ -50,6 +51,20 @@ struct candidate_search {
         using algebra_t = typename detector_t::algebra_type;
         using scalar_t = dscalar<algebra_t>;
 
+        // Tangential to the track direction
+        detray::detail::ray<algebra_t> tangential{
+            track.pos(),
+            static_cast<scalar_t>(nav_state.direction()) * track.dir()};
+
+        // Perform intersection and add result to the navigation cache via
+        // @c nav_state.insert()
+        intersection::intersect<ray_intersector>(tangential, sf_descr,
+                                                 nav_state, det, ctx, inter_cfg,
+                                                 nav_state.external_tol());
+
+        /*using algebra_t = typename detector_t::algebra_type;
+        using scalar_t = dscalar<algebra_t>;
+
         const auto sf = detray::geometry::surface{det, sf_descr};
 
         // Tangential to the track direction
@@ -62,7 +77,7 @@ struct candidate_search {
         sf.template visit_mask<
             detray::detail::intersection_initialize<ray_intersector>>(
             nav_state, tangential, sf_descr, det.transform_store(), ctx,
-            inter_cfg, nav_state.external_tol());
+            inter_cfg, nav_state.external_tol());*/
     }
 };
 
diff --git a/core/include/detray/navigation/intersection/helix_cylinder_intersector.hpp b/core/include/detray/navigation/intersection/helix_cylinder_intersector.hpp
index 8e7b120af..de516113c 100644
--- a/core/include/detray/navigation/intersection/helix_cylinder_intersector.hpp
+++ b/core/include/detray/navigation/intersection/helix_cylinder_intersector.hpp
@@ -41,6 +41,7 @@ struct helix_intersector_impl<cylindrical2D<algebra_t>, algebra_t>
 
     public:
     using algebra_type = algebra_t;
+    using frame_type = cylindrical2D<algebra_t>;
 
     template <typename surface_descr_t>
     using intersection_type =
diff --git a/core/include/detray/navigation/intersection/helix_line_intersector.hpp b/core/include/detray/navigation/intersection/helix_line_intersector.hpp
index 485d1a12b..ee813949f 100644
--- a/core/include/detray/navigation/intersection/helix_line_intersector.hpp
+++ b/core/include/detray/navigation/intersection/helix_line_intersector.hpp
@@ -36,6 +36,7 @@ struct helix_intersector_impl<line2D<algebra_t>, algebra_t> {
 
     public:
     using algebra_type = algebra_t;
+    using frame_type = line2D<algebra_t>;
 
     template <typename surface_descr_t>
     using intersection_type =
diff --git a/core/include/detray/navigation/intersection/helix_plane_intersector.hpp b/core/include/detray/navigation/intersection/helix_plane_intersector.hpp
index 1cef78a14..6f3050b7b 100644
--- a/core/include/detray/navigation/intersection/helix_plane_intersector.hpp
+++ b/core/include/detray/navigation/intersection/helix_plane_intersector.hpp
@@ -39,6 +39,7 @@ struct helix_intersector_impl<cartesian2D<algebra_t>, algebra_t> {
 
     public:
     using algebra_type = algebra_t;
+    using frame_type = cartesian2D<algebra_t>;
 
     template <typename surface_descr_t>
     using intersection_type =
diff --git a/core/include/detray/navigation/intersection/ray_cylinder_intersector.hpp b/core/include/detray/navigation/intersection/ray_cylinder_intersector.hpp
index b3d3e741d..bff1a1023 100644
--- a/core/include/detray/navigation/intersection/ray_cylinder_intersector.hpp
+++ b/core/include/detray/navigation/intersection/ray_cylinder_intersector.hpp
@@ -31,6 +31,7 @@ template <algebra::concepts::aos algebra_t, bool resolve_pos>
 struct ray_intersector_impl<cylindrical2D<algebra_t>, algebra_t, resolve_pos> {
 
     using algebra_type = algebra_t;
+    using frame_type = cylindrical2D<algebra_t>;
 
     template <typename surface_descr_t>
     using intersection_type =
diff --git a/core/include/detray/navigation/intersection/ray_cylinder_portal_intersector.hpp b/core/include/detray/navigation/intersection/ray_cylinder_portal_intersector.hpp
index b61f94bfe..24eb159ce 100644
--- a/core/include/detray/navigation/intersection/ray_cylinder_portal_intersector.hpp
+++ b/core/include/detray/navigation/intersection/ray_cylinder_portal_intersector.hpp
@@ -34,6 +34,7 @@ struct ray_intersector_impl<concentric_cylindrical2D<algebra_t>, algebra_t,
                             resolve_pos> {
 
     using algebra_type = algebra_t;
+    using frame_type = concentric_cylindrical2D<algebra_t>;
 
     template <typename surface_descr_t>
     using intersection_type =
@@ -45,7 +46,7 @@ struct ray_intersector_impl<concentric_cylindrical2D<algebra_t>, algebra_t,
     // Maximum number of solutions this intersector can produce
     static constexpr std::uint8_t n_solutions{1u};
 
-    using result_type = intersection_point<algebra_t, dpoint2D<algebra_t>,
+    using result_type = intersection_point<algebra_t, dpoint3D<algebra_t>,
                                            intersection::contains_pos>;
 
     /// Operator function to find intersections between ray and cylinder mask
@@ -69,7 +70,7 @@ struct ray_intersector_impl<concentric_cylindrical2D<algebra_t>, algebra_t,
         const dscalar<algebra_t> overstep_tol = 0.f) const {
 
         using scalar_t = dscalar<algebra_t>;
-        using point2_t = dpoint2D<algebra_t>;
+        // using point2_t = dpoint2D<algebra_t>;
         using point3_t = dpoint3D<algebra_t>;
         using vector3_t = dvector3D<algebra_t>;
 
@@ -127,7 +128,7 @@ struct ray_intersector_impl<concentric_cylindrical2D<algebra_t>, algebra_t,
         }
 
         // Only need the global z-component for the mask check
-        return {path, point2_t{inv, ro[2] + path * rd[2]}};
+        return {path, ro + path * rd};
     }
 };
 
diff --git a/core/include/detray/navigation/intersection/ray_line_intersector.hpp b/core/include/detray/navigation/intersection/ray_line_intersector.hpp
index 057a70f86..5cb11a83d 100644
--- a/core/include/detray/navigation/intersection/ray_line_intersector.hpp
+++ b/core/include/detray/navigation/intersection/ray_line_intersector.hpp
@@ -29,6 +29,7 @@ template <algebra::concepts::aos algebra_t, bool resolve_pos>
 struct ray_intersector_impl<line2D<algebra_t>, algebra_t, resolve_pos> {
 
     using algebra_type = algebra_t;
+    using frame_type = line2D<algebra_t>;
 
     template <typename surface_descr_t>
     using intersection_type =
diff --git a/core/include/detray/navigation/intersection/ray_plane_intersector.hpp b/core/include/detray/navigation/intersection/ray_plane_intersector.hpp
index d45170c52..17c44ec0f 100644
--- a/core/include/detray/navigation/intersection/ray_plane_intersector.hpp
+++ b/core/include/detray/navigation/intersection/ray_plane_intersector.hpp
@@ -30,6 +30,7 @@ template <algebra::concepts::aos algebra_t, bool resolve_pos>
 struct ray_intersector_impl<cartesian2D<algebra_t>, algebra_t, resolve_pos> {
 
     using algebra_type = algebra_t;
+    using frame_type = cartesian2D<algebra_t>;
 
     template <typename surface_descr_t>
     using intersection_type =
diff --git a/core/include/detray/utils/type_list.hpp b/core/include/detray/utils/type_list.hpp
index be2b01846..90bc98bd1 100644
--- a/core/include/detray/utils/type_list.hpp
+++ b/core/include/detray/utils/type_list.hpp
@@ -17,7 +17,9 @@
 #include <string_view>
 #include <type_traits>
 
-namespace detray::types {
+namespace detray {
+
+namespace types {
 
 /// @brief type list implementation
 /// @see https://www.codingwiththomas.com/blog/getting-started-with-typelists
@@ -135,6 +137,22 @@ template <typename L, typename N>
 using push_front = typename do_push_front<N, L>::type;
 /// @}
 
+/// Traits for the type list/registry
+/// @{
+namespace detail {
+
+template <typename = void>
+struct is_type_list : public std::false_type {};
+
+template <typename... Ts>
+struct is_type_list<types::list<Ts...>> : public std::true_type {};
+
+template <typename L>
+inline constexpr bool is_type_list_v{is_type_list<L>::value};
+
+}  // namespace detail
+///@}
+
 /// Print the type list
 /// @{
 
@@ -240,7 +258,8 @@ struct print<list<Ts...>> {
 /// @returns the filled type list
 template <typename orig_list_t, class type_selector, std::size_t I = 0u,
           typename... Fs>
-consteval auto filtered_list(const list<Fs...>& filtered = list<>{}) {
+DETRAY_HOST_DEVICE consteval auto filtered_list(
+    const list<Fs...>& filtered = list<>{}) {
     static_assert(sizeof...(Fs) <= I, "Can only map down to list with ");
 
     // The current list of mapped types
@@ -278,7 +297,7 @@ consteval auto filtered_list(const list<Fs...>& filtered = list<>{}) {
 /// @returns the filled index array
 template <typename orig_list_t, class type_selector, std::size_t I = 0u,
           typename... Fs>
-consteval auto filtered_indices(
+DETRAY_HOST_DEVICE consteval auto filtered_indices(
     const list<Fs...>& filtered,
     std::array<dindex, size<orig_list_t>> idx_array = {0}) {
 
@@ -308,4 +327,16 @@ consteval auto filtered_indices(
     }
 }
 
-}  // namespace detray::types
+}  // namespace types
+
+/// Type list/registry concepts
+/// @{
+namespace concepts {
+
+template <typename L>
+concept type_list = types::detail::is_type_list_v<L>;
+
+}
+///@}
+
+}  // namespace detray
diff --git a/core/include/detray/utils/type_registry.hpp b/core/include/detray/utils/type_registry.hpp
index c2cae811b..7951a7b6f 100644
--- a/core/include/detray/utils/type_registry.hpp
+++ b/core/include/detray/utils/type_registry.hpp
@@ -18,7 +18,9 @@
 #include <type_traits>
 #include <utility>
 
-namespace detray::types {
+namespace detray {
+
+namespace types {
 
 /// @brief match types with indices/identifiers and vice versa.
 ///
@@ -95,7 +97,7 @@ class mapped_registry : public registry_t {
     template <typename id_t = id>
         requires(!std::convertible_to<id_t, std::size_t>)
     DETRAY_HOST_DEVICE static constexpr bool is_valid(const id_t orig_id) {
-        if (static_cast<std::size_t>(orig_id) >= m_idx_map.size()) {
+        if (static_cast<std::size_t>(orig_id) >= index_map().size()) {
             return false;
         } else {
             return mapped_index(orig_id) < n_types;
@@ -105,26 +107,23 @@ class mapped_registry : public registry_t {
 
     /// @returns the array that maps the original type positions to the new ones
     DETRAY_HOST_DEVICE
-    static constexpr const auto& index_map() { return m_idx_map; }
+    static consteval auto index_map() {
+        return detray::types::filtered_indices<orig_types, type_selector_t>(
+            detray::types::list{});
+    }
 
     /// @returns the filtered type index corresponding to the original type
     /// index
     DETRAY_HOST_DEVICE
     static constexpr std::size_t mapped_index(const std::size_t orig_idx) {
-        return m_idx_map.at(orig_idx);
+        return index_map().at(orig_idx);
     }
 
     /// @returns the filtered type index corresponding to the original type ID
     DETRAY_HOST_DEVICE
     static constexpr std::size_t mapped_index(const id orig_id) {
-        return m_idx_map.at(static_cast<std::size_t>(orig_id));
+        return index_map().at(static_cast<std::size_t>(orig_id));
     }
-
-    private:
-    /// How to map the original type positions to the new ones
-    static constexpr std::array<dindex, registry_t::n_types> m_idx_map =
-        detray::types::filtered_indices<orig_types, type_selector_t>(
-            detray::types::list{});
 };
 
 /// Specialization of the type list @c size trait
@@ -305,6 +304,26 @@ inline constexpr std::size_t index_cast =
 
 /// @}
 
+}  // namespace types
+
+namespace concepts {
+
+/// Type list/registry concepts
+/// @{
+template <typename R>
+concept type_registry =
+    type_list<typename R::type_list> && type_id<typename R::id>;
+
+template <typename R>
+concept mapped_type_registry =
+    type_list<typename R::type_list> && type_list<typename R::orig_types> &&
+    type_id<typename R::id>;
+///@}
+
+}  // namespace concepts
+
+namespace types {
+
 /// Variadic unrolling of the tuple that calls a functor on the element that
 /// corresponds to @param idx.
 ///
@@ -326,10 +345,18 @@ DETRAY_HOST_DEVICE decltype(auto) visit_helper(
         Args...>;
 
     // Check if the current tuple index is matched to the target index
-    if (idx == current_idx) {
-        return functor_t{}(
-            types::at<typename registry_t::type_list, current_idx>{},
-            std::forward<Args>(As)...);
+    if constexpr (concepts::mapped_type_registry<registry_t>) {
+        if (registry_t::mapped_index(idx) == current_idx) {
+            return functor_t{}(
+                types::at<typename registry_t::type_list, current_idx>{},
+                std::forward<Args>(As)...);
+        }
+    } else {
+        if (idx == current_idx) {
+            return functor_t{}(
+                types::at<typename registry_t::type_list, current_idx>{},
+                std::forward<Args>(As)...);
+        }
     }
 
     // Check the next index
@@ -388,4 +415,6 @@ DETRAY_HOST_DEVICE decltype(auto) visit(const typename registry_t::id id,
                                         std::forward<Args>(As)...);
 }
 
-}  // namespace detray::types
+}  // namespace types
+
+}  // namespace detray
diff --git a/tests/integration_tests/cpu/utils/type_registry.cpp b/tests/integration_tests/cpu/utils/type_registry.cpp
index 54ef726f4..5d4a5db0a 100644
--- a/tests/integration_tests/cpu/utils/type_registry.cpp
+++ b/tests/integration_tests/cpu/utils/type_registry.cpp
@@ -53,10 +53,13 @@ GTEST_TEST(detray_utils, mapped_type_registry) {
     types::print<mapped_registry_t::type_list>();
     std::cout << std::endl;
 
+    static_assert(concepts::mapped_type_registry<mapped_registry_t>,
+                  "Concept failure for mapped type registry");
+
     //
     // Test the mapping
     //
-    constexpr const auto& idx_array = mapped_registry_t::index_map();
+    constexpr auto idx_array = mapped_registry_t::index_map();
 
     static_assert(mapped_registry_t::n_types == 3u);
     static_assert(types::size<mapped_registry_t> == 3u);
diff --git a/tests/unit_tests/cpu/navigation/caching_navigator.cpp b/tests/unit_tests/cpu/navigation/caching_navigator.cpp
index c4a24c41d..9f966e486 100644
--- a/tests/unit_tests/cpu/navigation/caching_navigator.cpp
+++ b/tests/unit_tests/cpu/navigation/caching_navigator.cpp
@@ -121,7 +121,7 @@ inline void step_and_check(navigator_t &nav, stepper_t &stepper,
 }  // namespace detray
 
 /// This tests the construction and general methods of the navigator
-GTEST_TEST(detray_navigation, navigator_toy_geometry) {
+GTEST_TEST(detray_navigation, caching_navigator_toy_geometry) {
     using namespace detray;
     using namespace detray::navigation;
 
@@ -343,7 +343,7 @@ GTEST_TEST(detray_navigation, navigator_toy_geometry) {
     ASSERT_TRUE(navigation.finished()) << navigation.inspector().to_string();
 }
 
-GTEST_TEST(detray_navigation, navigator_wire_chamber) {
+GTEST_TEST(detray_navigation, caching_navigator_wire_chamber) {
 
     using namespace detray;
     using namespace detray::navigation;
diff --git a/tests/unit_tests/cpu/utils/type_registry.cpp b/tests/unit_tests/cpu/utils/type_registry.cpp
index d571eae22..503f1790a 100644
--- a/tests/unit_tests/cpu/utils/type_registry.cpp
+++ b/tests/unit_tests/cpu/utils/type_registry.cpp
@@ -36,6 +36,9 @@ GTEST_TEST(detray_utils, type_registry) {
     using type_registry_t =
         types::registry<test_ids, int, double, float, float>;
 
+    static_assert(concepts::type_registry<type_registry_t>,
+                  "Concept failure for type registry");
+
     static_assert(type_registry_t::n_types == 4u,
                   "Incorrect number of types in registry");
     static_assert(types::size<type_registry_t> == 4u,