diff --git a/core/include/detray/utils/ranges/chain.hpp b/core/include/detray/utils/ranges/chain.hpp
index 66a7cbda59..bdc3f6284a 100644
--- a/core/include/detray/utils/ranges/chain.hpp
+++ b/core/include/detray/utils/ranges/chain.hpp
@@ -24,7 +24,7 @@ struct chain_iterator;
 
 }
 
-/// @brief Chain together different ranges of the same type.
+/// @brief Range adaptor that chains together different ranges of the same type.
 ///
 /// @tparam I the number of ranges in the chain.
 /// @tparam range_itr_t the iterator type of the ranges.
@@ -177,10 +177,7 @@ struct chain_iterator {
     DETRAY_HOST_DEVICE
     constexpr chain_iterator(const iterator_coll_t &begins,
                              const iterator_coll_t &ends)
-        : m_begins(&begins),
-          m_ends(&ends),
-          m_iter{detray::detail::get<0>(*m_begins)},
-          m_idx{0} {}
+        : m_begins(&begins), m_ends(&ends), m_iter{(*m_begins)[0]}, m_idx{0} {}
 
     /// Fully parametrized construction
     DETRAY_HOST_DEVICE
diff --git a/core/include/detray/utils/ranges/enumerate.hpp b/core/include/detray/utils/ranges/enumerate.hpp
index 5fa9f4ec51..5e4078c36a 100644
--- a/core/include/detray/utils/ranges/enumerate.hpp
+++ b/core/include/detray/utils/ranges/enumerate.hpp
@@ -178,7 +178,7 @@ class enumerate_view : public detray::ranges::view_interface<
     DETRAY_HOST_DEVICE constexpr explicit enumerate_view(range_t &&rng)
         : m_begin{detray::ranges::begin(std::forward<range_t>(rng)), 0},
           m_end{detray::ranges::end(std::forward<range_t>(rng)),
-                rng.size() - detray::ranges::range_difference_t<range_t>{1}} {}
+                rng.size() - dindex{1}} {}
 
     /// Construct from a @param range that will be enumerated beginning at
     /// @param start.
@@ -189,8 +189,7 @@ class enumerate_view : public detray::ranges::view_interface<
                                                          dindex start)
         : m_begin{detray::ranges::begin(std::forward<range_t>(rng)), start},
           m_end{detray::ranges::end(std::forward<range_t>(rng)),
-                start + rng.size() -
-                    detray::ranges::range_difference_t<range_t>{1}} {}
+                start + rng.size() - dindex{1}} {}
 
     /// Copy assignment operator
     DETRAY_HOST_DEVICE
@@ -232,7 +231,8 @@ struct enumerate : public enumerate_view<range_itr_t, incr_t> {
     template <
         typename range_t,
         std::enable_if_t<detray::ranges::range<range_t>::value, bool> = true>
-    DETRAY_HOST_DEVICE constexpr enumerate(range_t &&rng, dindex start)
+    DETRAY_HOST_DEVICE constexpr enumerate(
+        range_t &&rng, detray::ranges::range_difference_t<range_t> start)
         : base_type(std::forward<range_t>(rng), start) {}
 
     /// Construct from a @param range and an index range provided by a volume
diff --git a/core/include/detray/utils/ranges/pick.hpp b/core/include/detray/utils/ranges/pick.hpp
index bb828bd521..eecedac4c0 100644
--- a/core/include/detray/utils/ranges/pick.hpp
+++ b/core/include/detray/utils/ranges/pick.hpp
@@ -18,7 +18,8 @@
 
 namespace detray::ranges {
 
-/// @brief Indexes the elements of a range by iterating through an index range.
+/// @brief Range adaptor that indexes the elements of a range using another
+///        index range.
 ///
 /// @tparam range_itr_t the iterator type of the enumerated range
 /// @tparam sequence_itr_t range of indices.
diff --git a/core/include/detray/utils/ranges/ranges.hpp b/core/include/detray/utils/ranges/ranges.hpp
index a385a2125f..d15928ba92 100644
--- a/core/include/detray/utils/ranges/ranges.hpp
+++ b/core/include/detray/utils/ranges/ranges.hpp
@@ -15,101 +15,179 @@
 
 namespace detray::ranges {
 
-/// @brief Detail interface of an iterable type.
+/// @brief Provides c++17 detray iterators in std::ranges style, meant to be
+////       used in device code.
 ///
-/// Base case: The type is not iterable
-template <typename T, typename = void>
-struct range : public std::false_type {
-    using type = void;
-};
-
-/// @brief Check if a type is iterable and extract iterator type.
+/// @note Does make use of concepts and des not implement full ranges standard
+/// (e.g. not every requirement is modelled, range/view complexity guarantees
+/// are not given and there is no lazy-evaluation).
+/// missing: ranges::sized_range, ranges::viewable_range, ranges::constant_range
 ///
-/// A range has a begin() and an end() member function, which is guranteed by
-/// simply calling std::begin and std::end.
-/// In case of @c vecmem::device_vector the iterator is a pointer type.
-template <typename T>
-struct range<
-    T, std::enable_if_t<std::is_class_v<std::decay_t<decltype(std::begin(
-                            std::declval<T&>()))>> or
-                            std::is_pointer_v<std::decay_t<decltype(std::begin(
-                                std::declval<T&>()))>>,
-                        void>> : public std::true_type {
-    using iterator_type =
-        std::decay_t<decltype(std::begin(std::declval<T&>()))>;
-    using const_iterator_type =
-        std::decay_t<decltype(std::cbegin(std::declval<T&>()))>;
-};
-
-class base_view;
-
-template <typename range_t>
-class view_interface;
-
-template <typename T>
-inline constexpr bool enable_view =
-    std::is_base_of_v<base_view, T> or std::is_base_of_v<view_interface<T>, T>;
-
-template <class T>
-inline constexpr bool is_view = detray::ranges::range<T>::value and
-    std::is_object_v<T>&& std::is_move_constructible_v<T>and enable_view<T>;
+/// @see https://en.cppreference.com/w/cpp/ranges
+/// @{
 
-/// Simply import the std versions of basic iterator functionality
+/// Simply import the std versions of basic iterator functionality for now
 /// @{
 using std::begin;
 using std::cbegin;
 using std::cend;
+using std::crbegin;
+using std::crend;
 using std::end;
 using std::rbegin;
 using std::rend;
 
+using std::size;
+// ranges::ssize;
+using std::data;
+using std::empty;
+// ranges::cdata
+
 using std::advance;
 using std::distance;
 using std::next;
 using std::prev;
 /// @}
 
-/// Implementation of the detray ranges specific functions (size, data)
-/// @{
-using std::size;
-
-/// @}
-
-/// Compliance with std::ranges typedefs,
+/// Ranges typedefs,
 /// @see https://en.cppreference.com/w/cpp/ranges/iterator_t
 /// @{
-template <class T>
-using iterator_t = decltype(detray::ranges::begin(std::declval<T&>()));
+template <class R>
+using iterator_t = decltype(detray::ranges::begin(std::declval<R&>()));
 
-template <class T>
-using const_iterator_t = iterator_t<const T>;
+template <class R>
+using const_iterator_t = iterator_t<const R>;
 
-template <class T>
-using sentinel_t = decltype(detray::ranges::end(std::declval<T&>()));
+template <class R>
+using sentinel_t = decltype(detray::ranges::end(std::declval<R&>()));
 
-template <class T>
-using range_size_t = decltype(detray::ranges::size(std::declval<T&>()));
+template <class R>
+using range_size_t = decltype(detray::ranges::size(std::declval<R&>()));
 
-template <class T>
+template <class R>
 using range_difference_t = typename std::iterator_traits<
-    detray::ranges::iterator_t<T>>::difference_type;
+    detray::ranges::iterator_t<R>>::difference_type;
 
-template <class T>
+template <class R>
 using range_value_t =
-    typename std::iterator_traits<detray::ranges::iterator_t<T>>::value_type;
+    typename std::iterator_traits<detray::ranges::iterator_t<R>>::value_type;
 
-template <class T>
+template <class R>
 using range_reference_t =
-    typename std::iterator_traits<detray::ranges::iterator_t<T>>::reference;
+    typename std::iterator_traits<detray::ranges::iterator_t<R>>::reference;
+
+template <class R>
+using range_const_reference_t = const range_reference_t<R>;
 
-template <class T>
-using range_const_reference_t = const range_reference_t<T>;
+template <class R>
+using range_rvalue_reference_t = std::decay_t<range_value_t<R>>&&;
 
-template <class T>
-using range_rvalue_reference_t = std::decay_t<range_value_t<T>>&&;
 /// @}
 
-// https://en.cppreference.com/w/cpp/ranges/view
+/// Range traits
+/// @{
+
+/// Base case: The type is not a 'range'
+template <class R, typename = void>
+struct range : public std::false_type {
+    using type = void;
+};
+
+/// @brief A range has a begin() and an end() member function
+///
+/// @see https://en.cppreference.com/w/cpp/ranges/range
+///
+/// Existance of 'begin' and 'end' is guranteed by simply calling std::begin
+/// and std::end.
+/// @note In case of @c vecmem::device_vector the iterator is a pointer type.
+template <class R>
+struct range<
+    R, std::enable_if_t<
+           (std::is_class_v<std::decay_t<decltype(detray::ranges::begin(
+                std::declval<R&>()))>> or
+            std::is_pointer_v<std::decay_t<decltype(detray::ranges::begin(
+                std::declval<R&>()))>>)and(std::
+                                               is_class_v<std::decay_t<
+                                                   decltype(detray::ranges::end(
+                                                       std::declval<R&>()))>> or
+                                           std::is_pointer_v<std::decay_t<
+                                               decltype(detray::ranges::end(
+                                                   std::declval<R&>()))>>),
+           void>> : public std::true_type {};
+
+template <class R>
+inline constexpr bool range_v = detray::ranges::range<R>::value;
+
+template <class R>
+inline constexpr bool input_range_v = detray::ranges::range_v<R>and
+    std::is_base_of_v<std::input_iterator_tag,
+                      typename std::iterator_traits<
+                          detray::ranges::iterator_t<R>>::iterator_category>;
+
+template <class R>
+inline constexpr bool output_range_v = detray::ranges::range_v<R>and
+    std::is_base_of_v<std::output_iterator_tag,
+                      typename std::iterator_traits<
+                          detray::ranges::iterator_t<R>>::iterator_category>;
+
+template <class R>
+inline constexpr bool forward_range_v = detray::ranges::range_v<R>and
+    std::is_base_of_v<std::forward_iterator_tag,
+                      typename std::iterator_traits<
+                          detray::ranges::iterator_t<R>>::iterator_category>;
+
+template <class R>
+inline constexpr bool bidirectional_range_v = detray::ranges::range_v<R>and
+    std::is_base_of_v<std::bidirectional_iterator_tag,
+                      typename std::iterator_traits<
+                          detray::ranges::iterator_t<R>>::iterator_category>;
+
+template <class R>
+inline constexpr bool random_access_range_v = detray::ranges::range_v<R>and
+    std::is_base_of_v<std::random_access_iterator_tag,
+                      typename std::iterator_traits<
+                          detray::ranges::iterator_t<R>>::iterator_category>;
+
+// Available only in c++20
+/*template <typename R>
+inline constexpr bool contiguous_range_v = range_v<R> and
+std::is_base_of_v<std::contiguous_iterator_tag, typename
+std::iterator_traits<detray::ranges::iterator_t<R>>::iterator_category>;*/
+
+/// @see https://en.cppreference.com/w/cpp/ranges/borrowed_range
+template <class R>
+inline constexpr bool enable_borrowed_range = false;
+
+template <class R>
+inline constexpr bool borrowed_range =
+    detray::ranges::range_v<R> &&
+    (std::is_lvalue_reference_v<R> ||
+     ranges::enable_borrowed_range<
+         std::remove_reference_t<std::remove_cv_t<R>>>);
+
+/// @brief models a dangling iterator
+/// @see https://en.cppreference.com/w/cpp/ranges/dangling
+struct dangling {
+    constexpr dangling() noexcept = default;
+    template <class... Args>
+    constexpr dangling(Args&&...) noexcept {}
+};
+
+template <class R>
+using borrowed_iterator_t =
+    std::conditional_t<borrowed_range<R>, detray::ranges::iterator_t<R>,
+                       dangling>;
+
+/// @see https://en.cppreference.com/w/cpp/ranges/common_range
+template <class R>
+inline constexpr bool common_range =
+    detray::ranges::range_v<R>&& std::is_same_v<detray::ranges::iterator_t<R>,
+                                                detray::ranges::sentinel_t<R>>;
+/// @}
+
+/// Definition of 'view'
+/// @see https://en.cppreference.com/w/cpp/ranges/view
+/// @{
 
 /// Tags a type as a view
 struct base_view {};
@@ -150,4 +228,15 @@ struct view_interface : public base_view {
     view_impl_t* const m_impl_ptr{static_cast<view_impl_t*>(this)};
 };
 
+/// View traits
+/// @{
+template <typename R>
+inline constexpr bool enable_view =
+    std::is_base_of_v<base_view, R> or std::is_base_of_v<view_interface<R>, R>;
+
+template <class R>
+inline constexpr bool view = detray::ranges::range_v<R>and std::is_object_v<R>&&
+    std::is_move_constructible_v<R>and enable_view<R>;
+/// @}
+
 }  // namespace detray::ranges
\ No newline at end of file
diff --git a/core/include/detray/utils/ranges/subrange.hpp b/core/include/detray/utils/ranges/subrange.hpp
index 89b38da1ad..9534b4a783 100644
--- a/core/include/detray/utils/ranges/subrange.hpp
+++ b/core/include/detray/utils/ranges/subrange.hpp
@@ -131,4 +131,10 @@ template <typename deduced_range_t, typename volume_t,
 DETRAY_HOST_DEVICE subrange(deduced_range_t &&range, const volume_t &vol)
     ->subrange<deduced_range_t>;
 
+/// @see https://en.cppreference.com/w/cpp/ranges/borrowed_iterator_t
+template <class R>
+using borrowed_subrange_t =
+    std::conditional_t<borrowed_range<R>, detray::ranges::subrange<R>,
+                       dangling>;
+
 }  // namespace detray::ranges
diff --git a/tests/unit_tests/core/utils_ranges.cpp b/tests/unit_tests/core/utils_ranges.cpp
index a296b18ac2..0839acceb6 100644
--- a/tests/unit_tests/core/utils_ranges.cpp
+++ b/tests/unit_tests/core/utils_ranges.cpp
@@ -11,13 +11,84 @@
 #include "tests/common/test_defs.hpp"
 
 // detray core
+#include "detray/definitions/containers.hpp"
 #include "detray/utils/ranges.hpp"
 
+// Vecmem include(s)
+#include "vecmem/containers/device_vector.hpp"
+
 // System include(s)
+#include <forward_list>
+#include <list>
 #include <type_traits>
 
 using namespace detray;
 
+// Test basic ranges definitions
+TEST(utils, ranges) {
+    //
+    // detray containers
+    //
+    // std::vector
+    static_assert(detray::ranges::range_v<dvector<float>>);
+    static_assert(not detray::ranges::view<dvector<float>>);
+    static_assert(detray::ranges::random_access_range_v<dvector<float>>);
+    static_assert(detray::ranges::common_range<dvector<float>>);
+
+    // std::array
+    static_assert(detray::ranges::range_v<darray<float, 1>>);
+    static_assert(not detray::ranges::view<darray<float, 1>>);
+    static_assert(detray::ranges::random_access_range_v<darray<float, 1>>);
+    static_assert(detray::ranges::common_range<darray<float, 1>>);
+
+    // std::map
+    static_assert(detray::ranges::range_v<dmap<int, float>>);
+    static_assert(not detray::ranges::view<dmap<int, float>>);
+    static_assert(detray::ranges::bidirectional_range_v<dmap<int, float>>);
+    static_assert(not detray::ranges::random_access_range_v<dmap<int, float>>);
+    static_assert(detray::ranges::common_range<dmap<int, float>>);
+
+    // std::tuple
+    static_assert(not detray::ranges::range_v<dtuple<int, float>>);
+    static_assert(not detray::ranges::view<dtuple<int, float>>);
+
+    //
+    // vecmem containers
+    //
+
+    // vecmem::device_vector
+    static_assert(detray::ranges::range_v<vecmem::device_vector<float>>);
+    static_assert(not detray::ranges::view<vecmem::device_vector<float>>);
+    static_assert(
+        detray::ranges::random_access_range_v<vecmem::device_vector<float>>);
+    static_assert(detray::ranges::common_range<vecmem::device_vector<float>>);
+
+    // vecmem::jagged_vector
+    static_assert(detray::ranges::range_v<djagged_vector<float>>);
+    static_assert(not detray::ranges::view<djagged_vector<float>>);
+    static_assert(detray::ranges::random_access_range_v<djagged_vector<float>>);
+    static_assert(detray::ranges::common_range<djagged_vector<float>>);
+
+    //
+    // Some additional STL containers
+    //
+
+    // std::forward_list
+    static_assert(detray::ranges::range_v<std::forward_list<float>>);
+    static_assert(not detray::ranges::view<std::forward_list<float>>);
+    static_assert(detray::ranges::forward_range_v<std::forward_list<float>>);
+    static_assert(
+        not detray::ranges::bidirectional_range_v<std::forward_list<float>>);
+    static_assert(detray::ranges::common_range<std::forward_list<float>>);
+
+    // std::list
+    static_assert(detray::ranges::range_v<std::list<float>>);
+    static_assert(not detray::ranges::view<std::list<float>>);
+    static_assert(detray::ranges::bidirectional_range_v<std::list<float>>);
+    static_assert(not detray::ranges::random_access_range_v<std::list<float>>);
+    static_assert(detray::ranges::common_range<std::list<float>>);
+}
+
 // Unittest for the generation of a single element sequence
 TEST(utils, ranges_single) {
 
@@ -26,21 +97,18 @@ TEST(utils, ranges_single) {
     auto sngl = detray::views::single(value);
 
     // general tests
-    ASSERT_TRUE(detray::ranges::range<decltype(sngl)>::value);
-    ASSERT_TRUE(detray::ranges::is_view<decltype(sngl)>);
-    ASSERT_TRUE(std::is_copy_assignable_v<decltype(sngl)>);
+    static_assert(std::is_copy_assignable_v<decltype(sngl)>);
+    static_assert(detray::ranges::range_v<decltype(sngl)>);
+    static_assert(detray::ranges::view<decltype(sngl)>);
+    static_assert(detray::ranges::bidirectional_range_v<decltype(sngl)>);
+    static_assert(not detray::ranges::random_access_range_v<decltype(sngl)>);
 
     // Test prerequisits for LagacyIterator
-    ASSERT_TRUE(
+    static_assert(
         std::is_copy_constructible_v<typename decltype(sngl)::iterator_t>);
-    ASSERT_TRUE(std::is_copy_assignable_v<typename decltype(sngl)::iterator_t>);
-    ASSERT_TRUE(std::is_destructible_v<typename decltype(sngl)::iterator_t>);
-
-    // Check iterator category
-    constexpr bool is_correct_itr_tag =
-        std::is_same_v<typename decltype(sngl)::iterator_t::iterator_category,
-                       std::bidirectional_iterator_tag>;
-    ASSERT_TRUE(is_correct_itr_tag);
+    static_assert(
+        std::is_copy_assignable_v<typename decltype(sngl)::iterator_t>);
+    static_assert(std::is_destructible_v<typename decltype(sngl)::iterator_t>);
 
     // Test inherited member functions
     ASSERT_EQ(sngl[0], value);
@@ -62,21 +130,18 @@ TEST(utils, ranges_iota_single) {
     auto seq = detray::views::iota(single);
 
     // general tests
-    ASSERT_TRUE(detray::ranges::range<decltype(seq)>::value);
-    ASSERT_TRUE(detray::ranges::is_view<decltype(seq)>);
-    ASSERT_TRUE(std::is_copy_assignable_v<decltype(seq)>);
+    static_assert(std::is_copy_assignable_v<decltype(seq)>);
+    static_assert(detray::ranges::range_v<decltype(seq)>);
+    static_assert(detray::ranges::view<decltype(seq)>);
+    static_assert(detray::ranges::input_range_v<decltype(seq)>);
+    static_assert(not detray::ranges::forward_range_v<decltype(seq)>);
 
     // Test prerequisits for LagacyIterator
-    ASSERT_TRUE(
+    static_assert(
         std::is_copy_constructible_v<typename decltype(seq)::iterator_t>);
-    ASSERT_TRUE(std::is_copy_assignable_v<typename decltype(seq)::iterator_t>);
-    ASSERT_TRUE(std::is_destructible_v<typename decltype(seq)::iterator_t>);
-
-    // Check iterator category
-    constexpr bool is_correct_itr_tag =
-        std::is_same_v<typename decltype(seq)::iterator_t::iterator_category,
-                       std::input_iterator_tag>;
-    ASSERT_TRUE(is_correct_itr_tag);
+    static_assert(
+        std::is_copy_assignable_v<typename decltype(seq)::iterator_t>);
+    static_assert(std::is_destructible_v<typename decltype(seq)::iterator_t>);
 
     // Test inherited member functions
     ASSERT_EQ(seq[1], single + 1);
@@ -98,21 +163,18 @@ TEST(utils, ranges_iota_interval) {
     auto seq = detray::views::iota(interval);
 
     // general tests
-    ASSERT_TRUE(detray::ranges::range<decltype(seq)>::value);
-    ASSERT_TRUE(detray::ranges::is_view<decltype(seq)>);
-    ASSERT_TRUE(std::is_copy_assignable_v<decltype(seq)>);
+    static_assert(detray::ranges::range_v<decltype(seq)>);
+    static_assert(detray::ranges::view<decltype(seq)>);
+    static_assert(std::is_copy_assignable_v<decltype(seq)>);
+    static_assert(detray::ranges::input_range_v<decltype(seq)>);
+    static_assert(not detray::ranges::forward_range_v<decltype(seq)>);
 
     // Test prerequisits for LagacyIterator
-    ASSERT_TRUE(
+    static_assert(
         std::is_copy_constructible_v<typename decltype(seq)::iterator_t>);
-    ASSERT_TRUE(std::is_copy_assignable_v<typename decltype(seq)::iterator_t>);
-    ASSERT_TRUE(std::is_destructible_v<typename decltype(seq)::iterator_t>);
-
-    // Check iterator category
-    constexpr bool is_correct_itr_tag =
-        std::is_same_v<typename decltype(seq)::iterator_t::iterator_category,
-                       std::input_iterator_tag>;
-    ASSERT_TRUE(is_correct_itr_tag);
+    static_assert(
+        std::is_copy_assignable_v<typename decltype(seq)::iterator_t>);
+    static_assert(std::is_destructible_v<typename decltype(seq)::iterator_t>);
 
     // Test inherited member functions
     ASSERT_EQ(seq[1], 3UL);
@@ -141,24 +203,19 @@ TEST(utils, ranges_enumerate) {
     auto enumerator = detray::views::enumerate(seq);
 
     // general tests
-    ASSERT_TRUE(detray::ranges::range<decltype(enumerator)>::value);
-    ASSERT_TRUE(detray::ranges::is_view<decltype(enumerator)>);
-    ASSERT_TRUE(std::is_copy_assignable_v<decltype(enumerator)>);
+    static_assert(detray::ranges::range_v<decltype(enumerator)>);
+    static_assert(detray::ranges::view<decltype(enumerator)>);
+    static_assert(std::is_copy_assignable_v<decltype(enumerator)>);
+    static_assert(detray::ranges::random_access_range_v<decltype(enumerator)>);
 
     // Test prerequisits for LagacyIterator
-    ASSERT_TRUE(std::is_copy_constructible_v<
-                typename decltype(enumerator)::iterator_t>);
-    ASSERT_TRUE(
+    static_assert(std::is_copy_constructible_v<
+                  typename decltype(enumerator)::iterator_t>);
+    static_assert(
         std::is_copy_assignable_v<typename decltype(enumerator)::iterator_t>);
-    ASSERT_TRUE(
+    static_assert(
         std::is_destructible_v<typename decltype(enumerator)::iterator_t>);
 
-    // Check iterator category
-    constexpr bool is_correct_itr_tag = std::is_same_v<
-        typename decltype(enumerator)::iterator_t::iterator_category,
-        std::random_access_iterator_tag>;
-    ASSERT_TRUE(is_correct_itr_tag);
-
     // Test inherited member functions
     const auto [i, v] = enumerator[2];
     ASSERT_EQ(i, 2UL);
@@ -189,22 +246,18 @@ TEST(utils, ranges_chain) {
     auto chained = detray::views::chain(interval_1, interval_2);
 
     // general tests
-    ASSERT_TRUE(detray::ranges::range<decltype(chained)>::value);
-    ASSERT_TRUE(detray::ranges::is_view<decltype(chained)>);
-    ASSERT_TRUE(std::is_copy_assignable_v<decltype(chained)>);
+    static_assert(detray::ranges::range_v<decltype(chained)>);
+    static_assert(detray::ranges::view<decltype(chained)>);
+    static_assert(std::is_copy_assignable_v<decltype(chained)>);
+    static_assert(detray::ranges::random_access_range_v<decltype(chained)>);
 
     // Test prerequisits for LagacyIterator
-    ASSERT_TRUE(
+    static_assert(
         std::is_copy_constructible_v<typename decltype(chained)::iterator_t>);
-    ASSERT_TRUE(
+    static_assert(
         std::is_copy_assignable_v<typename decltype(chained)::iterator_t>);
-    ASSERT_TRUE(std::is_destructible_v<typename decltype(chained)::iterator_t>);
-
-    // Check iterator category
-    constexpr bool is_correct_itr_tag = std::is_same_v<
-        typename decltype(chained)::iterator_t::iterator_category,
-        std::random_access_iterator_tag>;
-    ASSERT_TRUE(is_correct_itr_tag);
+    static_assert(
+        std::is_destructible_v<typename decltype(chained)::iterator_t>);
 
     // Test inherited member functions
     ASSERT_EQ(chained[1], 3UL);
@@ -236,24 +289,19 @@ TEST(utils, ranges_pick) {
     auto selected = detray::views::pick(seq, indices);
 
     // general tests
-    ASSERT_TRUE(detray::ranges::range<decltype(selected)>::value);
-    ASSERT_TRUE(detray::ranges::is_view<decltype(selected)>);
-    ASSERT_TRUE(std::is_copy_assignable_v<decltype(selected)>);
+    static_assert(detray::ranges::range_v<decltype(selected)>);
+    static_assert(detray::ranges::view<decltype(selected)>);
+    static_assert(std::is_copy_assignable_v<decltype(selected)>);
+    static_assert(detray::ranges::random_access_range_v<decltype(selected)>);
 
     // Test prerequisits for LagacyIterator
-    ASSERT_TRUE(
+    static_assert(
         std::is_copy_constructible_v<typename decltype(selected)::iterator_t>);
-    ASSERT_TRUE(
+    static_assert(
         std::is_copy_assignable_v<typename decltype(selected)::iterator_t>);
-    ASSERT_TRUE(
+    static_assert(
         std::is_destructible_v<typename decltype(selected)::iterator_t>);
 
-    // Check iterator category
-    constexpr bool is_correct_itr_tag = std::is_same_v<
-        typename decltype(selected)::iterator_t::iterator_category,
-        std::random_access_iterator_tag>;
-    ASSERT_TRUE(is_correct_itr_tag);
-
     // Test inherited member functions
     const auto [i, v] = selected[2];
     ASSERT_EQ(i, 7UL);
@@ -286,21 +334,16 @@ TEST(utils, ranges_subrange) {
     auto sr = detray::ranges::subrange(seq, interval);
 
     // general tests
-    ASSERT_TRUE(detray::ranges::range<decltype(sr)>::value);
-    ASSERT_TRUE(detray::ranges::is_view<decltype(sr)>);
-    ASSERT_TRUE(std::is_copy_assignable_v<decltype(sr)>);
+    static_assert(detray::ranges::range_v<decltype(sr)>);
+    static_assert(detray::ranges::view<decltype(sr)>);
+    static_assert(std::is_copy_assignable_v<decltype(sr)>);
+    static_assert(detray::ranges::random_access_range_v<decltype(sr)>);
 
     // Test prerequisits for LagacyIterator
-    ASSERT_TRUE(
+    static_assert(
         std::is_copy_constructible_v<typename decltype(sr)::iterator_t>);
-    ASSERT_TRUE(std::is_copy_assignable_v<typename decltype(sr)::iterator_t>);
-    ASSERT_TRUE(std::is_destructible_v<typename decltype(sr)::iterator_t>);
-
-    // Check iterator category
-    constexpr bool is_correct_itr_tag =
-        std::is_same_v<typename decltype(sr)::iterator_t::iterator_category,
-                       std::random_access_iterator_tag>;
-    ASSERT_TRUE(is_correct_itr_tag);
+    static_assert(std::is_copy_assignable_v<typename decltype(sr)::iterator_t>);
+    static_assert(std::is_destructible_v<typename decltype(sr)::iterator_t>);
 
     ASSERT_EQ(sr[1], seq[begin + 1]);
     ASSERT_EQ(sr.size(), 3UL);
@@ -336,10 +379,8 @@ TEST(utils, ranges_subrange_iota) {
     auto iota_sr = detray::ranges::subrange(detray::views::iota(seq), interval);
 
     // Check iterator category
-    constexpr bool is_correct_itr_tag = std::is_same_v<
-        typename decltype(iota_sr)::iterator_t::iterator_category,
-        std::input_iterator_tag>;
-    ASSERT_TRUE(is_correct_itr_tag);
+    static_assert(detray::ranges::input_range_v<decltype(iota_sr)>);
+    static_assert(not detray::ranges::forward_range_v<decltype(iota_sr)>);
 
     std::size_t i{4};
     for (const auto v : iota_sr) {
@@ -364,10 +405,7 @@ TEST(utils, ranges_enumerated_subrange) {
         detray::views::enumerate(detray::ranges::subrange(seq, interval));
 
     // Check iterator category
-    constexpr bool is_correct_itr_tag = std::is_same_v<
-        typename decltype(enum_sr)::iterator_t::iterator_category,
-        std::random_access_iterator_tag>;
-    ASSERT_TRUE(is_correct_itr_tag);
+    static_assert(detray::ranges::random_access_range_v<decltype(enum_sr)>);
 
     for (const auto [i, v] : enum_sr) {
         ASSERT_EQ(i, v.ui - 1);
@@ -395,14 +433,10 @@ TEST(utils, ranges_pick_chained_sequence) {
     auto selected = detray::views::pick(seq, indices);
 
     // Check iterator category
-    bool is_correct_itr_tag = std::is_same_v<
-        typename decltype(indices)::iterator_t::iterator_category,
-        std::input_iterator_tag>;
-    ASSERT_TRUE(is_correct_itr_tag);
-    is_correct_itr_tag = std::is_same_v<
-        typename decltype(selected)::iterator_t::iterator_category,
-        std::input_iterator_tag>;
-    ASSERT_TRUE(is_correct_itr_tag);
+    static_assert(detray::ranges::input_range_v<decltype(indices)>);
+    static_assert(not detray::ranges::forward_range_v<decltype(indices)>);
+    static_assert(detray::ranges::input_range_v<decltype(selected)>);
+    static_assert(not detray::ranges::forward_range_v<decltype(selected)>);
 
     // Test inherited member functions
     const auto [i, v] = selected[2];