diff --git a/libcxx/docs/Status/RangesAlgorithms.csv b/libcxx/docs/Status/RangesAlgorithms.csv
--- a/libcxx/docs/Status/RangesAlgorithms.csv
+++ b/libcxx/docs/Status/RangesAlgorithms.csv
@@ -60,11 +60,11 @@
 Write,unique_copy,Not assigned,n/a,Not started
 Write,partition_copy,Not assigned,n/a,Not started
 Write,partial_sort_copy,Not assigned,n/a,Not started
-Merge,merge,Not assigned,n/a,Not started
-Merge,set_difference,Not assigned,n/a,Not started
-Merge,set_intersection,Not assigned,n/a,Not started
-Merge,set_symmetric_difference,Not assigned,n/a,Not started
-Merge,set_union,Not assigned,n/a,Not started
+Merge,merge,Hui Xie,n/a,Under review
+Merge,set_difference,Hui Xie,n/a,Not started
+Merge,set_intersection,Hui Xie,n/a,Not started
+Merge,set_symmetric_difference,Hui Xie,n/a,Not started
+Merge,set_union,Not assigned,Hui Xie,Not started
 Permutation,remove,Not assigned,n/a,Not started
 Permutation,remove_if,Not assigned,n/a,Not started
 Permutation,reverse,Nikolas Klauser,`D125752 <https://llvm.org/D125752>`_,✅
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -94,6 +94,7 @@
   __algorithm/ranges_lower_bound.h
   __algorithm/ranges_max.h
   __algorithm/ranges_max_element.h
+  __algorithm/ranges_merge.h
   __algorithm/ranges_min.h
   __algorithm/ranges_min_element.h
   __algorithm/ranges_minmax.h
diff --git a/libcxx/include/__algorithm/ranges_merge.h b/libcxx/include/__algorithm/ranges_merge.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__algorithm/ranges_merge.h
@@ -0,0 +1,120 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___ALGORITHM_RANGES_MERGE_H
+#define _LIBCPP___ALGORITHM_RANGES_MERGE_H
+
+#include "__algorithm/in_in_out_result.h"
+#include "__algorithm/ranges_copy.h"
+#include "__iterator/concepts.h"
+#include "__iterator/mergeable.h"
+#include "__functional/identity.h"
+#include "__functional/invoke.h"
+#include "__functional/ranges_operations.h"
+#include "__utility/move.h"
+#include "__ranges/access.h"
+#include "__ranges/concepts.h"
+#include "__ranges/dangling.h"
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _InIt1, class _InIt2, class _OutIt>
+using merge_result = in_in_out_result<_InIt1, _InIt2, _OutIt>;
+
+namespace __merge {
+
+  struct __fn {
+    template <
+        std::input_iterator _InIt1,
+        std::sentinel_for<_InIt1> _Sent1,
+        std::input_iterator _InIt2,
+        std::sentinel_for<_InIt2> _Sent2,
+        std::weakly_incrementable _OutIt,
+        class _Comp  = ranges::less,
+        class _Proj1 = std::identity,
+        class _Proj2 = std::identity >
+      requires std::mergeable<_InIt1, _InIt2, _OutIt, _Comp, _Proj1, _Proj2>
+    constexpr ranges::merge_result<_InIt1, _InIt2, _OutIt> operator()(
+        _InIt1 __first1,
+        _Sent1 __last1,
+        _InIt2 __first2,
+        _Sent2 __last2,
+        _OutIt __result,
+        _Comp __comp   = {},
+        _Proj1 __proj1 = {},
+        _Proj2 __proj2 = {}) const {
+      for (; !(__first1 == __last1 || __first2 == __last2); ++__result) {
+        if (std::invoke(__comp, std::invoke(__proj2, *__first2), std::invoke(__proj1, *__first1))) {
+          *__result = *__first2;
+          ++__first2;
+        } else {
+          *__result = *__first1;
+          ++__first1;
+        }
+      }
+      auto __ret1 = ranges::copy(std::move(__first1), std::move(__last1), std::move(__result));
+      auto __ret2 = ranges::copy(std::move(__first2), std::move(__last2), std::move(__ret1.out));
+      return {std::move(__ret1.in), std::move(__ret2.in), std::move(__ret2.out)};
+    }
+
+    template <
+        ranges::input_range _Range1,
+        ranges::input_range _Range2,
+        std::weakly_incrementable _OutIt,
+        class _Comp  = ranges::less,
+        class _Proj1 = std::identity,
+        class _Proj2 = std::identity >
+      requires std::mergeable<
+          ranges::iterator_t<_Range1>,
+          ranges::iterator_t<_Range2>,
+          _OutIt,
+          _Comp,
+          _Proj1,
+          _Proj2> constexpr ranges::
+          merge_result<ranges::borrowed_iterator_t<_Range1>, ranges::borrowed_iterator_t<_Range2>, _OutIt>
+          operator()(
+              _Range1&& __range1,
+              _Range2&& __range2,
+              _OutIt __result,
+              _Comp __comp   = {},
+              _Proj1 __proj1 = {},
+              _Proj2 __proj2 = {}) const {
+      return (*this)(
+          ranges::begin(__range1),
+          ranges::end(__range1),
+          ranges::begin(__range2),
+          ranges::end(__range2),
+          std::move(__result),
+          std::move(__comp),
+          std::move(__proj1),
+          std::move(__proj2));
+    }
+  };
+
+} // namespace __merge
+
+inline namespace __cpo {
+  inline constexpr auto merge = __merge::__fn{};
+} // namespace __cpo
+
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_MERGE_H
diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm
--- a/libcxx/include/algorithm
+++ b/libcxx/include/algorithm
@@ -470,6 +470,23 @@
     constexpr ranges::move_result<borrowed_iterator_t<R>, O>
       ranges::move(R&& r, O result);                                                                // since C++20
 
+  template<class I1, class I2, class O>
+    using merge_result = in_in_out_result<I1, I2, O>;                                               // since C++20
+
+  template<input_­iterator I1, sentinel_­for<I1> S1, input_­iterator I2, sentinel_­for<I2> S2,
+           weakly_­incrementable O, class Comp = ranges::less, class Proj1 = identity,
+           class Proj2 = identity>
+    requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+    constexpr merge_result<I1, I2, O>
+      merge(I1 first1, S1 last1, I2 first2, S2 last2, O result,
+            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                                    // since C++20
+
+  template<input_­range R1, input_­range R2, weakly_­incrementable O, class Comp = ranges::less,
+           class Proj1 = identity, class Proj2 = identity>
+    requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+    constexpr merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
+      merge(R1&& r1, R2&& r2, O result,
+            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                                    // since C++20
 
 }
 
@@ -1216,6 +1233,7 @@
 #include <__algorithm/ranges_minmax.h>
 #include <__algorithm/ranges_minmax_element.h>
 #include <__algorithm/ranges_mismatch.h>
+#include <__algorithm/ranges_merge.h>
 #include <__algorithm/ranges_move.h>
 #include <__algorithm/ranges_move_backward.h>
 #include <__algorithm/ranges_none_of.h>
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -338,6 +338,7 @@
       module ranges_minmax                   { private header "__algorithm/ranges_minmax.h" }
       module ranges_minmax_element           { private header "__algorithm/ranges_minmax_element.h" }
       module ranges_mismatch                 { private header "__algorithm/ranges_mismatch.h" }
+      module ranges_merge                    { private header "__algorithm/ranges_merge.h" }
       module ranges_move                     { private header "__algorithm/ranges_move.h" }
       module ranges_move_backward            { private header "__algorithm/ranges_move_backward.h" }
       module ranges_none_of                  { private header "__algorithm/ranges_none_of.h" }
diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp
--- a/libcxx/test/libcxx/private_headers.verify.cpp
+++ b/libcxx/test/libcxx/private_headers.verify.cpp
@@ -136,6 +136,7 @@
 #include <__algorithm/ranges_minmax.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_minmax.h'}}
 #include <__algorithm/ranges_minmax_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_minmax_element.h'}}
 #include <__algorithm/ranges_mismatch.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_mismatch.h'}}
+#include <__algorithm/ranges_merge.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_merge.h'}}
 #include <__algorithm/ranges_move.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_move.h'}}
 #include <__algorithm/ranges_move_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_move_backward.h'}}
 #include <__algorithm/ranges_none_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_none_of.h'}}
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.merge/ranges_merge.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.merge/ranges_merge.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.merge/ranges_merge.pass.cpp
@@ -0,0 +1,526 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_­iterator I1, sentinel_­for<I1> S1, input_­iterator I2, sentinel_­for<I2> S2,
+//          weakly_­incrementable O, class Comp = ranges::less, class Proj1 = identity,
+//          class Proj2 = identity>
+//   requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+//   constexpr merge_result<I1, I2, O>
+//     merge(I1 first1, S1 last1, I2 first2, S2 last2, O result,
+//           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                                    // since C++20
+//
+// template<input_­range R1, input_­range R2, weakly_­incrementable O, class Comp = ranges::less,
+//          class Proj1 = identity, class Proj2 = identity>
+//   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+//   constexpr merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
+//     merge(R1&& r1, R2&& r2, O result,
+//           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                                    // since C++20
+
+#include <algorithm>
+#include <array>
+#include <optional>
+
+#include "almost_satisfies_types.h"
+#include "MoveOnly.h"
+#include "test_iterators.h"
+
+template <class... Args>
+concept canMerge = requires(Args&&... args) { std::ranges::merge(std::forward<Args>(args)...); };
+
+// Test iterator overload's constraints:
+// =====================================
+
+// Positive tests: different categories of input iterators and output iterators
+static_assert(canMerge<int*, int*, int*, int*, int*>);
+static_assert(canMerge<int*, sentinel_wrapper<int*>, int*, sentinel_wrapper<int*>, int*>);
+static_assert(canMerge<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>, int*, int*, int*>);
+static_assert(canMerge<forward_iterator<int*>, sentinel_wrapper<forward_iterator<int*>>, int*, int*, int*>);
+static_assert(canMerge<int*, int*, bidirectional_iterator<int*>, sentinel_wrapper<bidirectional_iterator<int*>>, int*>);
+static_assert(canMerge<int*, int*, random_access_iterator<int*>, sentinel_wrapper<random_access_iterator<int*>>, int*>);
+static_assert(canMerge<int*, int*, contiguous_iterator<int*>, sentinel_wrapper<contiguous_iterator<int*>>, int*>);
+static_assert(canMerge<int*, int*, int*, int*, cpp17_output_iterator<int*>>);
+static_assert(canMerge<int*, int*, int*, int*, cpp20_output_iterator<int*>>);
+static_assert(canMerge<int*, int*, short*, short*, long*>);
+
+template <class... Sigs>
+struct Func;
+
+template <class R, class... Args, class... Rest>
+struct Func<R(Args...), Rest...> : Func<Rest>... {
+  using Func<Rest>::operator()...;
+  R operator()(Args...) const;
+};
+
+struct Foo {};
+struct Bar {};
+
+// Positive tests: different comparators and projections
+static_assert(canMerge<int*, int*, int*, int*, int*, Func<bool(int, int)>>);
+static_assert(canMerge<int*, int*, int*, int*, int*, Func<void*(short, long)>>);
+static_assert(
+    canMerge<int*, int*, int*, int*, int*, Func<bool(const Foo&, const Foo&)>, Func<Foo(int)>, Func<Foo(int)>>);
+
+using CompareOverloadSet = Func<
+    bool(const Foo&, const Bar&),
+    bool(const Bar&, const Foo&),
+    bool(const Foo&, const Foo&),
+    bool(const Bar&, const Bar&)>;
+static_assert(canMerge<int*, int*, int*, int*, int*, CompareOverloadSet, Func<Foo(int)>, Func<Bar(int)>>);
+
+// Negative tests: not enough input arguments
+static_assert(!canMerge<>);
+static_assert(!canMerge<int*>);
+static_assert(!canMerge<int*, int*>);
+static_assert(!canMerge<int*, int*, int*>);
+static_assert(!canMerge<int*, int*, int*, int*>);
+
+// Negative tests: !std::input_iterator<I1>
+static_assert(!canMerge<cpp20_output_iterator<int*>, sentinel_wrapper<cpp20_output_iterator<int*>>, int*, int*, int*>);
+static_assert(!canMerge<InputIteratorNotDerivedFrom, sentinel_wrapper<InputIteratorNotDerivedFrom>, int*, int*, int*>);
+
+// Negative tests: !std::sentinel_for<S1, I1>
+static_assert(!canMerge<int*, long*, int*, int*, int*>);
+static_assert(!canMerge<cpp20_input_iterator<int*>, int*, int*, int*, int*>);
+static_assert(!canMerge<const int*, sentinel_wrapper<int*>, int*, int*, int*>);
+
+// Negative tests: !std::input_iterator<I2>
+static_assert(!canMerge<int*, int*, cpp20_output_iterator<int*>, sentinel_wrapper<cpp20_output_iterator<int*>>, int*>);
+static_assert(!canMerge<int*, int*, InputIteratorNotDerivedFrom, sentinel_wrapper<InputIteratorNotDerivedFrom>, int*>);
+
+// Negative tests: !std::sentinel_for<S2, I2>
+static_assert(!canMerge<int*, int*, int*, long*, int*>);
+static_assert(!canMerge<int*, int*, cpp20_input_iterator<int*>, int*, int*>);
+static_assert(!canMerge<int*, int*, const int*, sentinel_wrapper<int*>, int*>);
+
+// Negative tests: !std::weakly_incrementable<O>
+static_assert(!canMerge<int*, int*, int*, int*, std::optional<int>>);
+
+// Negative tests: !std::indirectly_copyable<I1, Out>
+static_assert(!canMerge<int*, int*, int*, int*, const int*>);
+static_assert(!canMerge<Bar*, Bar*, Foo*, Foo*, Foo*, CompareOverloadSet>);
+static_assert(!canMerge<MoveOnly*, MoveOnly*, MoveOnly*, MoveOnly*, MoveOnly*>);
+
+// Negative tests: !std::indirectly_copyable<I2, Out>
+static_assert(!canMerge<Foo*, Foo*, Bar*, Bar*, Foo*, CompareOverloadSet>);
+
+// Negative tests: std::indirect_strict_weak_order<Comp, std::projected<I1, Proj1>, std::projected<I2, Proj2>>
+static_assert(!canMerge<int*, int*, int*, int*, int*, Func<bool(Foo, Foo)>>);
+static_assert(!canMerge<int*, int*, int*, int*, int*, std::ranges::less, Func<Foo(int)>>);
+static_assert(!canMerge<int*, int*, int*, int*, int*, std::ranges::less, std::identity, Func<Bar(int)>>);
+static_assert(
+    !canMerge<int*, int*, int*, int*, int*, Func<bool(Foo, Bar)>, Func<Foo(int)>, Func<Bar(int)>>,
+    "std::relation requires the predicate can be applied to all combination of Foo and Bar");
+
+// Test range overload's constraints:
+// =====================================
+
+template <class It, class St = sentinel_wrapper<It>>
+struct Range {
+  It begin() const;
+  St end() const;
+};
+
+// Positive tests: different categories of input ranges and output iterator
+static_assert(canMerge<Range<int*, int*>, Range<int*, int*>, int*>);
+static_assert(canMerge<Range<int*>, Range<int*>, int*>);
+static_assert(canMerge<Range<cpp20_input_iterator<int*>>, Range<int*>, int*>);
+static_assert(canMerge<Range<forward_iterator<int*>>, Range<int*>, int*>);
+static_assert(canMerge<Range<int*>, Range<bidirectional_iterator<int*>>, int*>);
+static_assert(canMerge<Range<int*>, Range<random_access_iterator<int*>>, int*>);
+static_assert(canMerge<Range<int*>, Range<contiguous_iterator<int*>>, int*>);
+static_assert(canMerge<Range<int*, int*>, Range<int*, int*>, cpp17_output_iterator<int*>>);
+static_assert(canMerge<Range<int*, int*>, Range<int*, int*>, cpp20_output_iterator<int*>>);
+static_assert(canMerge<Range<int*>, Range<short*>, long*>);
+
+// Positive tests: different comparators and projections
+static_assert(canMerge<Range<int*, int*>, Range<int*, int*>, int*, Func<bool(int, int)>>);
+static_assert(canMerge<Range<int*, int*>, Range<int*, int*>, int*, Func<void*(short, long)>>);
+static_assert(canMerge<Range<int*>, Range<int*>, int*, Func<bool(Foo, Foo)>, Func<Foo(int)>, Func<Foo(int)>>);
+static_assert(canMerge<Range<int*>, Range<int*>, int*, CompareOverloadSet, Func<Foo(int)>, Func<Bar(int)>>);
+
+// Negative tests: not enough input arguments
+static_assert(!canMerge<>);
+static_assert(!canMerge<Range<int*>>);
+static_assert(!canMerge<Range<int*>, Range<int*>>);
+
+// Negative tests: !std::input_range<R1>
+static_assert(!canMerge<Range<cpp20_output_iterator<int*>>, Range<int*>, int*>);
+static_assert(!canMerge<Range<InputIteratorNotDerivedFrom>, Range<int*>, int*>);
+
+// Negative tests: !std::input_range<R2>
+static_assert(!canMerge<Range<int*>, Range<cpp20_output_iterator<int*>>, int*>);
+static_assert(!canMerge<Range<int*>, Range<InputIteratorNotDerivedFrom>, int*>);
+
+// Negative tests: !std::weakly_incrementable<O>
+static_assert(!canMerge<Range<int*>, Range<int*>, std::optional<int>>);
+
+// Negative tests: !std::indirectly_copyable<ranges::iterator_t<R1>, Out>
+static_assert(!canMerge<Range<int*>, Range<int*>, const int*>);
+static_assert(!canMerge<Range<Bar*>, Range<Foo*>, Foo*, CompareOverloadSet>);
+static_assert(!canMerge<Range<MoveOnly*>, Range<MoveOnly*>, MoveOnly*>);
+
+// Negative tests: !std::indirectly_copyable<ranges::iterator_t<R2>, Out>
+static_assert(!canMerge<Range<Foo*>, Range<Bar*>, Foo*, CompareOverloadSet>);
+
+// Negative tests: std::indirect_strict_weak_order<Comp, std::projected<ranges::iterator_t<R1>, Proj1>, std::projected<ranges::iterator_t<R2>, Proj2>>
+static_assert(!canMerge<Range<int*>, Range<int*>, int*, Func<bool(Foo, Foo)>>);
+static_assert(!canMerge<Range<int*>, Range<int*>, int*, std::ranges::less, Func<Foo(int)>>);
+static_assert(!canMerge<Range<int*>, Range<int*>, int*, std::ranges::less, std::identity, Func<Bar(int)>>);
+static_assert(
+    !canMerge<Range<int*>, Range<int*>, int*, Func<bool(Foo, Bar)>, Func<Foo(int)>, Func<Bar(int)>>,
+    "std::relation requires the predicate can be applied to all combination of Foo and Bar");
+
+// test the range is correctly merged for different kinds of input ranges and output iterator
+template <class...>
+struct type_list {};
+
+template <class... In1, class... In2, class... Out, std::size_t... Is>
+constexpr auto cartesian_product_impl(
+    std::tuple<In1...>, std::tuple<In2...>, std::tuple<Out...>, std::index_sequence<Is...>)
+    -> type_list< type_list<
+        std::tuple_element_t<Is / (sizeof...(In2) * sizeof...(Out)), std::tuple<In1...>>,
+        std::tuple_element_t<Is % (sizeof...(In2) * sizeof...(Out)) / sizeof...(Out), std::tuple<In2...>>,
+        std::tuple_element_t<Is % sizeof...(Out), std::tuple<Out...>> >... >;
+
+template <class... In1, class... In2, class... Out>
+constexpr auto
+cartesian_product(type_list<In1...>, type_list<In2...>, type_list<Out...>) -> decltype(cartesian_product_impl(
+    std::declval<std::tuple<In1...>>(),
+    std::declval<std::tuple<In2...>>(),
+    std::declval<std::tuple<Out...>>(),
+    std::make_index_sequence<sizeof...(In1) * sizeof...(In2) * sizeof...(Out)>())) {
+  return {};
+}
+
+template <class In1, class In2, class Out>
+constexpr void testMergeCorrectImpl(type_list<In1, In2, Out>) {
+  std::array i1{0, 1, 5, 6, 9, 10};
+  std::array i2{3, 6, 7, 9, 13, 15, 100};
+  std::array expected{0, 1, 3, 5, 6, 6, 7, 9, 9, 10, 13, 15, 100};
+
+  // TODO: std::ranges::merge calls std::ranges::copy
+  // std::ranges::copy(contiguous_iterator<int*>, sentinel_wrapper<contiguous_iterator<int*>>, contiguous_iteartor<int*>) doesn't seem to work.
+  // It seems that std::ranges::copy calls std::copy, which unwraps contiguous_iterator<int*> into int*, and then it failed because there is no == between int* and sentinel_wrapper<contiguous_iterator<int*>>
+  using Sent1 = std::conditional_t<std::contiguous_iterator<In1>, In1, sentinel_wrapper<In1>>;
+  using Sent2 = std::conditional_t<std::contiguous_iterator<In2>, In2, sentinel_wrapper<In2>>;
+
+  // iterator overload
+  {
+    std::array<int, 13> out{};
+    std::same_as<std::ranges::merge_result<In1, In2, Out>> decltype(auto) result = std::ranges::merge(
+        In1{i1.data()},
+        Sent1{In1{i1.data() + i1.size()}},
+        In2{i2.data()},
+        Sent2{In2{i2.data() + i2.size()}},
+        Out{out.data()});
+    assert(std::ranges::equal(out, expected));
+
+    static_assert(std::same_as<decltype(result.in1), In1>);
+    assert(result.in1 == Sent1{In1{i1.data() + i1.size()}});
+
+    static_assert(std::same_as<decltype(result.in2), In2>);
+    assert(result.in2 == Sent2{In2{i2.data() + i2.size()}});
+
+    static_assert(std::same_as<decltype(result.out), Out>);
+    assert(base(result.out) == out.data() + out.size());
+  }
+
+  // range overload
+  {
+    std::array<int, 13> out{};
+    std::ranges::subrange r1{In1{i1.data()}, Sent1{In1{i1.data() + i1.size()}}};
+    std::ranges::subrange r2{In2{i2.data()}, Sent2{In2{i2.data() + i2.size()}}};
+    std::same_as<std::ranges::merge_result<In1, In2, Out>> decltype(auto) result =
+        std::ranges::merge(r1, r2, Out{out.data()});
+    assert(std::ranges::equal(out, expected));
+
+    static_assert(std::same_as<decltype(result.in1), In1>);
+    assert(result.in1 == Sent1{In1{i1.data() + i1.size()}});
+
+    static_assert(std::same_as<decltype(result.in2), In2>);
+    assert(result.in2 == Sent2{In2{i2.data() + i2.size()}});
+
+    static_assert(std::same_as<decltype(result.out), Out>);
+    assert(base(result.out) == out.data() + out.size());
+  }
+}
+
+template <class... Sigs>
+constexpr void runAllMergeCorrectTests(type_list<Sigs...>) {
+  (testMergeCorrectImpl(Sigs{}), ...);
+}
+
+struct TracedCopyMove {
+  int copy_ctor   = 0;
+  int move_ctor   = 0;
+  int copy_assign = 0;
+  int move_assign = 0;
+
+  int data = 0;
+
+  constexpr TracedCopyMove() = default;
+  constexpr TracedCopyMove(int i) : data(i) {}
+  constexpr TracedCopyMove(const TracedCopyMove& other)
+      : copy_ctor(other.copy_ctor + 1),
+        move_ctor(other.move_ctor),
+        copy_assign(other.copy_assign),
+        move_assign(other.move_assign),
+        data(other.data) {}
+
+  constexpr TracedCopyMove(TracedCopyMove&& other)
+      : copy_ctor(other.copy_ctor),
+        move_ctor(other.move_ctor + 1),
+        copy_assign(other.copy_assign),
+        move_assign(other.move_assign),
+        data(other.data) {}
+
+  constexpr TracedCopyMove& operator=(const TracedCopyMove& other) {
+    copy_ctor   = other.copy_ctor;
+    move_ctor   = other.move_ctor;
+    copy_assign = other.copy_assign + 1;
+    move_assign = other.move_assign;
+    data        = other.data;
+    return *this;
+  }
+
+  constexpr TracedCopyMove& operator=(TracedCopyMove&& other) {
+    copy_ctor   = other.copy_ctor;
+    move_ctor   = other.move_ctor;
+    copy_assign = other.copy_assign;
+    move_assign = other.move_assign + 1;
+    data        = other.data;
+    return *this;
+  }
+
+  friend constexpr bool operator==(const TracedCopyMove& x, const TracedCopyMove& y) { return x.data == y.data; }
+  friend constexpr auto operator<=>(const TracedCopyMove& x, const TracedCopyMove& y) { return x.data <=> y.data; }
+};
+
+struct IntAndID {
+  int data = 0;
+  int id   = 0;
+
+  friend constexpr auto operator==(const IntAndID& x, const IntAndID& y) { return x.data == y.data; }
+  friend constexpr auto operator<=>(const IntAndID& x, const IntAndID& y) { return x.data <=> y.data; }
+};
+
+struct Data {
+  int data = 0;
+};
+
+constexpr bool test() {
+  // Test merge produces correct result for different kinds of iterators
+  {
+    using In1s = type_list<
+        cpp20_input_iterator<int*>,
+        forward_iterator<int*>,
+        bidirectional_iterator<int*>,
+        random_access_iterator<int*>,
+        contiguous_iterator<int*> >;
+
+    using In2s = type_list<
+        cpp20_input_iterator<int*>,
+        forward_iterator<int*>,
+        bidirectional_iterator<int*>,
+        random_access_iterator<int*>,
+        contiguous_iterator<int*> >;
+
+    using Outs = type_list<
+        cpp17_output_iterator<int*>,
+        cpp20_output_iterator<int*>,
+        cpp17_input_iterator<int*>,
+        cpp20_input_iterator<int*>,
+        forward_iterator<int*>,
+        bidirectional_iterator<int*>,
+        random_access_iterator<int*>,
+        contiguous_iterator<int*>>;
+    runAllMergeCorrectTests(cartesian_product(In1s{}, In2s{}, Outs{}));
+  }
+
+  // check that ranges::dangling is returned for non-borrowed_range and iterator_t is returned for borrowed_range
+  {
+    std::array r1{3, 6, 7, 9};
+    std::array<int, 7> out;
+    std::same_as<
+        std::ranges::
+            merge_result<std::ranges::iterator_t<std::array<int, 4>&>, std::ranges::dangling, int*>> decltype(auto)
+        result = std::ranges::merge(r1, std::array{2, 3, 4}, out.data());
+    assert(result.in1 == r1.end());
+    assert(result.out == out.data() + out.size());
+    assert(std::ranges::equal(out, std::array{2, 3, 3, 4, 6, 7, 9}));
+  }
+
+  // check that every element is copied exactly once
+  {
+    std::array r1{TracedCopyMove{3}, TracedCopyMove{5}, TracedCopyMove{8}};
+    std::array r2{TracedCopyMove{1}, TracedCopyMove{3}, TracedCopyMove{8}};
+    using iter = std::ranges::iterator_t<std::array<TracedCopyMove, 3>&>;
+
+    const auto verify = [&](const auto& result, const auto& out) {
+      assert(result.in1 == r1.end());
+      assert(result.in2 == r2.end());
+      assert(result.out == out.end());
+      assert(std::ranges::equal(out, std::array<TracedCopyMove, 6>{1, 3, 3, 5, 8, 8}));
+
+      std::ranges::all_of(out, [](const TracedCopyMove& e) {
+        return e.copy_assign == 1 && e.move_assign == 0 && e.copy_ctor == 0 && e.move_ctor == 0;
+      });
+    };
+
+    // iter overload
+    {
+      std::array<TracedCopyMove, 6> out{};
+      std::same_as<std::ranges::merge_result<iter, iter, TracedCopyMove*>> decltype(auto) result =
+          std::ranges::merge(r1.begin(), r1.end(), r2.begin(), r2.end(), out.data());
+      verify(result, out);
+    }
+
+    // range overload
+    {
+      std::array<TracedCopyMove, 6> out{};
+      std::same_as<std::ranges::merge_result<iter, iter, TracedCopyMove*>> decltype(auto) result =
+          std::ranges::merge(r1, r2, out.data());
+      verify(result, out);
+    }
+  }
+
+  // Algorithm is stable: equal elements should merged in the original order
+  {
+    std::array r1{IntAndID{0, 0}, IntAndID{0, 1}, IntAndID{0, 2}};
+    std::array r2{IntAndID{1, 0}, IntAndID{1, 1}, IntAndID{1, 2}};
+
+    const auto verify = [&](const std::array<IntAndID, 6>& out) {
+      assert(std::ranges::equal(out | std::views::transform(&IntAndID::data), std::array{0, 0, 0, 1, 1, 1}));
+
+      // ID should be in their original order
+      assert(std::ranges::equal(out | std::views::transform(&IntAndID::id), std::array{0, 1, 2, 0, 1, 2}));
+    };
+
+    // range overload
+    {
+      std::array<IntAndID, 6> out;
+      std::ranges::merge(r1, r2, out.data());
+      verify(out);
+    }
+
+    // iteartor overload
+    {
+      std::array<IntAndID, 6> out;
+      std::ranges::merge(r1.begin(), r1.end(), r2.begin(), r2.end(), out.data());
+      verify(out);
+    }
+  }
+
+  // Equal elements in R1 should be merged before equal elements in R2
+  {
+    std::array r1{IntAndID{0, 1}, IntAndID{1, 1}, IntAndID{2, 1}};
+    std::array r2{IntAndID{0, 2}, IntAndID{1, 2}, IntAndID{2, 2}};
+    const auto verify = [&](const std::array<IntAndID, 6>& out) {
+      assert(std::ranges::equal(out | std::views::transform(&IntAndID::data), std::array{0, 0, 1, 1, 2, 2}));
+
+      // ID 1 (from R1) should be in front of ID 2 (from R2)
+      assert(std::ranges::equal(out | std::views::transform(&IntAndID::id), std::array{1, 2, 1, 2, 1, 2}));
+    };
+
+    // range overload
+    {
+      std::array<IntAndID, 6> out;
+      std::ranges::merge(r1, r2, out.data());
+      verify(out);
+    }
+
+    // iteartor overload
+    {
+      std::array<IntAndID, 6> out;
+      std::ranges::merge(r1.begin(), r1.end(), r2.begin(), r2.end(), out.data());
+      verify(out);
+    }
+  }
+
+  // Test custom comparator
+  {
+    std::array r1{Data{4}, Data{8}, Data{12}};
+    std::array r2{Data{5}, Data{9}};
+    using Iter1 = std::ranges::iterator_t<decltype((r1))>;
+    using Iter2 = std::ranges::iterator_t<decltype((r2))>;
+
+    const auto verify = [&](const auto& result, const std::array<Data, 5>& out) {
+      assert(std::ranges::equal(out | std::views::transform(&Data::data), std::array{4, 5, 8, 9, 12}));
+
+      assert(result.in1 == r1.end());
+      assert(result.in2 == r2.end());
+      assert(result.out == out.end());
+    };
+
+    // range overload
+    {
+      std::array<Data, 5> out;
+      std::same_as<std::ranges::merge_result<Iter1, Iter2, Data*>> decltype(auto) result =
+          std::ranges::merge(r1, r2, out.data(), [](const Data& x, const Data& y) { return x.data < y.data; });
+      verify(result, out);
+    }
+
+    // iteartor overload
+    {
+      std::array<Data, 5> out;
+      std::same_as<std::ranges::merge_result<Iter1, Iter2, Data*>> decltype(auto) result =
+          std::ranges::merge(r1.begin(), r1.end(), r2.begin(), r2.end(), out.data(), [](const Data& x, const Data& y) {
+            return x.data < y.data;
+          });
+      verify(result, out);
+    }
+  }
+
+  // Test Projection
+  {
+    std::array r1{Data{4}, Data{8}, Data{12}};
+    std::array r2{Data{5}, Data{9}};
+    using Iter1 = std::ranges::iterator_t<decltype((r1))>;
+    using Iter2 = std::ranges::iterator_t<decltype((r2))>;
+
+    const auto verify = [&](const auto& result, const std::array<Data, 5>& out) {
+      assert(std::ranges::equal(out | std::views::transform(&Data::data), std::array{4, 5, 8, 9, 12}));
+
+      assert(result.in1 == r1.end());
+      assert(result.in2 == r2.end());
+      assert(result.out == out.end());
+    };
+
+    const auto proj = &Data::data;
+
+    // range overload
+    {
+      std::array<Data, 5> out;
+      std::same_as<std::ranges::merge_result<Iter1, Iter2, Data*>> decltype(auto) result =
+          std::ranges::merge(r1, r2, out.data(), std::ranges::less{}, proj, proj);
+      verify(result, out);
+    }
+
+    // iteartor overload
+    {
+      std::array<Data, 5> out;
+      std::same_as<std::ranges::merge_result<Iter1, Iter2, Data*>> decltype(auto) result =
+          std::ranges::merge(r1.begin(), r1.end(), r2.begin(), r2.end(), out.data(), std::ranges::less{}, proj, proj);
+      verify(result, out);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp b/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
--- a/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
+++ b/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
@@ -98,7 +98,7 @@
 //static_assert(test(std::ranges::make_heap, a));
 static_assert(test(std::ranges::max, a));
 static_assert(test(std::ranges::max_element, a));
-//static_assert(test(std::ranges::merge, a, a, a));
+static_assert(test(std::ranges::merge, a, a, a));
 static_assert(test(std::ranges::min, a));
 static_assert(test(std::ranges::min_element, a));
 static_assert(test(std::ranges::minmax, a));