diff --git a/libcxx/include/random b/libcxx/include/random
--- a/libcxx/include/random
+++ b/libcxx/include/random
@@ -17,6 +17,9 @@
 
 namespace std
 {
+// [rand.req.urng], uniform random bit generator requirements
+template<class G>
+concept uniform_random_bit_generator = see below;
 
 // Engines
 
@@ -1678,6 +1681,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <cmath>
+#include <concepts>
 #include <type_traits>
 #include <initializer_list>
 #include <limits>
@@ -1697,6 +1701,20 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
+
+// [rand.req.urng]
+template<class G>
+concept uniform_random_bit_generator =
+  invocable<G&> && unsigned_integral<invoke_result_t<G&>> &&
+  requires {
+    { G::min() } -> same_as<invoke_result_t<G&>>;
+    { G::max() } -> same_as<invoke_result_t<G&>>;
+    requires bool_constant<(G::min() < G::max())>::value;
+  };
+
+#endif // _LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
+
 // __is_seed_sequence
 
 template <class _Sseq, class _Engine>
diff --git a/libcxx/test/std/concepts/lang/arithmetic.pass.cpp b/libcxx/test/std/concepts/lang/arithmetic.pass.cpp
--- a/libcxx/test/std/concepts/lang/arithmetic.pass.cpp
+++ b/libcxx/test/std/concepts/lang/arithmetic.pass.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class T>
diff --git a/libcxx/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp b/libcxx/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp
deleted file mode 100644
--- a/libcxx/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-int main(int, char**)
-{
-
-  return 0;
-}
diff --git a/libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp b/libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp
@@ -0,0 +1,132 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// template<class T>
+// concept uniform_random_bit_generator = // see below
+
+#include <random>
+
+static_assert(std::uniform_random_bit_generator<
+              std::linear_congruential_engine<unsigned int, 0U, 1U, 2U> >);
+static_assert(std::uniform_random_bit_generator<
+              std::subtract_with_carry_engine<__uint128_t, 1U, 2U, 3U> >);
+
+// Not invocable
+static_assert(!std::uniform_random_bit_generator<void>);
+static_assert(!std::uniform_random_bit_generator<int>);
+static_assert(!std::uniform_random_bit_generator<int[10]>);
+static_assert(!std::uniform_random_bit_generator<int*>);
+static_assert(!std::uniform_random_bit_generator<const int*>);
+static_assert(!std::uniform_random_bit_generator<volatile int*>);
+static_assert(!std::uniform_random_bit_generator<const volatile int*>);
+static_assert(!std::uniform_random_bit_generator<int&>);
+static_assert(!std::uniform_random_bit_generator<const int&>);
+static_assert(!std::uniform_random_bit_generator<volatile int&>);
+static_assert(!std::uniform_random_bit_generator<const volatile int&>);
+static_assert(!std::uniform_random_bit_generator<int&&>);
+static_assert(!std::uniform_random_bit_generator<const int&&>);
+static_assert(!std::uniform_random_bit_generator<volatile int&&>);
+static_assert(!std::uniform_random_bit_generator<const volatile int&&>);
+
+struct Empty {};
+static_assert(!std::uniform_random_bit_generator<Empty>);
+
+namespace WrongReturnType {
+using FunctionPointer = void (*)();
+static_assert(!std::uniform_random_bit_generator<FunctionPointer>);
+
+using FunctionReference = int (&)();
+static_assert(!std::uniform_random_bit_generator<FunctionReference>);
+
+struct FunctionObject {
+  unsigned long* operator()();
+};
+static_assert(!std::uniform_random_bit_generator<FunctionObject>);
+static_assert(!std::uniform_random_bit_generator<unsigned int Empty::*>);
+static_assert(!std::uniform_random_bit_generator<unsigned short (Empty::*)()>);
+} // namespace WrongReturnType
+
+namespace NoMinOrMax {
+using FunctionPointer = unsigned int (*)();
+static_assert(!std::uniform_random_bit_generator<FunctionPointer>);
+
+using FunctionReference = unsigned long long (&)();
+static_assert(!std::uniform_random_bit_generator<FunctionReference>);
+
+struct FunctionObject {
+  unsigned char operator()();
+};
+static_assert(!std::uniform_random_bit_generator<FunctionObject>);
+} // namespace NoMinOrMax
+
+namespace OnlyMinIsRight {
+struct NoMax {
+  unsigned char operator()();
+
+  static unsigned char min();
+};
+static_assert(!std::uniform_random_bit_generator<NoMax>);
+
+struct MaxHasWrongReturnType {
+  unsigned char operator()();
+
+  static unsigned char min();
+  static unsigned int max();
+};
+
+static_assert(!std::uniform_random_bit_generator<MaxHasWrongReturnType>);
+} // namespace OnlyMinIsRight
+
+namespace OnlyMaxIsRight {
+struct NoMin {
+  unsigned char operator()();
+
+  static unsigned char max();
+};
+static_assert(!std::uniform_random_bit_generator<NoMin>);
+
+struct MinHasWrongReturnType {
+  unsigned char operator()();
+
+  static unsigned int min();
+  static unsigned char max();
+};
+
+static_assert(!std::uniform_random_bit_generator<MinHasWrongReturnType>);
+} // namespace OnlyMaxIsRight
+
+namespace MinNotLessMax {
+struct NotConstexpr {
+  unsigned char operator()();
+
+  static unsigned char min();
+  static unsigned char max();
+};
+static_assert(!std::uniform_random_bit_generator<NotConstexpr>);
+
+struct MaxLessThanMin {
+  unsigned char operator()();
+
+  static constexpr unsigned char min() { return ~0; }
+  static constexpr unsigned char max() { return 0; }
+};
+static_assert(!std::uniform_random_bit_generator<MaxLessThanMin>);
+} // namespace MinNotLessMax
+
+struct Works {
+  unsigned char operator()();
+
+  static constexpr unsigned char min() { return 0; }
+  static constexpr unsigned char max() { return ~0; }
+};
+static_assert(std::uniform_random_bit_generator<Works>);
+
+int main(int, char**) { return 0; }