rand

Rand is a Rust library for random number generation, providing a trait-based foundation for pseudo-random and cryptographically-secure generators alongside a rich toolkit for sampling values, ranges, distributions, and sequences. Built on the rand_core RngCore trait, it ships fast, automatically-seeded generators such as ThreadRng and StdRng plus small PRNGs, and layers on ergonomic helpers like rand::random() and random_range().

It supports uniform and non-uniform distributions, weighted sampling, shuffling and choosing from slices, and portable reproducible output, with #[no_std] compatibility and optional Serde support. Rand is the most widely adopted randomness crate in the Rust ecosystem, downloaded well over a billion times.

What You Get

• Automatically-seeded, reasonably strong generators (ThreadRng, StdRng) plus fast small PRNGs, all built over the rand_core RngCore trait
• Uniform and ranged value sampling via StandardUniform and Uniform, plus a large set of non-uniform distributions
• Sequence utilities for shuffling, choosing, and weighted selection from slices and iterators
• no_std compatibility, optional Serde support, and portably reproducible output for deterministic use cases

Common Use Cases

• Generating random numbers, booleans, and values of common types with a single rand::random() call
• Sampling from a numeric range or a statistical distribution for simulations and Monte Carlo methods
• Shuffling collections or picking random and weighted elements from slices in games, tests, and tooling

Under The Hood

Architecture

Rand is layered on top of the separate rand_core crate, which defines the RngCore, Rng, and SeedableRng traits re-exported from src/lib.rs. The crate is organized into focused modules: src/rngs/ supplies concrete generators (StdRng backed by ChaCha in std.rs, ThreadRng in thread.rs, SmallRng and the xoshiro128/256++ PRNGs), src/distr/ holds the sampling layer (StandardUniform, Uniform with per-type uniform_int/uniform_float back-ends, Bernoulli, and weighted indices), and src/seq/ implements sequence operations like shuffle and choose via a coin-flipper and increasing-uniform index sampler. Top-level convenience functions (rand::random, random_range, rng) in src/rng.rs and a prelude tie the layers together for ergonomic use.

Tech Stack

Written in Rust on the 2024 edition with an MSRV of 1.85, the crate is #[no_std] by default with alloc and std opt-in feature layers. Runtime dependencies are minimal: rand_core for the trait foundation, chacha20 for the cryptographic StdRng, and getrandom for OS entropy seeding, with serde available behind a feature. A granular feature matrix (std_rng, sys_rng, thread_rng, chacha, simd_support, unbiased) lets consumers trade functionality against footprint. Building and testing use standard Cargo, with dev-dependencies including rand_pcg, rayon, and serde_json.

Code Quality

Code quality is high and correctness-focused. The crate enforces #![deny(missing_docs)], missing_debug_implementations, and undocumented_unsafe_blocks, and carries roughly 107 unit-test functions across ~20 files plus integration tests (tests/fill.rs), doctests on public APIs, and a dedicated benches/ suite. A clippy.toml and CI workflows back consistent linting. Naming follows idiomatic Rust conventions and unsafe blocks are documented, reflecting the project’s stated priority of correctness and speed over simplicity.

API Design

The public API is deliberately ergonomic: newcomers can call rand::random() or rand::random_range(a..b) with zero setup, while power users compose over the Rng trait and explicit generators. A prelude module surfaces the common imports, distributions read fluently (Uniform::new, StandardUniform), and sequence helpers hang off iterator/slice extension traits. Documentation is exceptional, spanning inline docs enforced by deny(missing_docs), published docs.rs reference, and the dedicated Rust Rand Book with a quick-start guide, which keeps the learning curve manageable despite the domain’s inherent depth.