diff --git a/include/experimental/__p2630_bits/strided_slice.hpp b/include/experimental/__p2630_bits/strided_slice.hpp
index 538b7a55..57ca5aba 100644
--- a/include/experimental/__p2630_bits/strided_slice.hpp
+++ b/include/experimental/__p2630_bits/strided_slice.hpp
@@ -51,4 +51,15 @@ struct extent_slice {
   static_assert(detail::mdspan_is_index_like_v<StrideType>);
 };
 
+template<class FirstType, class LastType, class StrideType = detail::constant_wrapper<size_t(1)>>
+struct range_slice {
+  MDSPAN_IMPL_NO_UNIQUE_ADDRESS FirstType first{};
+  MDSPAN_IMPL_NO_UNIQUE_ADDRESS LastType last{};
+  MDSPAN_IMPL_NO_UNIQUE_ADDRESS StrideType stride{};
+
+  static_assert(detail::mdspan_is_index_like_v<FirstType>);
+  static_assert(detail::mdspan_is_index_like_v<LastType>);
+  static_assert(detail::mdspan_is_index_like_v<StrideType>);
+};
+
 } // MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/include/experimental/__p2630_bits/submdspan_canonicalize_slices.hpp b/include/experimental/__p2630_bits/submdspan_canonicalize_slices.hpp
index fad36410..bae74f29 100644
--- a/include/experimental/__p2630_bits/submdspan_canonicalize_slices.hpp
+++ b/include/experimental/__p2630_bits/submdspan_canonicalize_slices.hpp
@@ -3,7 +3,8 @@
 
 #pragma once
 
-#include "submdspan_extents.hpp"
+#include "constant_wrapper.hpp"
+#include "strided_slice.hpp"
 #include <complex>
 
 namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
@@ -12,6 +13,19 @@ namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
 namespace detail {
 
+// Helper for identifying extent_slice and range_slice
+template <class T> struct is_extent_slice : std::false_type {};
+
+template <class OffsetType, class ExtentType, class StrideType>
+struct is_extent_slice<
+    extent_slice<OffsetType, ExtentType, StrideType>> : std::true_type {};
+
+template <class T> struct is_range_slice : std::false_type {};
+
+template<class FirstType, class LastType, class StrideType>
+struct is_range_slice<
+  range_slice<FirstType, LastType, StrideType>> : std::true_type {};
+
 // ============================================================
 // de_ice: extract the value of an integral-constant-like type
 // ============================================================
@@ -185,6 +199,36 @@ constexpr bool check_static_bounds()
     else {
       return true;
     }
+  } else if constexpr (is_range_slice<S_k>::value) {
+    using first_type = decltype(std::declval<S_k>().first);
+    using last_type = decltype(std::declval<S_k>().last);
+
+    if constexpr (is_integral_constant_like_v<first_type>) {
+      if constexpr (de_ice(first_type{}) < 0) {
+        return false;
+      }
+      else if constexpr (
+        Exts_k != dynamic_extent &&
+        Exts_k < static_cast<size_t>(de_ice(first_type{})))
+      {
+        return false;
+      }
+    }
+
+    if constexpr (is_integral_constant_like_v<last_type>) {
+      if constexpr ((is_integral_constant_like_v<first_type> && (de_ice(first_type()) > de_ice(last_type{})))
+                      || de_ice(last_type{}) < 0) {
+        return false;
+      }
+      else if constexpr (
+        Exts_k != dynamic_extent &&
+        Exts_k < static_cast<size_t>(de_ice(last_type{})))
+      {
+        return false;
+      }
+    }
+
+    return true;
   } else {
     // General pair-like case: attempt to get the first and second elements.
     // If S_k cannot be structured-bound into two elements, this is ill-formed,
@@ -270,6 +314,71 @@ constexpr bool check_submdspan_slice_mandates(
   return (check_submdspan_slice_mandate<typename Extents::index_type, Extents::static_extent(Idx), Slices>(slices) && ... && true);
 }
 
+
+template<class IndexType, class SpanType, class StrideType>
+struct calculate_extents
+{
+  static constexpr IndexType value(SpanType span, StrideType stride)
+  {
+    return static_cast<IndexType>(span != 0 ? 1 + divide<IndexType>(span - 1, stride) : 0);
+  }
+};
+
+template<class IndexType, auto Span, auto Stride>
+struct calculate_extents<IndexType, constant_wrapper<Span>, constant_wrapper<Stride>>
+{
+  static constexpr auto value(constant_wrapper<Span>, constant_wrapper<Stride>)
+  {
+    return cw<static_cast<IndexType>(Span != 0 ? 1 + divide<IndexType>(Span - 1, Stride) : 0)>;
+  }
+};
+
+
+template<class IndexType, class StrideType>
+struct calculate_stride
+{
+  template< class SpanType >
+  static constexpr auto value(SpanType span, StrideType stride)
+  {
+    return span != 0 ? stride : IndexType(1);
+  }
+};
+
+template<class IndexType, auto Stride>
+struct calculate_stride<IndexType, constant_wrapper<Stride>>
+{
+  template< class SpanType >
+  static constexpr auto value(SpanType, constant_wrapper<Stride>)
+  {
+    return cw<Stride>;
+  }
+};
+
+
+// Some compilers do not do ctad properly with canonical_range_slice
+template<class OffsetType, class ExtentType, class StrideType>
+constexpr extent_slice<OffsetType, ExtentType, StrideType>
+make_extent_slice(OffsetType offset, ExtentType extent, StrideType stride)
+{
+  return extent_slice<OffsetType, ExtentType, StrideType>{offset, extent, stride};
+}
+
+template<class IndexType, class OffsetType, class SpanType, class StrideType>
+constexpr auto canonical_range_slice(OffsetType offset, SpanType span, StrideType stride)
+{
+  return make_extent_slice(
+    offset,
+    calculate_extents<IndexType, SpanType, StrideType>::value(span, stride),
+    calculate_stride<IndexType, StrideType>::value(span, stride)
+  );
+}
+
+template<class IndexType, class OffsetType, class SpanType>
+constexpr auto canonical_range_slice(OffsetType offset, SpanType span)
+{
+  return canonical_range_slice<IndexType>(offset, span, cw<IndexType(1)>);
+}
+
 // ============================================================
 // canonical_slice: canonicalize a single slice
 //
@@ -301,6 +410,15 @@ constexpr auto canonical_slice([[maybe_unused]] Slice s)
       /* .extent = */ extent,
       /* .stride = */ stride
     };
+  }
+  else if constexpr (is_range_slice<Slice>::value) {
+    auto c_first = canonical_index<IndexType>(std::move(s.first));
+    auto c_last = canonical_index<IndexType>(std::move(s.last));
+    return canonical_range_slice<IndexType>(
+      c_first,
+      subtract_ice<IndexType>(c_first, c_last),
+      canonical_index<IndexType>(std::move(s.stride))
+    );
   } else {
     // General pair-like case: structured binding into [first, last)
     auto [s_k0, s_k1] = std::move(s);
diff --git a/include/experimental/__p2630_bits/submdspan_extents.hpp b/include/experimental/__p2630_bits/submdspan_extents.hpp
index 0f096427..99c306fd 100644
--- a/include/experimental/__p2630_bits/submdspan_extents.hpp
+++ b/include/experimental/__p2630_bits/submdspan_extents.hpp
@@ -8,6 +8,7 @@
 #include "constant_wrapper.hpp"
 #include "strided_slice.hpp"
 #include "../__p0009_bits/utility.hpp"
+#include "submdspan_canonicalize_slices.hpp"
 
 namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 namespace detail {
@@ -35,13 +36,6 @@ constexpr auto inv_map_rank(std::integral_constant<size_t, Counter>, std::index_
                                      slices...);
 }
 
-// Helper for identifying strided_slice
-template <class T> struct is_extent_slice : std::false_type {};
-
-template <class OffsetType, class ExtentType, class StrideType>
-struct is_extent_slice<
-    extent_slice<OffsetType, ExtentType, StrideType>> : std::true_type {};
-
 // first_of(slice): getting begin of slice specifier range
 MDSPAN_TEMPLATE_REQUIRES(
   class Integral,
@@ -275,6 +269,6 @@ constexpr auto submdspan_extents(const extents<IndexType, Extents...> &src_exts,
 
   using ext_t = extents<IndexType, Extents...>;
   return detail::extents_constructor<ext_t::rank(), ext_t>::next_extent(
-      src_exts, slices...);
+      src_exts, detail::canonical_slice<IndexType>(slices)...);
 }
 } // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/include/experimental/__p2630_bits/submdspan_mapping.hpp b/include/experimental/__p2630_bits/submdspan_mapping.hpp
index c0a7619e..5e9f7627 100644
--- a/include/experimental/__p2630_bits/submdspan_mapping.hpp
+++ b/include/experimental/__p2630_bits/submdspan_mapping.hpp
@@ -103,6 +103,15 @@ constexpr bool is_range_like_slice_v<
     IndexType
   > = (constant_wrapper<Stride>::value == IndexType(1));
 
+template<class FirstType, class LastType, auto Stride, class IndexType>
+constexpr bool is_range_like_slice_v<
+    range_slice<
+      FirstType,
+      LastType,
+      constant_wrapper<Stride>>,
+    IndexType
+  > = (constant_wrapper<Stride>::value == IndexType(1));
+
 template<class SliceSpecifier, class IndexType>
 struct is_index_slice {
   constexpr static bool value = std::is_convertible_v<SliceSpecifier, IndexType>;
diff --git a/tests/test_canonicalize_slices.cpp b/tests/test_canonicalize_slices.cpp
index 7b60b1e9..fc20e7ae 100644
--- a/tests/test_canonicalize_slices.cpp
+++ b/tests/test_canonicalize_slices.cpp
@@ -276,11 +276,11 @@ TEST(CanonicalizeSlices, Rank2_full) {
     MDSPAN_IMPL_STANDARD_NAMESPACE::extents<int, 11, 13>{}, full, full);
 }
 
-TEST(CanonicalizeSlices, Rank1_strided_slice_dynamic) {
+TEST(CanonicalizeSlices, Rank1_extent_slice_dynamic) {
   using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
   using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
 
-  // strided_slice with all dynamic values
+  // extent_slice with all dynamic values
   const auto slice0 = MDSPAN_IMPL_STANDARD_NAMESPACE::extent_slice<int, int, int>{
     /* .offset = */ 1,
     /* .extent = */ 4,
@@ -296,7 +296,27 @@ TEST(CanonicalizeSlices, Rank1_strided_slice_dynamic) {
   test_canonicalize_slices(expected_slices, exts, slice0);
 }
 
-TEST(CanonicalizeSlices, Rank1_strided_slice_static) {
+TEST(CanonicalizeSlices, Rank1_range_slice_dynamic) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+
+  // range_slice with all dynamic values
+  const auto slice0 = MDSPAN_IMPL_STANDARD_NAMESPACE::range_slice<int, int, int>{
+    /* .first = */ 1,
+    /* .last = */ 11,
+    /* .stride = */ 3
+  };
+
+  const auto expected_slices = tuple{
+    MDSPAN_IMPL_STANDARD_NAMESPACE::extent_slice<size_t, size_t, size_t>{
+      size_t(1), size_t(4), size_t(3)
+    }
+  };
+  const auto exts = MDSPAN_IMPL_STANDARD_NAMESPACE::extents<size_t, 11>{};
+  test_canonicalize_slices(expected_slices, exts, slice0);
+}
+
+TEST(CanonicalizeSlices, Rank1_extent_slice_static) {
   using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
   using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
 
@@ -317,4 +337,25 @@ TEST(CanonicalizeSlices, Rank1_strided_slice_static) {
   test_canonicalize_slices(expected_slices, exts, slice0);
 }
 
+TEST(CanonicalizeSlices, Rank1_range_slice_static) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+
+  using offset_t = std::integral_constant<int, 1>;
+  using extent_t = std::integral_constant<int, 11>;
+  using stride_t = std::integral_constant<int, 3>;
+  const auto slice0 =
+    MDSPAN_IMPL_STANDARD_NAMESPACE::range_slice<offset_t, extent_t, stride_t>{};
+
+  const auto expected_slices = tuple{
+    MDSPAN_IMPL_STANDARD_NAMESPACE::extent_slice<
+      decltype(cw<size_t(1)>),
+      decltype(cw<size_t(4)>),
+      decltype(cw<size_t(3)>)
+    >{cw<size_t(1)>, cw<size_t(4)>, cw<size_t(3)>}
+  };
+  const auto exts = MDSPAN_IMPL_STANDARD_NAMESPACE::extents<size_t, 11>{};
+  test_canonicalize_slices(expected_slices, exts, slice0);
+}
+
 } // namespace (anonymous)
diff --git a/tests/test_strided_slice.cpp b/tests/test_strided_slice.cpp
index a9bd23a4..1da13804 100644
--- a/tests/test_strided_slice.cpp
+++ b/tests/test_strided_slice.cpp
@@ -9,7 +9,7 @@
 namespace {
 
 template<class OffsetType, class ExtentType, class StrideType>
-void test_strided_slice(OffsetType offset, ExtentType extent, StrideType stride)
+void test_extent_slice(OffsetType offset, ExtentType extent, StrideType stride)
 {
   // Some compilers are bad at CTAD for aggregates.
   Kokkos::extent_slice<OffsetType, ExtentType, StrideType> s{offset, extent, stride};
@@ -60,23 +60,60 @@ static_assert(
     my_integral_constant<int, 1>
   >);
 
-TEST(StridedSlice, WellFormed) {
-  test_strided_slice(int(1), unsigned(10), long(3));
-  test_strided_slice((signed char)(1), (unsigned short)(10), (unsigned long long)(3));
+TEST(ExtentSlice, WellFormed) {
+  test_extent_slice(int(1), unsigned(10), long(3));
+  test_extent_slice((signed char)(1), (unsigned short)(10), (unsigned long long)(3));
 
-  test_strided_slice(IC<int, 1>, unsigned(10), long(3));
-  test_strided_slice(int(1), IC<unsigned, 10>, long(3));
-  test_strided_slice(int(1), unsigned(10), IC<long, 3>);
+  test_extent_slice(IC<int, 1>, unsigned(10), long(3));
+  test_extent_slice(int(1), IC<unsigned, 10>, long(3));
+  test_extent_slice(int(1), unsigned(10), IC<long, 3>);
 
   using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
 
-  test_strided_slice(cw<1>, unsigned(10), long(3));
-  test_strided_slice(int(1), cw<unsigned(10)>, long(3));
-  test_strided_slice(int(1), unsigned(10), cw<long(3)>);
+  test_extent_slice(cw<1>, unsigned(10), long(3));
+  test_extent_slice(int(1), cw<unsigned(10)>, long(3));
+  test_extent_slice(int(1), unsigned(10), cw<long(3)>);
 
-  test_strided_slice(IC2<int, 1>, unsigned(10), long(3));
-  test_strided_slice(int(1), IC2<unsigned, 10>, long(3));
-  test_strided_slice(int(1), unsigned(10), IC2<long, 3>);
+  test_extent_slice(IC2<int, 1>, unsigned(10), long(3));
+  test_extent_slice(int(1), IC2<unsigned, 10>, long(3));
+  test_extent_slice(int(1), unsigned(10), IC2<long, 3>);
+}
+
+template<class FirstType, class LastType, class StrideType>
+void test_range_slice(FirstType first, LastType last, StrideType stride)
+{
+  // Some compilers are bad at CTAD for aggregates.
+  Kokkos::range_slice<FirstType, LastType, StrideType> s{first, last, stride};
+
+  auto first2 = s.first;
+  static_assert(std::is_same_v<FirstType, decltype(first2)>);
+  auto last2 = s.last;
+  static_assert(std::is_same_v<LastType, decltype(last2)>);
+  auto stride2 = s.stride;
+  static_assert(std::is_same_v<StrideType, decltype(stride2)>);
+
+  ASSERT_EQ(first2, first);
+  ASSERT_EQ(last2, last);
+  ASSERT_EQ(stride2, stride);
+}
+
+TEST(RangeSlice, WellFormed) {
+  test_range_slice(int(1), unsigned(10), long(3));
+  test_range_slice((signed char)(1), (unsigned short)(10), (unsigned long long)(3));
+
+  test_range_slice(IC<int, 1>, unsigned(10), long(3));
+  test_range_slice(int(1), IC<unsigned, 10>, long(3));
+  test_range_slice(int(1), unsigned(10), IC<long, 3>);
+
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
+
+  test_range_slice(cw<1>, unsigned(10), long(3));
+  test_range_slice(int(1), cw<unsigned(10)>, long(3));
+  test_range_slice(int(1), unsigned(10), cw<long(3)>);
+
+  test_range_slice(IC2<int, 1>, unsigned(10), long(3));
+  test_range_slice(int(1), IC2<unsigned, 10>, long(3));
+  test_range_slice(int(1), unsigned(10), IC2<long, 3>);
 }
 
 } // namespace (anonymous)
diff --git a/tests/test_submdspan.cpp b/tests/test_submdspan.cpp
index ffa86737..9ca5eb08 100644
--- a/tests/test_submdspan.cpp
+++ b/tests/test_submdspan.cpp
@@ -154,6 +154,11 @@ using submdspan_test_types =
     , std::tuple<Kokkos::layout_left, Kokkos::layout_stride,  Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, std::pair<int,int>, Kokkos::extent_slice<int,int,int>>
     , std::tuple<Kokkos::layout_left, Kokkos::layout_stride,  Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, Kokkos::extent_slice<int,int,int>, std::pair<int,int>>
     , std::tuple<Kokkos::layout_left, Kokkos::layout_stride,  Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, Kokkos::extent_slice<int,int,int>, Kokkos::extent_slice<int,int,int>>
+    , std::tuple<Kokkos::layout_left, Kokkos::layout_stride,  Kokkos::dextents<size_t,1>,          args_t<10>,          Kokkos::dextents<size_t,1>, Kokkos::range_slice<int,int,int>>
+    , std::tuple<Kokkos::layout_left, Kokkos::layout_stride,  Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,1>, Kokkos::range_slice<int,int,int>, int>
+    , std::tuple<Kokkos::layout_left, Kokkos::layout_stride,  Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, std::pair<int,int>, Kokkos::range_slice<int,int,int>>
+    , std::tuple<Kokkos::layout_left, Kokkos::layout_stride,  Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, Kokkos::range_slice<int,int,int>, std::pair<int,int>>
+    , std::tuple<Kokkos::layout_left, Kokkos::layout_stride,  Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, Kokkos::range_slice<int,int,int>, Kokkos::range_slice<int,int,int>>
     , std::tuple<Kokkos::layout_left, Kokkos::layout_stride,  Kokkos::extents<size_t,6,4,5,6,7,8>, args_t<6,4,5,6,7,8>, Kokkos::extents<size_t,6,dyn,8>, Kokkos::full_extent_t, int, std::pair<int,int>, int, int, Kokkos::full_extent_t>
     , std::tuple<Kokkos::layout_left, Kokkos::layout_stride,  Kokkos::extents<size_t,6,4,5,6,7,8>, args_t<6,4,5,6,7,8>, Kokkos::extents<size_t,4,dyn,7>, int, Kokkos::full_extent_t, std::pair<int,int>, int, Kokkos::full_extent_t, int>
     // layout_right to layout_right_padded
@@ -169,6 +174,12 @@ using submdspan_test_types =
     , std::tuple<Kokkos::layout_right, Kokkos::layout_stride, Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, std::pair<int,int>, Kokkos::extent_slice<int,int,int>>
     , std::tuple<Kokkos::layout_right, Kokkos::layout_stride, Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, Kokkos::extent_slice<int,int,int>, std::pair<int,int>>
     , std::tuple<Kokkos::layout_right, Kokkos::layout_stride, Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, Kokkos::extent_slice<int,int,int>, Kokkos::extent_slice<int,int,int>>
+    , std::tuple<Kokkos::layout_right, Kokkos::layout_stride, Kokkos::dextents<size_t,1>,          args_t<10>,          Kokkos::dextents<size_t,1>, Kokkos::range_slice<int,int,int>>
+    , std::tuple<Kokkos::layout_right, Kokkos::layout_stride, Kokkos::dextents<size_t,1>,          args_t<10>,          Kokkos::extents<size_t,0>,  Kokkos::range_slice<std::integral_constant<int,1>,std::integral_constant<int,1>,std::integral_constant<int,0>>>
+    , std::tuple<Kokkos::layout_right, Kokkos::layout_stride, Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,1>, Kokkos::range_slice<int,int,int>, int>
+    , std::tuple<Kokkos::layout_right, Kokkos::layout_stride, Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, std::pair<int,int>, Kokkos::range_slice<int,int,int>>
+    , std::tuple<Kokkos::layout_right, Kokkos::layout_stride, Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, Kokkos::range_slice<int,int,int>, std::pair<int,int>>
+    , std::tuple<Kokkos::layout_right, Kokkos::layout_stride, Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,2>, Kokkos::range_slice<int,int,int>, Kokkos::range_slice<int,int,int>>
     , std::tuple<Kokkos::layout_right, Kokkos::layout_stride, Kokkos::extents<size_t,6,4,5,6,7,8>, args_t<6,4,5,6,7,8>, Kokkos::extents<size_t,6,dyn,8>, Kokkos::full_extent_t, int, std::pair<int,int>, int, int, Kokkos::full_extent_t>
     , std::tuple<Kokkos::layout_right, Kokkos::layout_stride, Kokkos::extents<size_t,6,4,5,6,7,8>, args_t<6,4,5,6,7,8>, Kokkos::extents<size_t,4,dyn,7>, int, Kokkos::full_extent_t, std::pair<int,int>, int, Kokkos::full_extent_t, int>
     // layout_left_padded to layout_left
@@ -198,6 +209,12 @@ using submdspan_test_types =
     , std::tuple<layout_left_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,2>, args_t<10,20>, Kokkos::dextents<size_t,2>, Kokkos::full_extent_t, Kokkos::extent_slice<int,int,int>>
     , std::tuple<layout_left_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,3>, args_t<10,20,30>, Kokkos::dextents<size_t,3>, Kokkos::full_extent_t, Kokkos::extent_slice<int,int,int>, Kokkos::full_extent_t>
     , std::tuple<layout_left_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,3>, args_t<10,20,30>, Kokkos::dextents<size_t,2>, Kokkos::full_extent_t, int, Kokkos::extent_slice<int,int,int>>
+    , std::tuple<layout_left_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,1>, args_t<10>, Kokkos::dextents<size_t,1>, Kokkos::range_slice<int,int,int>>
+    , std::tuple<layout_left_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,2>, args_t<10,20>, Kokkos::dextents<size_t,1>, Kokkos::range_slice<int,int,int>, int>
+    , std::tuple<layout_left_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,2>, args_t<10,20>, Kokkos::dextents<size_t,2>, Kokkos::range_slice<int,int,int>, Kokkos::full_extent_t>
+    , std::tuple<layout_left_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,2>, args_t<10,20>, Kokkos::dextents<size_t,2>, Kokkos::full_extent_t, Kokkos::range_slice<int,int,int>>
+    , std::tuple<layout_left_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,3>, args_t<10,20,30>, Kokkos::dextents<size_t,3>, Kokkos::full_extent_t, Kokkos::range_slice<int,int,int>, Kokkos::full_extent_t>
+    , std::tuple<layout_left_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,3>, args_t<10,20,30>, Kokkos::dextents<size_t,2>, Kokkos::full_extent_t, int, Kokkos::range_slice<int,int,int>>
     , std::tuple<layout_left_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,4>, args_t<10,20,30,40>, Kokkos::dextents<size_t,3>, Kokkos::full_extent_t, Kokkos::full_extent_t, int, Kokkos::full_extent_t>
     // layout_right_padded to layout_right
     , std::tuple<layout_right_padded<dyn>, Kokkos::layout_right, Kokkos::dextents<size_t,2>, args_t<10,20>, Kokkos::dextents<size_t,0>, int, int>
@@ -226,6 +243,12 @@ using submdspan_test_types =
     , std::tuple<layout_right_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,2>, args_t<10,20>, Kokkos::dextents<size_t,2>, Kokkos::full_extent_t, Kokkos::extent_slice<int,int,int>>
     , std::tuple<layout_right_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,3>, args_t<10,20,30>, Kokkos::dextents<size_t,3>, Kokkos::full_extent_t, Kokkos::extent_slice<int,int,int>, Kokkos::full_extent_t>
     , std::tuple<layout_right_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,3>, args_t<10,20,30>, Kokkos::dextents<size_t,2>, Kokkos::extent_slice<int,int,int>, int, Kokkos::full_extent_t>
+    , std::tuple<layout_right_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,1>, args_t<10>, Kokkos::dextents<size_t,1>, Kokkos::range_slice<int,int,int>>
+    , std::tuple<layout_right_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,2>, args_t<10,20>, Kokkos::dextents<size_t,1>, int, Kokkos::range_slice<int,int,int>>
+    , std::tuple<layout_right_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,2>, args_t<10,20>, Kokkos::dextents<size_t,2>, Kokkos::range_slice<int,int,int>, Kokkos::full_extent_t>
+    , std::tuple<layout_right_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,2>, args_t<10,20>, Kokkos::dextents<size_t,2>, Kokkos::full_extent_t, Kokkos::range_slice<int,int,int>>
+    , std::tuple<layout_right_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,3>, args_t<10,20,30>, Kokkos::dextents<size_t,3>, Kokkos::full_extent_t, Kokkos::range_slice<int,int,int>, Kokkos::full_extent_t>
+    , std::tuple<layout_right_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,3>, args_t<10,20,30>, Kokkos::dextents<size_t,2>, Kokkos::range_slice<int,int,int>, int, Kokkos::full_extent_t>
     , std::tuple<layout_right_padded<dyn>, Kokkos::layout_stride, Kokkos::dextents<size_t,4>, args_t<10,20,30,40>, Kokkos::dextents<size_t,3>, Kokkos::full_extent_t, int, Kokkos::full_extent_t, Kokkos::full_extent_t>
     // Testing of customization point design
     , std::tuple<Foo::layout_foo, Foo::layout_foo, Kokkos::dextents<size_t,1>, args_t<10>,          Kokkos::dextents<size_t,1>, Kokkos::full_extent_t>
@@ -236,6 +259,8 @@ using submdspan_test_types =
     , std::tuple<Foo::layout_foo, Foo::layout_foo, Kokkos::dextents<size_t,2>, args_t<10,20>,       Kokkos::dextents<size_t,1>, int, Kokkos::full_extent_t>
     , std::tuple<Foo::layout_foo, Kokkos::layout_stride, Kokkos::dextents<size_t,1>,          args_t<10>,          Kokkos::dextents<size_t,1>, Kokkos::extent_slice<int,int,int>>
     , std::tuple<Foo::layout_foo, Kokkos::layout_stride, Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,1>, Kokkos::extent_slice<int,int,int>, int>
+    , std::tuple<Foo::layout_foo, Kokkos::layout_stride, Kokkos::dextents<size_t,1>,          args_t<10>,          Kokkos::dextents<size_t,1>, Kokkos::range_slice<int,int,int>>
+    , std::tuple<Foo::layout_foo, Kokkos::layout_stride, Kokkos::dextents<size_t,2>,          args_t<10,20>,       Kokkos::dextents<size_t,1>, Kokkos::range_slice<int,int,int>, int>
     >;
 
 template<class T> struct TestSubMDSpan;
@@ -279,6 +304,15 @@ struct TestSubMDSpan<
     return Kokkos::extent_slice<int,std::integral_constant<int, Ext>, std::integral_constant<int, Stride>>{1,std::integral_constant<int, Ext>(), std::integral_constant<int, Ext>()};
   }
   MDSPAN_INLINE_FUNCTION
+  static auto create_slice_arg(Kokkos::range_slice<int,int,int>) {
+    return Kokkos::range_slice<int,int,int>{1,8,2};
+  }
+  template<int First, int Second, int Stride>
+  MDSPAN_INLINE_FUNCTION
+  static auto create_slice_arg(Kokkos::range_slice<std::integral_constant<int, First>,std::integral_constant<int, Second>, std::integral_constant<int, Stride>>) {
+    return Kokkos::range_slice<std::integral_constant<int, First>, std::integral_constant<int, Second>, std::integral_constant<int, Stride>>{std::integral_constant<int, First>(),std::integral_constant<int, Second>(), std::integral_constant<int, Stride>()};
+  }
+  MDSPAN_INLINE_FUNCTION
   static auto create_slice_arg(Kokkos::full_extent_t) {
     return Kokkos::full_extent;
   }
@@ -315,6 +349,19 @@ struct TestSubMDSpan<
   }
   template<class SrcMDSpan, class SubMDSpan, size_t ... SrcIdx, size_t ... SubIdx, class ... SliceArgs>
   MDSPAN_INLINE_FUNCTION
+  static bool check_submdspan_match(int src_idx, int sub_idx, SrcMDSpan src_mds, SubMDSpan sub_mds, std::index_sequence<SrcIdx...>, std::index_sequence<SubIdx...>,
+                                     Kokkos::range_slice<int,int,int> p, SliceArgs ... slices) {
+    using idx_t = typename SubMDSpan::index_type;
+    return (sub_mds.extent(sub_idx)==static_cast<idx_t>(1 + (p.last - p.first - 1) / p.stride)) && check_submdspan_match(++src_idx, ++sub_idx, src_mds, sub_mds, std::index_sequence<SrcIdx...,3>(), std::index_sequence<SubIdx...,1>(), slices...);
+  }
+  template<class SrcMDSpan, class SubMDSpan, size_t ... SrcIdx, size_t ... SubIdx, int FirstLast, class ... SliceArgs>
+  MDSPAN_INLINE_FUNCTION
+  static bool check_submdspan_match(int src_idx, int sub_idx, SrcMDSpan src_mds, SubMDSpan sub_mds, std::index_sequence<SrcIdx...>, std::index_sequence<SubIdx...>,
+                                     Kokkos::range_slice<std::integral_constant<int, FirstLast>,std::integral_constant<int, FirstLast>,std::integral_constant<int,0>>, SliceArgs ... slices) {
+    return (sub_mds.extent(sub_idx)==0) && check_submdspan_match(++src_idx, ++sub_idx, src_mds, sub_mds, std::index_sequence<SrcIdx...,1>(), std::index_sequence<SubIdx...,0>(), slices...);
+  }
+  template<class SrcMDSpan, class SubMDSpan, size_t ... SrcIdx, size_t ... SubIdx, class ... SliceArgs>
+  MDSPAN_INLINE_FUNCTION
   static bool check_submdspan_match(int src_idx, int sub_idx, SrcMDSpan src_mds, SubMDSpan sub_mds, std::index_sequence<SrcIdx...>, std::index_sequence<SubIdx...>, Kokkos::full_extent_t, SliceArgs ... slices) {
     return (sub_mds.extent(sub_idx)==src_mds.extent(src_idx)) && check_submdspan_match(++src_idx, ++sub_idx, src_mds, sub_mds, std::index_sequence<SrcIdx...,1>(), std::index_sequence<SubIdx...,1>(), slices...);
   }