diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index d7c36d6b438fb..6098b3f43fdf9 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -676,6 +676,7 @@ set(files
   __ranges/access.h
   __ranges/all.h
   __ranges/as_rvalue_view.h
+  __ranges/cartesian_product_view.h
   __ranges/chunk_by_view.h
   __ranges/common_view.h
   __ranges/concepts.h
diff --git a/libcxx/include/__ranges/cartesian_product_view.h b/libcxx/include/__ranges/cartesian_product_view.h
new file mode 100644
index 0000000000000..4d95de846b3e9
--- /dev/null
+++ b/libcxx/include/__ranges/cartesian_product_view.h
@@ -0,0 +1,477 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_CARTESIAN_PRODUCT_VIEW_H
+#define _LIBCPP___RANGES_CARTESIAN_PRODUCT_VIEW_H
+
+#include <__config>
+#include <__iterator/access.h> // begin
+#include <__iterator/default_sentinel.h>
+#include <__iterator/distance.h>
+#include <__iterator/iter_move.h>
+#include <__iterator/next.h>
+#include <__memory/addressof.h>
+#include <__ranges/concepts.h> // forward_range, view, range_size_t, sized_range, ...
+#include <__ranges/zip_view.h> // tuple_transform
+#include <__type_traits/maybe_const.h>
+#include <tuple>       // apply
+#include <type_traits> // common_type_t
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <bool Const, class First, class... Vs>
+concept cartesian_product_is_random_access =
+    (random_access_range<__maybe_const<Const, First>> && ... &&
+     (random_access_range<__maybe_const<Const, Vs>> && sized_range<__maybe_const<Const, Vs>>));
+
+template <class R>
+concept cartesian_product_common_arg = common_range<R> || (sized_range<R> && random_access_range<R>);
+
+template <bool Const, class First, class... Vs>
+concept cartesian_product_is_bidirectional =
+    (bidirectional_range<__maybe_const<Const, First>> && ... &&
+     (bidirectional_range<__maybe_const<Const, Vs>> && cartesian_product_common_arg<__maybe_const<Const, Vs>>));
+
+template <class First, class... Vs>
+concept cartesian_product_is_common = cartesian_product_common_arg<First>;
+
+template <class... Vs>
+concept cartesian_product_is_sized = (sized_range<Vs> && ...);
+
+template <bool Const, template <class> class FirstSent, class First, class... Vs>
+concept cartesian_is_sized_sentinel =
+    (sized_sentinel_for<FirstSent<__maybe_const<Const, First>>, iterator_t<__maybe_const<Const, First>>> && ... &&
+     (sized_range<__maybe_const<Const, Vs>> &&
+      sized_sentinel_for<iterator_t<__maybe_const<Const, Vs>>, iterator_t<__maybe_const<Const, Vs>>>));
+
+template <cartesian_product_common_arg R>
+constexpr auto cartesian_common_arg_end(R& r) {
+  if constexpr (common_range<R>) {
+    return ranges::end(r);
+  } else {
+    return ranges::begin(r) + ranges::distance(r);
+  }
+}
+
+template <bool Const, class First, class... Vs>
+concept __cartesian_product_all_random_access =
+    (random_access_range<__maybe_const<Const, First>> && ... && random_access_range<__maybe_const<Const, Vs>>);
+
+template <input_range First, forward_range... Vs>
+  requires(view<First> && ... && view<Vs>)
+class cartesian_product_view : public view_interface<cartesian_product_view<First, Vs...>> {
+private:
+  tuple<First, Vs...> bases_;
+
+  template <bool Const>
+  class iterator;
+
+public:
+  constexpr cartesian_product_view() = default;
+  constexpr explicit cartesian_product_view(First first_base, Vs... bases)
+      : bases_{std::move(first_base), std::move(bases)...} {}
+
+  constexpr iterator<false> begin()
+    requires(!__simple_view<First> || ... || !__simple_view<Vs>)
+  {
+    return iterator<false>(*this, __tuple_transform(ranges::begin, bases_));
+  }
+
+  constexpr iterator<true> begin() const
+    requires(range<const First> && ... && range<const Vs>)
+  {
+    return iterator<true>(*this, __tuple_transform(ranges::begin, bases_));
+  }
+
+  constexpr iterator<false> end()
+    requires((!__simple_view<First> || ... || !__simple_view<Vs>) && cartesian_product_is_common<First, Vs...>)
+  {
+    constexpr bool is_const = false;
+    return end_impl<is_const>();
+  }
+
+  constexpr iterator<true> end() const
+    requires cartesian_product_is_common<const First, const Vs...>
+  {
+    constexpr bool is_const = true;
+    return end_impl<is_const>();
+  }
+
+  constexpr default_sentinel_t end() const noexcept { return {}; }
+
+  constexpr auto size()
+    requires cartesian_product_is_sized<First, Vs...>
+  {
+    return size_impl();
+  }
+
+  constexpr auto size() const
+    requires cartesian_product_is_sized<const First, const Vs...>
+  {
+    return size_impl();
+  }
+
+private:
+  template <bool is_const>
+  constexpr iterator<is_const> end_impl() const {
+    bool is_empty                  = end_is_empty();
+    const auto ranges_to_iterators = [is_empty, &b = bases_]<std::size_t... I>(std::index_sequence<I...>) {
+      const auto begin_or_first_end = [is_empty]<class is_first>(is_first, const auto& rng) {
+        if constexpr (is_first::value)
+          return is_empty ? ranges::begin(rng) : cartesian_common_arg_end(rng);
+        return ranges::begin(rng);
+      };
+
+      return std::make_tuple(begin_or_first_end(std::bool_constant<I == 0>{}, std::get<I>(b))...);
+    };
+    iterator<is_const> it(*this, ranges_to_iterators(std::make_index_sequence<1 + sizeof...(Vs)>{}));
+    return it;
+  }
+
+  template <std::size_t N = 1>
+  constexpr bool end_is_empty() const {
+    if constexpr (N == 1 + sizeof...(Vs))
+      return false;
+    else {
+      if (const auto& v = std::get<N>(bases_); ranges::empty(v))
+        return true;
+      return end_is_empty<N + 1>();
+    }
+  }
+
+  constexpr auto size_impl() const {
+    return std::apply(
+        [](auto&&... bases) {
+          using size_type = std::common_type_t<std::ranges::range_size_t<decltype(bases)>...>;
+          return (static_cast<size_type>(std::ranges::size(bases)) * ...);
+        },
+        bases_);
+  }
+};
+
+template <class... Vs>
+cartesian_product_view(Vs&&...) -> cartesian_product_view<views::all_t<Vs>...>;
+
+template <input_range First, forward_range... Vs>
+  requires(view<First> && ... && view<Vs>)
+template <bool Const>
+class cartesian_product_view<First, Vs...>::iterator {
+  static constexpr auto get_iterator_tag() {
+    if constexpr (cartesian_product_is_random_access<Const, First, Vs...>)
+      return random_access_iterator_tag{};
+    else if constexpr (cartesian_product_is_bidirectional<Const, First, Vs...>)
+      return bidirectional_iterator_tag{};
+    else if constexpr (forward_range<__maybe_const<Const, First>>)
+      return forward_iterator_tag{};
+    else
+      return input_iterator_tag{};
+  }
+
+  friend cartesian_product_view;
+
+public:
+  using iterator_category = input_iterator_tag;
+  using iterator_concept  = decltype(get_iterator_tag());
+  using value_type = tuple<range_value_t<__maybe_const<Const, First>>, range_value_t<__maybe_const<Const, Vs>>...>;
+  using reference =
+      tuple<range_reference_t<__maybe_const<Const, First>>, range_reference_t<__maybe_const<Const, Vs>>...>;
+  using difference_type = std::common_type_t<range_difference_t<First>, range_difference_t<Vs>...>;
+
+  iterator() = default;
+
+  constexpr iterator(iterator<!Const> i)
+    requires Const && (convertible_to<iterator_t<First>, iterator_t<const First>> && ... &&
+                       convertible_to<iterator_t<Vs>, iterator_t<const Vs>>)
+      : parent_(i.parent_), current_(std::move(i.current_)) {}
+
+  constexpr auto operator*() const {
+    return __tuple_transform([](auto& i) -> decltype(auto) { return *i; }, current_);
+  }
+
+  constexpr iterator& operator++() {
+    next();
+    return *this;
+  }
+
+  constexpr void operator++(int) { ++*this; }
+
+  constexpr iterator operator++(int)
+    requires forward_range<__maybe_const<Const, First>>
+  {
+    auto tmp = *this;
+    ++*this;
+    return tmp;
+  }
+
+  constexpr iterator& operator--()
+    requires cartesian_product_is_bidirectional<Const, First, Vs...>
+  {
+    prev();
+    return *this;
+  }
+
+  constexpr iterator operator--(int)
+    requires cartesian_product_is_bidirectional<Const, First, Vs...>
+  {
+    auto tmp = *this;
+    --*this;
+    return tmp;
+  }
+
+  constexpr iterator& operator+=(difference_type x)
+    requires cartesian_product_is_random_access<Const, First, Vs...>
+  {
+    advance(x);
+    return *this;
+  }
+
+  constexpr iterator& operator-=(difference_type x)
+    requires cartesian_product_is_random_access<Const, First, Vs...>
+  {
+    *this += -x;
+    return *this;
+  }
+
+  constexpr reference operator[](difference_type n) const
+    requires cartesian_product_is_random_access<Const, First, Vs...>
+  {
+    return *((*this) + n);
+  }
+
+  friend constexpr bool operator==(const iterator& x, const iterator& y)
+    requires equality_comparable<iterator_t<__maybe_const<Const, First>>>
+  {
+    return x.current_ == y.current_;
+  }
+
+  friend constexpr bool operator==(const iterator& x, default_sentinel_t) { return x.at_end(); }
+
+  friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+    requires __cartesian_product_all_random_access<Const, First, Vs...>
+  {
+    return x.current_ <=> y.current_;
+  }
+
+  friend constexpr iterator operator+(const iterator& x, difference_type y)
+    requires cartesian_product_is_random_access<Const, First, Vs...>
+  {
+    return iterator(x) += y;
+  }
+
+  friend constexpr iterator operator+(difference_type x, const iterator& y)
+    requires cartesian_product_is_random_access<Const, First, Vs...>
+  {
+    return y + x;
+  }
+
+  friend constexpr iterator operator-(const iterator& x, difference_type y)
+    requires cartesian_product_is_random_access<Const, First, Vs...>
+  {
+    return iterator(x) -= y;
+  }
+
+  friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+    requires cartesian_is_sized_sentinel<Const, iterator_t, First, Vs...>
+  {
+    return x.distance_from(y.current_);
+  }
+
+  friend constexpr difference_type operator-(const iterator& i, default_sentinel_t)
+    requires cartesian_is_sized_sentinel<Const, sentinel_t, First, Vs...>
+  {
+    tuple end_tuple = [&b = i.parent_->bases_]<size_t... I>(index_sequence<I...>) {
+      return tuple{ranges::end(std::get<0>(b)), ranges::begin(std::get<1 + I>(b))...};
+    }(std::make_index_sequence<sizeof...(Vs)>{});
+    return i.distance_from(end_tuple);
+  }
+
+  friend constexpr difference_type operator-(default_sentinel_t s, const iterator& i)
+    requires cartesian_is_sized_sentinel<Const, sentinel_t, First, Vs...>
+  {
+    return -(i - s);
+  }
+
+  friend constexpr auto iter_move(const iterator& i) noexcept(iter_move_noexcept_impl(i)) {
+    return __tuple_transform(ranges::iter_move, i.current_);
+  }
+
+  friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(iter_swap_noexcept_impl(l, r))
+    requires(indirectly_swappable<iterator_t<__maybe_const<Const, First>>> && ... &&
+             indirectly_swappable<iterator_t<__maybe_const<Const, Vs>>>)
+  {
+    iter_swap_impl(l, r);
+  }
+
+private:
+  using Parent        = __maybe_const<Const, cartesian_product_view>;
+  Parent* parent_     = nullptr;
+  using MultiIterator = tuple<iterator_t<__maybe_const<Const, First>>, iterator_t<__maybe_const<Const, Vs>>...>;
+  MultiIterator current_;
+
+  template <size_t N = sizeof...(Vs)>
+  constexpr void next() {
+    auto& it = std::get<N>(current_);
+    ++it;
+    if constexpr (N > 0) {
+      if (const auto& v = std::get<N>(parent_->bases_); it == ranges::end(v)) {
+        it = ranges::begin(v);
+        next<N - 1>();
+      }
+    }
+  }
+
+  template <size_t N = sizeof...(Vs)>
+  constexpr void prev() {
+    auto& it = std::get<N>(current_);
+    if constexpr (N > 0) {
+      if (const auto& v = std::get<N>(parent_->bases_); it == ranges::begin(v)) {
+        it = cartesian_common_arg_end(v);
+        prev<N - 1>();
+      }
+    }
+    --it;
+  }
+
+  template <auto N = sizeof...(Vs)>
+  constexpr void advance(difference_type x) {
+    if (x == 0)
+      return;
+
+    const auto& v    = std::get<N>(parent_->bases_);
+    auto& it         = std::get<N>(current_);
+    const auto sz    = static_cast<difference_type>(std::ranges::size(v));
+    const auto first = ranges::begin(v);
+
+    if (sz > 0) {
+      const auto idx = static_cast<difference_type>(std::distance(first, it));
+      x += idx;
+
+      difference_type mod;
+      if constexpr (N > 0) {
+        difference_type div = x / sz;
+        mod                 = x % sz;
+        if (mod < 0) {
+          mod += sz;
+          div--;
+        }
+        advance<N - 1>(div);
+      } else {
+        mod = (x >= 0 && x < sz) ? x : sz;
+      }
+      it = std::next(first, mod);
+
+    } else {
+      if constexpr (N > 0) {
+        advance<N - 1>(x);
+      }
+      it = first;
+    }
+  }
+
+  template <auto N = sizeof...(Vs)>
+  constexpr bool at_end() const {
+    if (std::get<N>(current_) == ranges::end(std::get<N>(parent_->bases_)))
+      return true;
+    if constexpr (N > 0)
+      return at_end<N - 1>();
+    return false;
+  }
+
+  template <class Tuple>
+  constexpr difference_type distance_from(const Tuple& t) const {
+    return scaled_sum(t);
+  }
+
+  template <auto N>
+  constexpr difference_type scaled_size() const {
+    if constexpr (N <= sizeof...(Vs))
+      return static_cast<difference_type>(ranges::size(std::get<N>(parent_->bases_))) * scaled_size<N + 1>();
+    return static_cast<difference_type>(1);
+  }
+
+  template <auto N>
+  constexpr difference_type scaled_distance(const auto& t) const {
+    return static_cast<difference_type>(std::get<N>(current_) - std::get<N>(t)) * scaled_size<N + 1>();
+  }
+
+  template <auto N = 0>
+  constexpr difference_type scaled_sum(const auto& t) const {
+    if constexpr (N <= sizeof...(Vs))
+      return scaled_distance<N>(t) + scaled_sum<N + 1>(t);
+    return static_cast<difference_type>(0);
+  }
+
+  constexpr iterator(Parent& parent, MultiIterator current)
+      : parent_(std::addressof(parent)), current_(std::move(current)) {}
+
+  template <auto N = sizeof...(Vs)>
+  static constexpr bool iter_move_noexcept_impl(const iterator& i) {
+    if (not noexcept(std::ranges::iter_move(std::get<N>(i.current_))))
+      return false;
+    if constexpr (N > 0)
+      return iter_move_noexcept_impl<N - 1>(i);
+
+    return std::is_nothrow_move_constructible_v<
+               std::ranges::range_rvalue_reference_t<__maybe_const<Const, First>>>() and
+           (std::is_nothrow_move_constructible_v<std::ranges::range_rvalue_reference_t<__maybe_const<Const, Vs>>>() and
+            ...);
+  }
+
+  template <auto i = sizeof...(Vs)>
+  static constexpr bool iter_swap_noexcept_impl(const iterator& l, const iterator& r) {
+    if (not noexcept(std::ranges::iter_swap(std::get<i>(l.current_), std::get<i>(r.current_))))
+      return false;
+    if constexpr (i > 0)
+      return iter_move_noexcept_impl<i - 1>(i);
+    return true;
+  }
+
+  template <auto N = sizeof...(Vs)>
+  static constexpr void iter_swap_impl(const iterator& l, const iterator& r) {
+    ranges::iter_swap(std::get<N>(l.current_), std::get<N>(r.current_));
+    if constexpr (N > 0)
+      iter_swap_impl<N - 1>(l, r);
+  }
+};
+
+namespace views {
+namespace __cartesian_product {
+struct __fn {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()() { return views::single(tuple()); }
+
+  template <class... _Ranges>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Ranges&&... __rs)
+      -> decltype(cartesian_product_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(__rs)...)) {
+    return cartesian_product_view<all_t<_Ranges>...>(std::forward<_Ranges>(__rs)...);
+  }
+};
+} // namespace __cartesian_product
+inline namespace __cpo {
+inline constexpr auto cartesian_product = __cartesian_product::__fn{};
+} // namespace __cpo
+} // namespace views
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_CARTESIAN_PRODUCT_VIEW_H
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index 43072aa0fb0f1..8c20a03faf901 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -1786,6 +1786,7 @@ module std [system] {
     module access                         { header "__ranges/access.h" }
     module all                            { header "__ranges/all.h" }
     module as_rvalue_view                 { header "__ranges/as_rvalue_view.h" }
+    module cartesian_product_view         { header "__ranges/cartesian_product_view.h" }
     module chunk_by_view {
       header "__ranges/chunk_by_view.h"
       export std.functional.bind_back
diff --git a/libcxx/include/ranges b/libcxx/include/ranges
index 9ef614d21f525..668287ffe02c8 100644
--- a/libcxx/include/ranges
+++ b/libcxx/include/ranges
@@ -425,6 +425,7 @@ namespace std {
 
 #  if _LIBCPP_STD_VER >= 23
 #    include <__ranges/as_rvalue_view.h>
+#    include <__ranges/cartesian_product_view.h>
 #    include <__ranges/chunk_by_view.h>
 #    include <__ranges/from_range.h>
 #    include <__ranges/repeat_view.h>
diff --git a/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/begin.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/begin.pass.cpp
new file mode 100644
index 0000000000000..fac0d39b9f723
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/begin.pass.cpp
@@ -0,0 +1,107 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr iterator<false> begin()       requires (!simple-view<First> || ... || !simple-view <Vs>);
+// constexpr iterator<true > begin() const requires (range<const First> && ... && range<const Vs>);
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+#include <tuple>
+#include <utility>
+
+#include "../range.zip/types.h"
+
+template <class T>
+concept HasConstBegin = requires(const T& ct) { ct.begin(); };
+
+template <class T>
+concept HasNonConstBegin = requires(T& t) { t.begin(); };
+
+template <class T>
+concept HasConstAndNonConstBegin = HasConstBegin<T> && HasNonConstBegin<T> && requires(T& t, const T& ct) {
+  requires !std::same_as<decltype(t.begin()), decltype(ct.begin())>;
+};
+
+template <class T>
+concept HasOnlyNonConstBegin = HasNonConstBegin<T> && !HasConstBegin<T>;
+
+template <class T>
+concept HasOnlyConstBegin = HasConstBegin<T> && !HasConstAndNonConstBegin<T>;
+
+struct NoConstBeginView : std::ranges::view_base {
+  int* begin();
+  int* end();
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  { // all underlying iterators should be at the begin position
+    std::ranges::cartesian_product_view v(
+        SizedRandomAccessView{buffer}, std::views::iota(0), std::ranges::single_view(2.0));
+    std::same_as<std::tuple<int&, int, double&>> decltype(auto) mutVal = *v.begin();
+    std::same_as<std::tuple<int&, int, const double&>> decltype(auto) constVal =
+        *std::as_const(v).begin();
+    assert(mutVal == std::make_tuple(1, 0, 2.0));
+    assert(constVal == std::make_tuple(1, 0, 2.0));
+    assert(&(std::get<0>(mutVal)) == &buffer[0]);
+    assert(&(std::get<0>(constVal)) == &buffer[0]);
+  }
+
+  { // with empty range
+    std::ranges::cartesian_product_view v(SizedRandomAccessView{buffer}, std::ranges::empty_view<int>());
+    assert(v.begin() == v.end());
+    assert(std::as_const(v).begin() == std::as_const(v).end());
+  }
+
+  { // underlying ranges all model simple-view
+    std::ranges::cartesian_product_view v(SimpleCommon{buffer}, SimpleCommon{buffer});
+    static_assert(std::is_same_v<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+    assert(v.begin() == std::as_const(v).begin());
+    auto [x, y] = *std::as_const(v).begin();
+    assert(&x == &buffer[0]);
+    assert(&y == &buffer[0]);
+
+    using View = decltype(v);
+    static_assert(std::ranges::__simple_view<SimpleCommon>);
+    static_assert(HasOnlyConstBegin<View>);
+    static_assert(!HasOnlyNonConstBegin<View>);
+    static_assert(!HasConstAndNonConstBegin<View>);
+  }
+
+  { // not all underlying ranges model simple-view
+    std::ranges::cartesian_product_view v(SimpleCommon{buffer}, NonSimpleNonCommon{buffer});
+    static_assert(!std::is_same_v<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+    assert(v.begin() == std::as_const(v).begin());
+    auto [x, y] = *std::as_const(v).begin();
+    assert(&x == &buffer[0]);
+    assert(&y == &buffer[0]);
+
+    using View = decltype(v);
+    static_assert(!HasOnlyConstBegin<View>);
+    static_assert(!HasOnlyNonConstBegin<View>);
+    static_assert(HasConstAndNonConstBegin<View>);
+  }
+
+  { // underlying const R is not a range
+    using View = std::ranges::cartesian_product_view<SimpleCommon, NoConstBeginView>;
+    static_assert(!HasOnlyConstBegin<View>);
+    static_assert(HasOnlyNonConstBegin<View>);
+    static_assert(!HasConstAndNonConstBegin<View>);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctad.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctad.compile.pass.cpp
new file mode 100644
index 0000000000000..d67e018828c27
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctad.compile.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template <class... Vs>
+// cartesian_product_view(Vs&&...) -> cartesian_product_view<views::all_t<Vs>...>;
+
+#include <cassert>
+#include <ranges>
+#include <utility>
+
+struct Container {
+  int* begin() const;
+  int* end() const;
+};
+
+struct View : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+void testCTAD() {
+  static_assert(std::is_same_v<decltype(std::ranges::cartesian_product_view(Container{})),
+                               std::ranges::cartesian_product_view<std::ranges::owning_view<Container>>>);
+
+  static_assert(std::is_same_v<decltype(std::ranges::cartesian_product_view(Container{}, View{})),
+                               std::ranges::cartesian_product_view<std::ranges::owning_view<Container>, View>>);
+
+  Container c{};
+  static_assert(
+      std::is_same_v<
+          decltype(std::ranges::cartesian_product_view(Container{}, View{}, c)),
+          std::ranges::
+              cartesian_product_view<std::ranges::owning_view<Container>, View, std::ranges::ref_view<Container>>>);
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctor.default.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctor.default.pass.cpp
new file mode 100644
index 0000000000000..8691ff2122e30
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctor.default.pass.cpp
@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// cartesian_product_view() = default;
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+
+constexpr int buff[] = {1, 2, 3};
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  constexpr DefaultConstructibleView() : begin_(buff), end_(buff + 3) {}
+  constexpr int const* begin() const { return begin_; }
+  constexpr int const* end() const { return end_; }
+
+private:
+  int const* begin_;
+  int const* end_;
+};
+
+struct NoDefaultCtrView : std::ranges::view_base {
+  NoDefaultCtrView() = delete;
+  int* begin() const;
+  int* end() const;
+};
+
+// The default constructor requires all underlying views to be default constructible.
+// It is implicitly required by the tuple's constructor. If any of the iterators are
+// not default constructible, cartesian product iterator's =default would be implicitly deleted.
+static_assert(std::is_default_constructible_v<std::ranges::cartesian_product_view<DefaultConstructibleView>>);
+static_assert(std::is_default_constructible_v<
+              std::ranges::cartesian_product_view<DefaultConstructibleView, DefaultConstructibleView>>);
+static_assert(
+    !std::is_default_constructible_v<std::ranges::cartesian_product_view<DefaultConstructibleView, NoDefaultCtrView>>);
+static_assert(
+    !std::is_default_constructible_v<std::ranges::cartesian_product_view<NoDefaultCtrView, NoDefaultCtrView>>);
+static_assert(!std::is_default_constructible_v<std::ranges::cartesian_product_view<NoDefaultCtrView>>);
+
+constexpr bool test() {
+  {
+    using View = std::ranges::cartesian_product_view<DefaultConstructibleView, DefaultConstructibleView>;
+    View v     = View(); // the default constructor is not explicit
+    assert(v.size() == 9);
+    auto it     = v.begin();
+    using Value = std::tuple<const int&, const int&>;
+    assert(*it++ == Value(1, 1));
+    assert(*it++ == Value(1, 2));
+    assert(*it++ == Value(1, 3));
+    assert(*it++ == Value(2, 1));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
\ No newline at end of file
diff --git a/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctor.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctor.pass.cpp
new file mode 100644
index 0000000000000..bf23c913ff9cc
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctor.pass.cpp
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// std::ranges::cartesian_product_view
+
+#include <cassert>
+#include <ranges>
+
+#include "test_iterators.h"
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  int i_;
+  int* begin();
+  int* end();
+};
+
+constexpr bool test() {
+  { // view | views::as_rvalue
+    // DefaultConstructibleView v{{}, 3};
+    [[maybe_unused]] std::ranges::cartesian_product_view<DefaultConstructibleView> r1;
+    [[maybe_unused]] std::ranges::cartesian_product_view<DefaultConstructibleView, DefaultConstructibleView> r2;
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctor.views.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctor.views.pass.cpp
new file mode 100644
index 0000000000000..0c424acaf3950
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/ctor.views.pass.cpp
@@ -0,0 +1,90 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr explicit cartesian_product_view(First first_base, Vs... bases);
+
+#include <ranges>
+#include <tuple>
+
+#include "../range.zip/types.h"
+
+template <class T>
+void conversion_test(T);
+
+template <class T, class... Args>
+concept implicitly_constructible_from = requires(Args&&... args) { conversion_test<T>({std::move(args)...}); };
+
+// test constructor is explicit
+static_assert(std::constructible_from<std::ranges::cartesian_product_view<SimpleCommon>, SimpleCommon>);
+static_assert(!implicitly_constructible_from<std::ranges::cartesian_product_view<SimpleCommon>, SimpleCommon>);
+
+static_assert(std::constructible_from<std::ranges::cartesian_product_view<SimpleCommon, SimpleCommon>, SimpleCommon, SimpleCommon>);
+static_assert(
+    !implicitly_constructible_from<std::ranges::cartesian_product_view<SimpleCommon, SimpleCommon>, SimpleCommon, SimpleCommon>);
+
+struct MoveAwareView : std::ranges::view_base {
+  int moves = 0;
+  constexpr MoveAwareView() = default;
+  constexpr MoveAwareView(MoveAwareView&& other) : moves(other.moves + 1) { other.moves = 1; }
+  constexpr MoveAwareView& operator=(MoveAwareView&& other) {
+    moves = other.moves + 1;
+    other.moves = 0;
+    return *this;
+  }
+  constexpr const int* begin() const { return &moves; }
+  constexpr const int* end() const { return &moves + 1; }
+};
+
+template <class View1, class View2>
+constexpr void constructorTest(auto&& buffer1, auto&& buffer2) {
+  std::ranges::cartesian_product_view v{View1{buffer1}, View2{buffer2}};
+  auto [i, j] = *v.begin();
+  assert(i == buffer1[0]);
+  assert(j == buffer2[0]);
+}
+
+constexpr bool test() {
+
+  int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8};
+  int buffer2[] = {9, 8, 7, 6};
+
+  { // constructor from views
+    std::ranges::cartesian_product_view v(SizedRandomAccessView{buffer}, std::views::iota(0), std::ranges::single_view(2.));
+    assert(*v.begin() == std::make_tuple(1, 0, 2.0));
+  }
+
+  { // arguments are moved once
+    MoveAwareView mv;
+    std::ranges::cartesian_product_view v{std::move(mv), MoveAwareView{}};
+    auto [numMoves1, numMoves2] = *v.begin();
+    assert(numMoves1 == 2); // one move from the local variable to parameter, one move from parameter to member
+    assert(numMoves2 == 1);
+  }
+
+  { // input and forward
+    constructorTest<InputCommonView, ForwardSizedView>(buffer, buffer2);
+  }
+
+  { // bidi and random_access
+    constructorTest<BidiCommonView, SizedRandomAccessView>(buffer, buffer2);
+  }
+
+  { // contiguous
+    constructorTest<ContiguousCommonView, ContiguousCommonView>(buffer, buffer2);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
\ No newline at end of file
diff --git a/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/end.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/end.pass.cpp
new file mode 100644
index 0000000000000..1d057d05bc810
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/end.pass.cpp
@@ -0,0 +1,138 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr iterator<false> end()       requires ((!simple-view <First> || ... || !simple-view <Vs>) && cartesian-product-is-common<      First,       Vs...>);
+// constexpr iterator<true > end() const requires                                                        cartesian-product-is-common<const First, const Vs...> ;
+
+#include "assert_macros.h"
+
+#include <array>
+#include <cassert>
+#include <ranges>
+
+constexpr bool test() {
+  { // non-empty range
+    constexpr size_t N = 7;
+    std::array<int, N> a;
+    std::ranges::cartesian_product_view c{a};
+    assert(c.end() == c.begin() + N);
+  }
+
+  { // (non-empty range)^2
+    constexpr size_t N0 = 7;
+    std::array<int, N0> a0;
+    constexpr size_t N1 = 42;
+    std::array<int, N1> a1;
+    std::ranges::cartesian_product_view c{a0, a1};
+    assert(c.end() == c.begin() + N0 * N1);
+  }
+
+  { // (non-empty range)^3 
+    constexpr size_t N0 = 5, N1 = 42, N2 = 7;
+    std::array<int, N0> a0;
+    std::array<int, N1> a1;
+    std::array<int, N2> a2;
+    std::ranges::cartesian_product_view c{a0, a1, a2};
+    assert(c.end() == c.begin() + N0*N1*N2);
+  }
+
+  { // empty range
+    std::ranges::empty_view<int> e;
+    std::ranges::cartesian_product_view c{e};
+    assert(c.end() == c.begin());
+  }
+
+  { // (empty range)^2
+    std::ranges::empty_view<int> e;
+    std::ranges::cartesian_product_view c{e, e};
+    assert(c.end() == c.begin());
+  }
+
+  { // empty range X common range
+    std::ranges::empty_view<int> e;
+    constexpr size_t N = 7;
+    std::array<int, N> a;
+    std::ranges::cartesian_product_view c{e, a};
+    assert(c.end() == c.begin());
+  }
+
+  { // common range X empty range
+    std::ranges::empty_view<int> e;
+    constexpr size_t N = 7;
+    std::array<int, N> a;
+    std::ranges::cartesian_product_view c{e, a};
+    assert(c.end() == c.begin());
+  }
+
+  { // (empty range)^3
+    std::ranges::empty_view<int> e;
+    std::ranges::cartesian_product_view c{e, e, e};
+    assert(c.end() == c.begin());
+  }
+
+  { // empty range X empty range X common range
+    std::ranges::empty_view<int> e;
+    constexpr size_t N = 7;
+    std::array<int, N> a;
+    std::ranges::cartesian_product_view c{e, e, a};
+    assert(c.end() == c.begin());
+  }
+
+  { // empty range X common range X empty range 
+    std::ranges::empty_view<int> e;
+    constexpr size_t N = 7;
+    std::array<int, N> a;
+    std::ranges::cartesian_product_view c{e, a, e};
+    assert(c.end() == c.begin());
+  }
+
+  { // common range X empty range X empty range 
+    std::ranges::empty_view<int> e;
+    constexpr size_t N = 7;
+    std::array<int, N> a;
+    std::ranges::cartesian_product_view c{a, e, e};
+    assert(c.end() == c.begin());
+  }
+
+  { // empty range X common range X common range 
+    std::ranges::empty_view<int> e;
+    constexpr size_t N0 = 7, N1 = 42;
+    std::array<int, N0> a0;
+    std::array<int, N1> a1;
+    std::ranges::cartesian_product_view c{e, a0, a1};
+    assert(c.end() == c.begin());
+  }
+
+  { // common range X empty range X common range 
+    std::ranges::empty_view<int> e;
+    constexpr size_t N0 = 7, N1 = 42;
+    std::array<int, N0> a0;
+    std::array<int, N1> a1;
+    std::ranges::cartesian_product_view c{a0, e, a1};
+    assert(c.end() == c.begin());
+  }
+
+  { // common range X common range X empty range 
+    std::ranges::empty_view<int> e;
+    constexpr size_t N0 = 7, N1 = 42;
+    std::array<int, N0> a0;
+    std::array<int, N1> a1;
+    std::ranges::cartesian_product_view c{a0, a1, e};
+    assert(c.end() == c.begin());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/example_from_std.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/example_from_std.pass.cpp
new file mode 100644
index 0000000000000..4d505921b3a77
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/example_from_std.pass.cpp
@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <ranges>
+#include <cassert>
+#include <vector>
+#include <string>
+
+constexpr bool test() {
+  struct ConstexprStringStream {
+    std::string str;
+
+    constexpr ConstexprStringStream& operator<<(int x) {
+      return *this << char(x + 48);
+    }
+    constexpr ConstexprStringStream& operator<<(char c) {
+      str += c;
+      return *this;
+    }
+  };
+
+  const std::vector<int> v{0, 1, 2};
+  ConstexprStringStream out;
+  for (auto&& [a, b, c] : std::ranges::views::cartesian_product(v, v, v)) {
+    out << a << ' ' << b << ' ' << c << '\n';
+  }
+
+  const std::string_view expected =
+      "0 0 0\n"
+      "0 0 1\n"
+      "0 0 2\n"
+      "0 1 0\n"
+      "0 1 1\n"
+      "0 1 2\n"
+      "0 2 0\n"
+      "0 2 1\n"
+      "0 2 2\n"
+      "1 0 0\n"
+      "1 0 1\n"
+      "1 0 2\n"
+      "1 1 0\n"
+      "1 1 1\n"
+      "1 1 2\n"
+      "1 2 0\n"
+      "1 2 1\n"
+      "1 2 2\n"
+      "2 0 0\n"
+      "2 0 1\n"
+      "2 0 2\n"
+      "2 1 0\n"
+      "2 1 1\n"
+      "2 1 2\n"
+      "2 2 0\n"
+      "2 2 1\n"
+      "2 2 2\n";
+  assert(out.str == expected);
+  
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
\ No newline at end of file
diff --git a/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/size.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/size.pass.cpp
new file mode 100644
index 0000000000000..c29990a205e6a
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/size.pass.cpp
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// std::ranges::cartesian_product_view::size
+
+#include <array>
+#include <cassert>
+#include <initializer_list>
+#include <ranges>
+
+constexpr bool test() {
+  { // example taken from: https://en.cppreference.com/w/cpp/ranges/cartesian_product_view/size
+    constexpr static auto w = {1};
+    constexpr static auto x = {2, 3};
+    constexpr static auto y = {4, 5, 6};
+    constexpr static auto z = {7, 8, 9, 10, 11, 12, 13};
+
+    constexpr auto ww = std::ranges::views::all(w);
+    constexpr auto xx = std::ranges::views::all(x);
+    constexpr auto yy = std::ranges::views::all(y);
+    constexpr auto zz = std::ranges::views::all(z);
+
+    constexpr auto v = std::ranges::cartesian_product_view(ww, xx, yy, zz);
+
+    assert(v.size() == 42);
+    assert(v.size() == w.size() * x.size() * y.size() * z.size());
+  }
+
+  { // empty range
+    std::ranges::empty_view<int> e;
+    auto v = std::ranges::cartesian_product_view(e);
+    assert(v.size() == 0);
+  }
+
+  { // 1..3 range(s)
+    constexpr size_t N0 = 3, N1 = 7, N2 = 42;
+    std::array<int, N0> a0;
+    std::array<int, N1> a1;
+    std::array<int, N2> a2;
+    assert(std::ranges::cartesian_product_view(a0).size() == N0);
+    assert(std::ranges::cartesian_product_view(a0, a1).size() == N0 * N1);
+    assert(std::ranges::cartesian_product_view(a0, a1, a2).size() == N0 * N1 * N2);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
\ No newline at end of file
diff --git a/libcxx/test/std/ranges/range.adaptors/range.zip/types.h b/libcxx/test/std/ranges/range.adaptors/range.zip/types.h
index e084dcfc41b0d..7cd7fa6e68c6d 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.zip/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.zip/types.h
@@ -17,7 +17,7 @@
 #include "test_range.h"
 
 #if TEST_STD_VER <= 20
-#  error "range.zip/types.h" can only be included in builds supporting C++20
+#  error "range.zip/types.h" can only be included in builds supporting C++23
 #endif // TEST_STD_VER <= 20
 
 template <class T>