diff --git a/libcxx/include/__iterator/concepts.h b/libcxx/include/__iterator/concepts.h
--- a/libcxx/include/__iterator/concepts.h
+++ b/libcxx/include/__iterator/concepts.h
@@ -125,7 +125,34 @@
     { __i-- } -> same_as<_Ip>;
   };
 
-  // clang-format on
+template<class, class>
+inline constexpr bool disable_sized_sentinel_for = false;
+
+template<class _Sp, class _Ip>
+concept sized_sentinel_for =
+  sentinel_for<_Sp, _Ip> &&
+  !disable_sized_sentinel_for<remove_cv_t<_Sp>, remove_cv_t<_Ip> > &&
+  requires(const _Ip& __i, const _Sp& __s) {
+    { __s - __i } -> same_as<iter_difference_t<_Ip> >;
+    { __i - __s } -> same_as<iter_difference_t<_Ip> >;
+  };
+
+template<class _Ip>
+concept random_access_iterator =
+  bidirectional_iterator<_Ip> &&
+  derived_from<_ITER_CONCEPT<_Ip>, random_access_iterator_tag> &&
+  totally_ordered<_Ip> &&
+  sized_sentinel_for<_Ip, _Ip> &&
+  requires(_Ip __i, const _Ip __j, const iter_difference_t<_Ip> __n) {
+    { __i += __n } -> same_as<_Ip&>;
+    { __j +  __n } -> same_as<_Ip>;
+    { __n +  __j } -> same_as<_Ip>;
+    { __i -= __n } -> same_as<_Ip&>;
+    { __j -  __n } -> same_as<_Ip>;
+    {  __j[__n]  } -> same_as<iter_reference_t<_Ip>>;
+  };
+
+// clang-format on
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
diff --git a/libcxx/include/__ranges/concepts.h b/libcxx/include/__ranges/concepts.h
--- a/libcxx/include/__ranges/concepts.h
+++ b/libcxx/include/__ranges/concepts.h
@@ -65,6 +65,10 @@
 
   template <class _Tp>
   concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp> >;
+
+  template <class _Tp>
+  concept random_access_range =
+      bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp> >;
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
diff --git a/libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp
@@ -24,7 +24,9 @@
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
+static_assert(stdr::random_access_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
+static_assert(stdr::random_access_range<range const>);
diff --git a/libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp
@@ -24,7 +24,9 @@
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
+static_assert(stdr::random_access_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
+static_assert(stdr::random_access_range<range const>);
diff --git a/libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp
@@ -25,8 +25,10 @@
 static_assert(stdr::common_range<range>);
 static_assert(stdr::forward_range<range>);
 static_assert(!stdr::bidirectional_range<range>);
+static_assert(stdr::random_access_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::forward_range<range const>);
 static_assert(!stdr::bidirectional_range<range const>);
+static_assert(stdr::random_access_range<range const>);
diff --git a/libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp
@@ -24,7 +24,9 @@
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
+static_assert(stdr::random_access_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
+static_assert(stdr::random_access_range<range const>);
diff --git a/libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp
@@ -24,7 +24,9 @@
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
+static_assert(stdr::random_access_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
+static_assert(stdr::random_access_range<range const>);
diff --git a/libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp
@@ -24,7 +24,9 @@
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
+static_assert(stdr::random_access_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
+static_assert(stdr::random_access_range<range const>);
diff --git a/libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp
@@ -24,7 +24,9 @@
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
+static_assert(stdr::random_access_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
+static_assert(stdr::random_access_range<range const>);
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.random.access/random_access_iterator.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.random.access/random_access_iterator.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.random.access/random_access_iterator.compile.pass.cpp
@@ -0,0 +1,287 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// XFAIL: msvc && clang
+
+// template<class T>
+// concept random_access_iterator;
+
+#include <iterator>
+
+#include "test_iterators.h"
+
+static_assert(!std::random_access_iterator<input_iterator<int*> >);
+static_assert(!std::random_access_iterator<forward_iterator<int*> >);
+static_assert(!std::random_access_iterator<bidirectional_iterator<int*> >);
+static_assert(std::random_access_iterator<random_access_iterator<int*> >);
+static_assert(std::random_access_iterator<contiguous_iterator<int*> >);
+
+static_assert(!std::random_access_iterator<cxx20_input_iterator<int*> >);
+static_assert(!std::random_access_iterator<cxx20_forward_iterator<int*> >);
+static_assert(!std::random_access_iterator<cxx20_bidirectional_iterator<int*> >);
+// TODO: are we adding cxx20_iterators?
+// static_assert( std::random_access_iterator<cxx20_random_access_iterator<int*> >);
+
+static_assert(std::random_access_iterator<int*>);
+static_assert(std::random_access_iterator<int const*>);
+static_assert(std::random_access_iterator<int volatile*>);
+static_assert(std::random_access_iterator<int const volatile*>);
+
+struct simple_random_access_iterator {
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef simple_random_access_iterator   self;
+
+    simple_random_access_iterator();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+
+    reference operator[](difference_type n) const;
+};
+static_assert(std::forward_iterator<simple_random_access_iterator>);
+static_assert(std::random_access_iterator<simple_random_access_iterator>);
+
+struct no_plus_equals {
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef no_plus_equals                  self;
+
+    no_plus_equals();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+
+    reference operator[](difference_type n) const;
+};
+static_assert(std::forward_iterator<no_plus_equals>);
+static_assert(!std::random_access_iterator<no_plus_equals>);
+
+struct no_plus_difference_type {
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef no_plus_difference_type         self;
+
+    no_plus_difference_type();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+
+    reference operator[](difference_type n) const;
+};
+static_assert(std::forward_iterator<no_plus_difference_type>);
+static_assert(!std::random_access_iterator<no_plus_difference_type>);
+
+struct difference_type_no_plus {
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef difference_type_no_plus         self;
+
+    difference_type_no_plus();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+
+    reference operator[](difference_type n) const;
+};
+static_assert(std::forward_iterator<difference_type_no_plus>);
+static_assert(!std::random_access_iterator<difference_type_no_plus>);
+
+struct no_minus_equals {
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef no_minus_equals                 self;
+
+    no_minus_equals();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+
+    reference operator[](difference_type n) const;
+};
+static_assert(std::forward_iterator<no_minus_equals>);
+static_assert(!std::random_access_iterator<no_minus_equals>);
+
+struct no_minus {
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef no_minus                        self;
+
+    no_minus();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+
+    reference operator[](difference_type n) const;
+};
+static_assert(std::forward_iterator<no_minus>);
+static_assert(!std::random_access_iterator<no_minus>);
+
+struct no_subscript {
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef no_subscript                    self;
+
+    no_subscript();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+};
+static_assert(std::forward_iterator<no_subscript>);
+static_assert(!std::random_access_iterator<no_subscript>);
diff --git a/libcxx/test/std/ranges/range.refinements/random_access_range.compile.pass.cpp b/libcxx/test/std/ranges/range.refinements/random_access_range.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.refinements/random_access_range.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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// XFAIL: msvc && clang
+
+// template<range _Rp>
+// concept random_access_range;
+
+#include <ranges>
+
+#include "test_range.h"
+#include "test_iterators.h"
+
+namespace ranges = std::ranges;
+
+template <template <class...> class I>
+constexpr bool check_range() {
+  constexpr bool result = ranges::random_access_range<test_range<I> >;
+  static_assert(ranges::random_access_range<test_range<I> const> == result);
+  static_assert(ranges::random_access_range<test_non_const_common_range<I> > == result);
+  static_assert(ranges::random_access_range<test_non_const_range<I> > == result);
+  static_assert(ranges::random_access_range<test_common_range<I> > == result);
+  static_assert(ranges::random_access_range<test_common_range<I> const> == result);
+  static_assert(!ranges::random_access_range<test_non_const_common_range<I> const>);
+  static_assert(!ranges::random_access_range<test_non_const_range<I> const>);
+  return result;
+}
+
+static_assert(!check_range<input_iterator>());
+static_assert(!check_range<forward_iterator>());
+static_assert(!check_range<bidirectional_iterator>());
+static_assert(check_range<random_access_iterator>());
+static_assert(check_range<contiguous_iterator>());
diff --git a/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp
@@ -23,7 +23,9 @@
 static_assert(std::same_as<stdr::iterator_t<std::cmatch>, std::cmatch::iterator>);
 static_assert(stdr::common_range<std::cmatch>);
 static_assert(stdr::bidirectional_range<std::cmatch>);
+static_assert(stdr::bidirectional_range<std::cmatch>);
 
 static_assert(std::same_as<stdr::iterator_t<std::cmatch const>, std::cmatch::const_iterator>);
 static_assert(stdr::common_range<std::cmatch const>);
 static_assert(stdr::bidirectional_range<std::cmatch const>);
+static_assert(stdr::bidirectional_range<std::cmatch const>);
diff --git a/libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp
@@ -23,7 +23,9 @@
 static_assert(std::same_as<stdr::iterator_t<std::string>, std::string::iterator>);
 static_assert(stdr::common_range<std::string>);
 static_assert(stdr::bidirectional_range<std::string>);
+static_assert(stdr::random_access_range<std::string>);
 
 static_assert(std::same_as<stdr::iterator_t<std::string const>, std::string::const_iterator>);
 static_assert(stdr::common_range<std::string const>);
 static_assert(stdr::bidirectional_range<std::string const>);
+static_assert(stdr::random_access_range<std::string const>);
diff --git a/libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp
@@ -23,7 +23,9 @@
 static_assert(std::same_as<stdr::iterator_t<std::string_view>, std::string_view::iterator>);
 static_assert(stdr::common_range<std::string_view>);
 static_assert(stdr::bidirectional_range<std::string_view>);
+static_assert(stdr::random_access_range<std::string_view>);
 
 static_assert(std::same_as<stdr::iterator_t<std::string_view const>, std::string_view::const_iterator>);
 static_assert(stdr::common_range<std::string_view const>);
 static_assert(stdr::bidirectional_range<std::string_view const>);
+static_assert(stdr::random_access_range<std::string_view const>);