This is a Kotlin Multiplatform line-by-line transliteration port of rust-random/rand.

Original Project: This port is based on rust-random/rand. All design credit and project intent belong to the upstream authors; this repository is a faithful port to Kotlin Multiplatform with no behavioural changes intended.

This is an in-progress port. The goal is feature parity with the upstream Rust crate while providing a native Kotlin Multiplatform API. Every Kotlin file carries a // port-lint: source <path> header naming its upstream Rust counterpart so the AST-distance tool can track provenance.

The text below is reproduced and lightly edited from https://github.com/rust-random/rand. It is the upstream project's own description and remains under the upstream authors' authorship; links have been rewritten to absolute upstream URLs so they continue to resolve from this repository.

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: chacha20, rand_xoshiro, rand_pcg, rand_sfc, rand_seeder, 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 (docs.rs)

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

• Version 0.10 was released in February 2026.

See the CHANGELOG or Upgrade Guide for more details.

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; a significant portion of sequence and distribution functionality requires this
• sys_rng enables rand::rngs::SysRng (uses the getrandom crate)
• std_rng enables rand::rngs::StdRng (uses the chacha20 crate)
• thread_rng (implies std, std_rng, sys_rng) enables rand::rngs::ThreadRng and rand::rng()

Optionally, the following dependencies can be enabled:

• chacha enables rand::rngs::{ChaCha8Rng, ChaCha12Rng, ChaCha20Rng} (uses the chacha20 crate)

Additionally, these features configure Rand:

• simd_support (experimental) enables sampling of SIMD values (uniformly random SIMD integers and floats). Since std::simd is not yet stable this feature requires nightly Rust and may cause build failures.

• unbiased use unbiased sampling for algorithms supporting this option: Uniform distribution.

  (By default, bias affecting no more than one in 2^48 samples is accepted.)

  Note: enabling this option is expected to affect reproducibility of results.

Achieving reproducible results requires not only deterministic algorithms with fixed inputs but also a commitment to stability of algorithms and some platform-specific considerations. A subset of rand does aim to support reproducibility; read more about this in the book: Portability.

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 sys_rng feature may be disabled.

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.

dependencies {
    implementation("io.github.kotlinmania:rand-kotlin:0.2.0")
}

./gradlew build
./gradlew test

• macOS arm64
• Linux x64
• Windows mingw-x64
• iOS arm64 / simulator-arm64 (Swift export + XCFramework)
• JS (browser + Node.js)
• Wasm-JS (browser + Node.js)
• Android (API 24+)

See AGENTS.md and CLAUDE.md for translator discipline, port-lint header convention, and Rust → Kotlin idiom mapping.

This Kotlin port is distributed under the same MIT license as the upstream rust-random/rand. See LICENSE (and any sibling LICENSE-* / NOTICE files mirrored from upstream) for the full text.

Original work copyrighted by the rand authors.
Kotlin port: Copyright (c) 2026 Sydney Renee and The Solace Project.

Thanks to the rust-random/rand maintainers and contributors for the original Rust implementation. This port reproduces their work in Kotlin Multiplatform; bug reports about upstream design or behavior should go to the upstream repository.