diff --git a/tests/performance/network/network_storage/network_storage.cpp b/tests/performance/network/network_storage/network_storage.cpp
@@ -10,7 +10,6 @@
 #include <hpx/lcos/local/detail/sliding_semaphore.hpp>
 
 #include <boost/assert.hpp>
-#include <boost/random.hpp>
 
 #include <algorithm>
 #include <array>
@@ -20,12 +19,13 @@
 #include <cstdint>
 #include <cstdio>
 #include <iostream>
+#include <map>
 #include <memory>
 #include <mutex>
+#include <random>
 #include <string>
 #include <utility>
 #include <vector>
-#include <map>
 
 #include <hpx/runtime/serialization/serialize.hpp>
 #include <simple_profiler.hpp>
@@ -484,8 +484,8 @@ int reduce(hpx::future<std::vector<hpx::future<int> > > futvec)
 // Test speed of write/put
 void test_write(
     uint64_t rank, uint64_t nranks, uint64_t num_transfer_slots,
-    boost::random::mt19937& gen, boost::random::uniform_int_distribution<>& random_rank,
-    boost::random::uniform_int_distribution<>& random_slot,
+    std::mt19937& gen, std::uniform_int_distribution<>& random_rank,
+    std::uniform_int_distribution<>& random_slot,
     test_options &options
     )
 {
@@ -706,8 +706,8 @@ static void transfer_data(general_buffer_type recv,
 // Test speed of read/get
 void test_read(
     uint64_t rank, uint64_t nranks, uint64_t num_transfer_slots,
-    boost::random::mt19937& gen, boost::random::uniform_int_distribution<>& random_rank,
-    boost::random::uniform_int_distribution<>& random_slot,
+    std::mt19937& gen, std::uniform_int_distribution<>& random_rank,
+    std::uniform_int_distribution<>& random_slot,
     test_options &options
     )
 {
@@ -960,9 +960,9 @@ int hpx_main(boost::program_options::variables_map& vm)
         std::terminate();
     }
     //
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> random_rank(0, (int)nranks - 1);
-    boost::random::uniform_int_distribution<> random_slot(0,
+    std::mt19937 gen;
+    std::uniform_int_distribution<> random_rank(0, (int)nranks - 1);
+    std::uniform_int_distribution<> random_slot(0,
         (int)num_transfer_slots - 1);
     //
     ActiveFutures.reserve(nranks);

diff --git a/tests/performance/parallel_algorithms/local/benchmark_is_heap.cpp b/tests/performance/parallel_algorithms/local/benchmark_is_heap.cpp
@@ -14,15 +14,15 @@
 
 #include <boost/format.hpp>
 #include <boost/program_options.hpp>
-#include <boost/random.hpp>
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <vector>
-#include <algorithm>
-#include <limits>
 #include <iostream>
+#include <limits>
+#include <random>
 #include <string>
+#include <vector>
 
 ///////////////////////////////////////////////////////////////////////////////
 struct random_fill
@@ -37,8 +37,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 
     template <typename Archive>
     void serialize(Archive& ar, unsigned)

diff --git a/tests/performance/parallel_algorithms/local/benchmark_is_heap_until.cpp b/tests/performance/parallel_algorithms/local/benchmark_is_heap_until.cpp
@@ -14,15 +14,15 @@
 
 #include <boost/format.hpp>
 #include <boost/program_options.hpp>
-#include <boost/random.hpp>
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <vector>
-#include <algorithm>
-#include <limits>
 #include <iostream>
+#include <limits>
+#include <random>
 #include <string>
+#include <vector>
 
 ///////////////////////////////////////////////////////////////////////////////
 struct random_fill
@@ -37,8 +37,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 
     template <typename Archive>
     void serialize(Archive& ar, unsigned)

diff --git a/tests/performance/parallel_algorithms/local/benchmark_merge.cpp b/tests/performance/parallel_algorithms/local/benchmark_merge.cpp
@@ -14,14 +14,14 @@
 
 #include <boost/format.hpp>
 #include <boost/program_options.hpp>
-#include <boost/random.hpp>
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <vector>
-#include <algorithm>
 #include <iostream>
+#include <random>
 #include <string>
+#include <vector>
 
 #include "test_utils.hpp"
 
@@ -38,8 +38,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 };
 
 ///////////////////////////////////////////////////////////////////////////////

diff --git a/tests/performance/parallel_algorithms/local/benchmark_partition.cpp b/tests/performance/parallel_algorithms/local/benchmark_partition.cpp
@@ -15,15 +15,15 @@
 
 #include <boost/format.hpp>
 #include <boost/program_options.hpp>
-#include <boost/random.hpp>
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <vector>
-#include <algorithm>
-#include <limits>
 #include <iostream>
+#include <limits>
+#include <random>
 #include <string>
+#include <vector>
 
 #include "test_utils.hpp"
 
@@ -43,8 +43,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 
     template <typename Archive>
     void serialize(Archive& ar, unsigned)

diff --git a/tests/performance/parallel_algorithms/local/benchmark_partition_copy.cpp b/tests/performance/parallel_algorithms/local/benchmark_partition_copy.cpp
@@ -14,15 +14,15 @@
 
 #include <boost/format.hpp>
 #include <boost/program_options.hpp>
-#include <boost/random.hpp>
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <vector>
-#include <algorithm>
-#include <limits>
 #include <iostream>
+#include <limits>
+#include <random>
 #include <string>
+#include <vector>
 
 #include "test_utils.hpp"
 
@@ -39,8 +39,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 
     template <typename Archive>
     void serialize(Archive& ar, unsigned)

diff --git a/tests/performance/parallel_algorithms/local/benchmark_unique_copy.cpp b/tests/performance/parallel_algorithms/local/benchmark_unique_copy.cpp
@@ -14,14 +14,14 @@
 
 #include <boost/format.hpp>
 #include <boost/program_options.hpp>
-#include <boost/random.hpp>
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <vector>
-#include <algorithm>
 #include <iostream>
+#include <random>
 #include <string>
+#include <vector>
 
 #include "test_utils.hpp"
 
@@ -38,8 +38,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 };
 
 ///////////////////////////////////////////////////////////////////////////////

diff --git a/tests/regressions/components/partitioned_vector_2201.cpp b/tests/regressions/components/partitioned_vector_2201.cpp
@@ -9,9 +9,8 @@
 #include <hpx/include/parallel_generate.hpp>
 #include <hpx/include/partitioned_vector.hpp>
 
-#include <boost/random.hpp>
-
 #include <cstddef>
+#include <random>
 
 ///////////////////////////////////////////////////////////////////////////////
 // Define the vector types to be used.
@@ -30,8 +29,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 
     template <typename Archive>
     void serialize(Archive& ar, unsigned)

diff --git a/tests/regressions/lcos/future_hang_on_get_629.cpp b/tests/regressions/lcos/future_hang_on_get_629.cpp
@@ -11,11 +11,11 @@
 #include <hpx/include/runtime.hpp>
 #include <hpx/util/high_resolution_timer.hpp>
 
-#include <boost/random.hpp>
 #include <boost/format.hpp>
 
 #include <cstdint>
 #include <iostream>
+#include <random>
 #include <vector>
 
 using boost::program_options::variables_map;
@@ -60,10 +60,10 @@ double null_function(
   , std::uint64_t delay_iterations
     )
 {
-    boost::random::mt19937_64 prng(seed);
+    std::mt19937_64 prng(seed);
 
-    boost::random::uniform_real_distribution<double> v(0, 1.);
-    boost::random::uniform_smallint<std::uint8_t> s(0, 1);
+    std::uniform_real_distribution<double> v(0, 1.);
+    std::uniform_int_distribution<std::uint8_t> s(0, 1);
 
     double d = 0.;
 

diff --git a/tests/regressions/lcos/future_hang_on_then_629.cpp b/tests/regressions/lcos/future_hang_on_then_629.cpp
@@ -12,12 +12,12 @@
 #include <hpx/include/runtime.hpp>
 #include <hpx/util/high_resolution_timer.hpp>
 
-#include <boost/random.hpp>
 #include <boost/format.hpp>
 
 #include <cstdint>
 #include <functional>
 #include <iostream>
+#include <random>
 #include <vector>
 
 using boost::program_options::variables_map;
@@ -62,10 +62,10 @@ double null_function(
   , std::uint64_t delay_iterations
     )
 {
-    boost::random::mt19937_64 prng(seed);
+    std::mt19937_64 prng(seed);
 
-    boost::random::uniform_real_distribution<double> v(0, 1.);
-    boost::random::uniform_smallint<std::uint8_t> s(0, 1);
+    std::uniform_real_distribution<double> v(0, 1.);
+    std::uniform_int_distribution<std::uint8_t> s(0, 1);
 
     double d = 0.;
 

diff --git a/tests/regressions/lcos/future_hang_on_wait_with_callback_629.cpp b/tests/regressions/lcos/future_hang_on_wait_with_callback_629.cpp
@@ -12,11 +12,11 @@
 #include <hpx/include/runtime.hpp>
 #include <hpx/util/unwrap.hpp>
 
-#include <boost/random.hpp>
 #include <boost/format.hpp>
 
 #include <cstdint>
 #include <iostream>
+#include <random>
 #include <vector>
 
 using boost::program_options::variables_map;
@@ -61,10 +61,10 @@ double null_function(
   , std::uint64_t delay_iterations
     )
 {
-    boost::random::mt19937_64 prng(seed);
+    std::mt19937_64 prng(seed);
 
-    boost::random::uniform_real_distribution<double> v(0, 1.);
-    boost::random::uniform_smallint<std::uint8_t> s(0, 1);
+    std::uniform_real_distribution<double> v(0, 1.);
+    std::uniform_int_distribution<std::uint8_t> s(0, 1);
 
     double d = 0.;
 

diff --git a/tests/unit/parallel/algorithms/merge_tests.hpp b/tests/unit/parallel/algorithms/merge_tests.hpp
@@ -10,12 +10,11 @@
 #include <hpx/util/lightweight_test.hpp>
 #include <hpx/util/unused.hpp>
 
-#include <boost/random.hpp>
-
 #include <algorithm>
 #include <cstddef>
 #include <iostream>
 #include <numeric>
+#include <random>
 #include <string>
 #include <type_traits>
 #include <vector>
@@ -105,8 +104,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 };
 
 ///////////////////////////////////////////////////////////////////////////////

diff --git a/tests/unit/parallel/algorithms/partition_copy_tests.hpp b/tests/unit/parallel/algorithms/partition_copy_tests.hpp
@@ -10,12 +10,11 @@
 #include <hpx/util/lightweight_test.hpp>
 #include <hpx/util/unused.hpp>
 
-#include <boost/random.hpp>
-
 #include <algorithm>
 #include <cstddef>
 #include <iostream>
 #include <numeric>
+#include <random>
 #include <string>
 #include <vector>
 
@@ -87,8 +86,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 };
 
 ///////////////////////////////////////////////////////////////////////////////

diff --git a/tests/unit/parallel/algorithms/partition_tests.hpp b/tests/unit/parallel/algorithms/partition_tests.hpp
@@ -10,12 +10,11 @@
 #include <hpx/util/lightweight_test.hpp>
 #include <hpx/util/unused.hpp>
 
-#include <boost/random.hpp>
-
 #include <algorithm>
 #include <cstddef>
 #include <iostream>
 #include <numeric>
+#include <random>
 #include <string>
 #include <vector>
 
@@ -93,8 +92,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 };
 
 ///////////////////////////////////////////////////////////////////////////////

diff --git a/tests/unit/parallel/algorithms/reduce_by_key.cpp b/tests/unit/parallel/algorithms/reduce_by_key.cpp
@@ -9,8 +9,7 @@
 #include <hpx/parallel/algorithms/generate.hpp>
 #include <hpx/parallel/algorithms/reduce_by_key.hpp>
 //
-#include <boost/random/uniform_int_distribution.hpp>
-//
+#include <random>
 #include <utility>
 #include <vector>
 #ifdef EXTRA_DEBUG
@@ -83,12 +82,12 @@ void test_reduce_by_key1(ExPolicy && policy, Tkey, Tval, bool benchmark, const O
     std::vector<Tval> check_values;
 
     // use the default random engine and an uniform distribution for values
-    boost::random::mt19937 eng(static_cast<unsigned int>(std::rand()));
-    boost::random::uniform_real_distribution<double> distr(rnd_min, rnd_max);
+    std::mt19937 eng(static_cast<unsigned int>(std::rand()));
+    std::uniform_real_distribution<double> distr(rnd_min, rnd_max);
 
     // use the default random engine and an uniform distribution for keys
-    boost::random::mt19937 engk(static_cast<unsigned int>(std::rand()));
-    boost::random::uniform_real_distribution<double> distrk(0, 256);
+    std::mt19937 engk(static_cast<unsigned int>(std::rand()));
+    std::uniform_real_distribution<double> distrk(0, 256);
 
     // generate test data
     int keysize = 0;
@@ -180,12 +179,12 @@ void test_reduce_by_key_const(ExPolicy && policy, Tkey, Tval, bool benchmark,
     std::vector<Tval> check_values;
 
     // use the default random engine and an uniform distribution for values
-    boost::random::mt19937 eng(static_cast<unsigned int>(std::rand()));
-    boost::random::uniform_real_distribution<double> distr(rnd_min, rnd_max);
+    std::mt19937 eng(static_cast<unsigned int>(std::rand()));
+    std::uniform_real_distribution<double> distr(rnd_min, rnd_max);
 
     // use the default random engine and an uniform distribution for keys
-    boost::random::mt19937 engk(static_cast<unsigned int>(std::rand()));
-    boost::random::uniform_real_distribution<double> distrk(0, 256);
+    std::mt19937 engk(static_cast<unsigned int>(std::rand()));
+    std::uniform_real_distribution<double> distrk(0, 256);
 
     // generate test data
     int keysize = 0;
@@ -280,12 +279,12 @@ void test_reduce_by_key_async(ExPolicy && policy, Tkey, Tval, const Op &op,
     std::vector<Tval> check_values;
 
     // use the default random engine and an uniform distribution for values
-    boost::random::mt19937 eng(static_cast<unsigned int>(std::rand()));
-    boost::random::uniform_real_distribution<double> distr(rnd_min, rnd_max);
+    std::mt19937 eng(static_cast<unsigned int>(std::rand()));
+    std::uniform_real_distribution<double> distr(rnd_min, rnd_max);
 
     // use the default random engine and an uniform distribution for keys
-    boost::random::mt19937 engk(static_cast<unsigned int>(std::rand()));
-    boost::random::uniform_real_distribution<double> distrk(0, 256);
+    std::mt19937 engk(static_cast<unsigned int>(std::rand()));
+    std::uniform_real_distribution<double> distrk(0, 256);
 
     // generate test data
     int keysize = 0;

diff --git a/tests/unit/parallel/algorithms/sort_by_key.cpp b/tests/unit/parallel/algorithms/sort_by_key.cpp
@@ -9,8 +9,6 @@
 #include <hpx/parallel/algorithms/generate.hpp>
 #include <hpx/parallel/algorithms/sort_by_key.hpp>
 //
-#include <boost/random/uniform_int_distribution.hpp>
-//
 #include <iostream>
 #include <numeric>
 #include <string>

diff --git a/tests/unit/parallel/algorithms/sort_tests.hpp b/tests/unit/parallel/algorithms/sort_tests.hpp
@@ -29,9 +29,6 @@
 //
 #include "test_utils.hpp"
 
-#include <boost/random/mersenne_twister.hpp>
-#include <boost/random/uniform_real_distribution.hpp>
-
 #if !defined(HPX_SORT_TEST_SIZE_STRINGS)
 #define HPX_SORT_TEST_SIZE_STRINGS 1000000
 #endif
@@ -46,8 +43,8 @@ template <typename T>
 void rnd_fill(std::vector<T> &V, const T lower, const T upper, const T seed)
 {
     // use the default random engine and an uniform distribution
-    boost::random::mt19937 eng(static_cast<unsigned int>(seed));
-    boost::random::uniform_real_distribution<double> distr(lower, upper);
+    std::mt19937 eng(static_cast<unsigned int>(seed));
+    std::uniform_real_distribution<double> distr(lower, upper);
 
     for (auto &elem : V) {
         elem = static_cast<T>(distr(eng));

diff --git a/tests/unit/parallel/algorithms/unique_copy_tests.hpp b/tests/unit/parallel/algorithms/unique_copy_tests.hpp
@@ -10,12 +10,11 @@
 #include <hpx/util/lightweight_test.hpp>
 #include <hpx/util/unused.hpp>
 
-#include <boost/random.hpp>
-
 #include <algorithm>
 #include <cstddef>
 #include <iostream>
 #include <numeric>
+#include <random>
 #include <string>
 #include <type_traits>
 #include <vector>
@@ -103,8 +102,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 };
 
 ///////////////////////////////////////////////////////////////////////////////

diff --git a/tests/unit/parallel/container_algorithms/merge_range.cpp b/tests/unit/parallel/container_algorithms/merge_range.cpp
@@ -8,13 +8,12 @@
 #include <hpx/include/parallel_merge.hpp>
 #include <hpx/util/lightweight_test.hpp>
 
-#include <boost/random.hpp>
-
 #include <algorithm>
 #include <cstddef>
 #include <iostream>
 #include <iterator>
 #include <numeric>
+#include <random>
 #include <string>
 #include <vector>
 
@@ -68,8 +67,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 };
 
 ////////////////////////////////////////////////////////////////////////////

diff --git a/tests/unit/parallel/container_algorithms/partition_copy_range.cpp b/tests/unit/parallel/container_algorithms/partition_copy_range.cpp
@@ -9,13 +9,12 @@
 #include <hpx/util/lightweight_test.hpp>
 #include <hpx/util/unused.hpp>
 
-#include <boost/random.hpp>
-
 #include <algorithm>
 #include <cstddef>
 #include <iostream>
 #include <iterator>
 #include <numeric>
+#include <random>
 #include <string>
 #include <vector>
 
@@ -71,8 +70,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 };
 
 ////////////////////////////////////////////////////////////////////////////

diff --git a/tests/unit/parallel/container_algorithms/partition_range.cpp b/tests/unit/parallel/container_algorithms/partition_range.cpp
@@ -9,13 +9,12 @@
 #include <hpx/util/lightweight_test.hpp>
 #include <hpx/util/unused.hpp>
 
-#include <boost/random.hpp>
-
 #include <algorithm>
 #include <cstddef>
 #include <iostream>
 #include <iterator>
 #include <numeric>
+#include <random>
 #include <string>
 #include <vector>
 
@@ -77,8 +76,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 };
 
 ////////////////////////////////////////////////////////////////////////////

diff --git a/tests/unit/parallel/container_algorithms/sort_range_tests.hpp b/tests/unit/parallel/container_algorithms/sort_range_tests.hpp
@@ -30,9 +30,6 @@
 //
 #include "test_utils.hpp"
 
-#include <boost/random/mersenne_twister.hpp>
-#include <boost/random/uniform_real_distribution.hpp>
-
 #if !defined(HPX_SORT_TEST_SIZE_STRINGS)
 #define HPX_SORT_TEST_SIZE_STRINGS 1000000
 #endif
@@ -47,8 +44,8 @@ template <typename T>
 void rnd_fill(std::vector<T> &V, const T lower, const T upper, const T seed)
 {
     // use the default random engine and an uniform distribution
-    boost::random::mt19937 eng(static_cast<unsigned int>(seed));
-    boost::random::uniform_real_distribution<double> distr(lower, upper);
+    std::mt19937 eng(static_cast<unsigned int>(seed));
+    std::uniform_real_distribution<double> distr(lower, upper);
 
     for (auto &elem : V) {
         elem = static_cast<T>(distr(eng));

diff --git a/tests/unit/parallel/container_algorithms/unique_copy_range.cpp b/tests/unit/parallel/container_algorithms/unique_copy_range.cpp
@@ -8,13 +8,12 @@
 #include <hpx/include/parallel_unique.hpp>
 #include <hpx/util/lightweight_test.hpp>
 
-#include <boost/random.hpp>
-
 #include <algorithm>
 #include <cstddef>
 #include <iostream>
 #include <iterator>
 #include <numeric>
+#include <random>
 #include <string>
 #include <vector>
 
@@ -70,8 +69,8 @@ struct random_fill
         return dist(gen);
     }
 
-    boost::random::mt19937 gen;
-    boost::random::uniform_int_distribution<> dist;
+    std::mt19937 gen;
+    std::uniform_int_distribution<> dist;
 };
 
 ////////////////////////////////////////////////////////////////////////////

diff --git a/tools/inspect/deprecated_include_check.cpp b/tools/inspect/deprecated_include_check.cpp
@@ -46,6 +46,8 @@ namespace boost
       { "boost/preprocessor/cat\\.hpp", "hpx/util/detail/pp/cat.hpp" },
       { "boost/preprocessor/stringize\\.hpp", "hpx/util/detail/pp/stringize.hpp" },
       { "boost/atomic\\.hpp", "atomic" },
+      { "boost/nondet_random.hpp", "random" },
+      { "boost/random/([^\\s]*)\\.hpp", "random" },
       { nullptr, nullptr }
     };
 

diff --git a/tools/inspect/deprecated_name_check.cpp b/tools/inspect/deprecated_name_check.cpp
@@ -87,6 +87,7 @@ namespace boost
       { "(\\bboost\\s*::\\s*atomic\\b)", "std::atomic" },
       { "(\\bboost\\s*::\\s*memory_order_((relaxed)|(acquire)|(release)|"
         "(acq_rel)|(seq_cst))\\b)", "std::memory_order_\\2" },
+      { "(\\bboost\\s*::\\s*random\\s*::\\s*([^\\s]*)\\b)", "std::\\2" },
       /////////////////////////////////////////////////////////////////////////
       { "((\\bhpx::\\b)?\\btraits\\s*::\\bis_callable\\b)", "\\2traits::is_invocable[_r]" },
       { "((\\bhpx::\\b)?\\butil\\s*::\\bresult_of\\b)", "\\2util::invoke_result" },