diff --git a/libcxx/docs/Status/SpaceshipProjects.csv b/libcxx/docs/Status/SpaceshipProjects.csv
--- a/libcxx/docs/Status/SpaceshipProjects.csv
+++ b/libcxx/docs/Status/SpaceshipProjects.csv
@@ -44,7 +44,7 @@
 | `multimap <https://reviews.llvm.org/D145976>`_",[expos.only.func],Hristo Hristov,|Complete|
 | `[associative.set.syn] <https://wg21.link/associative.set.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),"| multiset
 | set",[expos.only.func],Hristo Hristov,|In Progress|
-| `[queue.ops] <https://wg21.link/queue.ops>`_,| `queue <https://reviews.llvm.org/D146066>`_,None,Hristo Hristov,|In Progress|
+| `[queue.ops] <https://wg21.link/queue.ops>`_,| `queue <https://reviews.llvm.org/D146066>`_,None,Hristo Hristov,|Complete|
 | `[stack.ops] <https://wg21.link/stack.ops>`_,| `stack <https://reviews.llvm.org/D146094>`_,None,Hristo Hristov,|In Progress|
 | `[reverse.iter.cmp] <https://wg21.link/reverse.iter.cmp>`_,| `reverse_iterator <https://reviews.llvm.org/D113695>`_,None,Mikhail Maltsev,|Complete|
 | `[move.iter.op.comp] <https://wg21.link/move.iter.op.comp>`_,| `move_iterator <https://reviews.llvm.org/D117656>`_,None,Arthur O'Dwyer,|Complete|
diff --git a/libcxx/include/queue b/libcxx/include/queue
--- a/libcxx/include/queue
+++ b/libcxx/include/queue
@@ -104,6 +104,10 @@
 template <class T, class Container>
   bool operator<=(const queue<T, Container>& x,const queue<T, Container>& y);
 
+template<class T, three_way_comparable Container>
+  compare_three_way_result_t<Container>
+    operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);  // since C++20
+
 template <class T, class Container>
   void swap(queue<T, Container>& x, queue<T, Container>& y)
   noexcept(noexcept(x.swap(y)));
@@ -394,6 +398,30 @@
     _LIBCPP_INLINE_VISIBILITY
     bool
     operator< (const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
+
+#if _LIBCPP_STD_VER >= 20
+
+    template <class _T1, class _C1>
+    friend _LIBCPP_HIDE_FROM_ABI bool
+    operator!=(const queue<_T1, _C1>& __x, const queue<_T1, _C1>& __y);
+
+    template <class _T1, class _C1>
+    friend _LIBCPP_HIDE_FROM_ABI bool
+    operator>(const queue<_T1, _C1>& __x, const queue<_T1, _C1>& __y);
+
+    template <class _T1, class _C1>
+    friend _LIBCPP_HIDE_FROM_ABI bool
+    operator>=(const queue<_T1, _C1>& __x, const queue<_T1, _C1>& __y);
+
+    template <class _T1, class _C1>
+    friend _LIBCPP_HIDE_FROM_ABI bool
+    operator<=(const queue<_T1, _C1>& __x, const queue<_T1, _C1>& __y);
+
+    template <class _T1, three_way_comparable _C1>
+    friend _LIBCPP_HIDE_FROM_ABI compare_three_way_result_t<_C1>
+    operator<=>(const queue<_T1, _C1>& __x, const queue<_T1, _C1>& __y);
+
+#endif
 };
 
 #if _LIBCPP_STD_VER >= 17
@@ -474,6 +502,16 @@
     return !(__y < __x);
 }
 
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Tp, three_way_comparable _Container>
+inline _LIBCPP_HIDE_FROM_ABI compare_three_way_result_t<_Container>
+operator<=>(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
+    return __x.c <=> __y.c;
+}
+
+#endif
+
 template <class _Tp, class _Container>
 inline _LIBCPP_INLINE_VISIBILITY
 __enable_if_t<__is_swappable<_Container>::value, void>
diff --git a/libcxx/test/std/containers/container.adaptors/queue/compare.three_way.pass.cpp b/libcxx/test/std/containers/container.adaptors/queue/compare.three_way.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/queue/compare.three_way.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <queue>
+
+// template<class T, three_way_comparable Container>
+//   compare_three_way_result_t<Container>
+//     operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);
+
+#include <cassert>
+#include <deque>
+#include <queue>
+#include <list>
+
+#include "test_container_comparisons.h"
+
+int main(int, char**) {
+  assert((test_sequence_container_adaptor_spaceship<std::queue, std::deque>()));
+  assert((test_sequence_container_adaptor_spaceship<std::queue, std::list>()));
+  // `std::queue` is not constexpr, so no `static_assert` test here.
+  return 0;
+}
diff --git a/libcxx/test/support/test_container_comparisons.h b/libcxx/test/support/test_container_comparisons.h
--- a/libcxx/test/support/test_container_comparisons.h
+++ b/libcxx/test/support/test_container_comparisons.h
@@ -205,4 +205,91 @@
   return true;
 }
 
+// Implementation detail of `test_sequence_container_adaptor_spaceship`
+template <template <typename...> typename ContainerAdaptor,
+          template <typename...>
+          typename Container,
+          typename Elem,
+          typename Order>
+constexpr void test_sequence_container_adaptor_spaceship_with_type() {
+  // Empty containers
+  {
+    Container<Elem> l1;
+    ContainerAdaptor<Elem, Container<Elem>> ca1{l1};
+    Container<Elem> l2;
+    ContainerAdaptor<Elem, Container<Elem>> ca2{l2};
+    assert(testOrder(ca1, ca2, Order::equivalent));
+  }
+  // Identical contents
+  {
+    Container<Elem> l1{1, 1};
+    ContainerAdaptor<Elem, Container<Elem>> ca1{l1};
+    Container<Elem> l2{1, 1};
+    ContainerAdaptor<Elem, Container<Elem>> ca2{l2};
+    assert(testOrder(ca1, ca2, Order::equivalent));
+  }
+  // Less, due to contained values
+  {
+    Container<Elem> l1{1, 1};
+    ContainerAdaptor<Elem, Container<Elem>> ca1{l1};
+    Container<Elem> l2{1, 2};
+    ContainerAdaptor<Elem, Container<Elem>> ca2{l2};
+    assert(testOrder(ca1, ca2, Order::less));
+  }
+  // Greater, due to contained values
+  {
+    Container<Elem> l1{1, 3};
+    ContainerAdaptor<Elem, Container<Elem>> ca1{l1};
+    Container<Elem> l2{1, 2};
+    ContainerAdaptor<Elem, Container<Elem>> ca2{l2};
+    assert(testOrder(ca1, ca2, Order::greater));
+  }
+  // Shorter list
+  {
+    Container<Elem> l1{1};
+    ContainerAdaptor<Elem, Container<Elem>> ca1{l1};
+    Container<Elem> l2{1, 2};
+    ContainerAdaptor<Elem, Container<Elem>> ca2{l2};
+    assert(testOrder(ca1, ca2, Order::less));
+  }
+  // Longer list
+  {
+    Container<Elem> l1{1, 2};
+    ContainerAdaptor<Elem, Container<Elem>> ca1{l1};
+    Container<Elem> l2{1};
+    ContainerAdaptor<Elem, Container<Elem>> ca2{l2};
+    assert(testOrder(ca1, ca2, Order::greater));
+  }
+  // Unordered
+  if constexpr (std::is_same_v<Elem, PartialOrder>) {
+    Container<Elem> l1{1, std::numeric_limits<int>::min()};
+    ContainerAdaptor<Elem, Container<Elem>> ca1{l1};
+    Container<Elem> l2{1, 2};
+    ContainerAdaptor<Elem, Container<Elem>> ca2{l2};
+    assert(testOrder(ca1, ca2, Order::unordered));
+  }
+}
+
+// Tests the `operator<=>` on sequence container adaptors
+template <template <typename...> typename ContainerAdaptor, template <typename...> typename Container>
+constexpr bool test_sequence_container_adaptor_spaceship() {
+  // The container should fulfil `std::three_way_comparable`
+  static_assert(std::three_way_comparable<ContainerAdaptor<int, Container<int>>>);
+
+  // Test different comparison categories
+  test_sequence_container_adaptor_spaceship_with_type<ContainerAdaptor, Container, int, std::strong_ordering>();
+  test_sequence_container_adaptor_spaceship_with_type<ContainerAdaptor, Container, StrongOrder, std::strong_ordering>();
+  test_sequence_container_adaptor_spaceship_with_type<ContainerAdaptor, Container, WeakOrder, std::weak_ordering>();
+  test_sequence_container_adaptor_spaceship_with_type<ContainerAdaptor, Container, PartialOrder, std::partial_ordering>();
+
+  // `LessAndEqComp` does not have `operator<=>`. Ordering is sythesized based on `operator<`
+  test_sequence_container_adaptor_spaceship_with_type<ContainerAdaptor, Container, LessAndEqComp, std::weak_ordering>();
+
+  // Thanks to SFINAE, the following is not a compiler error but returns `false`
+  struct NonComparable {};
+  static_assert(!std::three_way_comparable<ContainerAdaptor<NonComparable>>);
+
+  return true;
+}
+
 #endif