Rand

Rand is a set of crates supporting (pseudo-)random generators:

• Built over a standard RNG trait: rand_core::RngCore
• With fast implementations of both strong and
  small generators: rand::rngs, and more RNGs: rand_chacha, rand_xoshiro, rand_pcg, rngs repo
• rand::rng is an asymptotically-fast, automatically-seeded and reasonably strong generator available on all std targets
• Direct support for seeding generators from the getrandom crate

With broad support for random value generation and random processes:

• StandardUniform random value sampling,
  Uniform-ranged value sampling
  and more
• Samplers for a large number of non-uniform random number distributions via our own
  rand_distr and via
  the statrs
• Random processes (mostly choose and shuffle) via rand::seq traits

All with:

• Portably reproducible output
• #[no_std] compatibility (partial)
• Many performance optimisations thanks to contributions from the wide
  user-base

Rand is not:

• Small (LoC). Most low-level crates are small, but the higher-level rand
  and rand_distr each contain a lot of functionality.
• Simple (implementation). We have a strong focus on correctness, speed and flexibility, but
  not simplicity. If you prefer a small-and-simple library, there are
  alternatives including fastrand
  and oorandom.
• Primarily a cryptographic library. rand does provide some generators which
  aim to support unpredictable value generation under certain constraints;
  see SECURITY.md for details.
  Users are expected to determine for themselves
  whether rand's functionality meets their own security requirements.

Documentation:

• The Rust Rand Book
• API reference (master branch)
• API reference (docs.rs)

Versions

Rand is mature (suitable for general usage, with infrequent breaking releases
which minimise breakage) but not yet at 1.0. Current versions are:

• Version 0.9 was released in January 2025.

See the CHANGELOG or Upgrade Guide for more details.

Crate Features

Rand is built with these features enabled by default:

• std enables functionality dependent on the std lib
• alloc (implied by std) enables functionality requiring an allocator
• os_rng (implied by std) enables rngs::OsRng, using the getrandom crate
• std_rng enables inclusion of StdRng, ThreadRng

Optionally, the following dependencies can be enabled:

• log enables logging via log

Additionally, these features configure Rand:

• small_rng enables inclusion of the SmallRng PRNG
• nightly includes some additions requiring nightly Rust
• simd_support (experimental) enables sampling of SIMD values
  (uniformly random SIMD integers and floats), requiring nightly Rust

Note that nightly features are not stable and therefore not all library and
compiler versions will be compatible. This is especially true of Rand's
experimental simd_support feature.

Rand supports limited functionality in no_std mode (enabled via
default-features = false). In this case, OsRng and from_os_rng are
unavailable (unless os_rng is enabled), large parts of seq are
unavailable (unless alloc is enabled), and ThreadRng is unavailable.

Portability and platform support

Many (but not all) algorithms are intended to have reproducible output. Read more in the book: Portability.

The Rand library supports a variety of CPU architectures. Platform integration is outsourced to getrandom.

WebAssembly support

The WASI and Emscripten
targets are directly supported. The wasm32-unknown-unknown target is not
automatically supported. To enable support for this target, refer to the
getrandom documentation for WebAssembly.
Alternatively, the os_rng feature may be disabled.

License

Rand is distributed under the terms of both the MIT license and the
Apache License (Version 2.0).

See LICENSE-APACHE and LICENSE-MIT, and
COPYRIGHT for details.