Rayon — Data Parallelism Library for Rust

What it is

Rayon is the standard data parallelism library for Rust. It provides parallel iterators that mirror the standard Rust iterator API but distribute work across all available CPU cores automatically. The key advantage is that Rust's type system guarantees no data races at compile time, making parallelism safe by construction.

Rayon targets Rust developers who need to speed up CPU-bound computations without manual thread management. It is used by ripgrep, Polars, Servo, and many other performance-critical Rust projects.

How it saves time or tokens

Rayon's API requires minimal code changes: replace .iter() with .par_iter() or .into_iter() with .into_par_iter(). The library handles thread pool creation, work-stealing scheduling, and load balancing internally. You get multi-core performance without writing thread synchronization code or worrying about data races.

How to use

1. Add Rayon to your project: cargo add rayon.
2. Import the prelude: use rayon::prelude::*.
3. Replace sequential iterator calls with their parallel equivalents (.par_iter(), .par_sort(), .par_chunks()).

Example

use rayon::prelude::*;

fn main() {
    // Sequential: single-core
    let sum: i64 = (0..1_000_000).map(|x| x * x).sum();

    // Parallel: all cores, one-line change
    let par_sum: i64 = (0..1_000_000)
        .into_par_iter()
        .map(|x| x * x)
        .sum();

    // Parallel sort
    let mut data = vec![5, 2, 8, 1, 9, 3];
    data.par_sort();

    // Parallel string processing
    let results: Vec<String> = vec!["hello", "world", "rust"]
        .par_iter()
        .map(|s| s.to_uppercase())
        .collect();
}

Related on TokRepo

• AI Tools for Coding -- explore coding tools and libraries for performance-critical development
• Featured Workflows -- browse top-rated developer tools and utilities

Common pitfalls

• Not all workloads benefit from parallelism; very short iterations may run slower due to thread pool overhead. Benchmark before and after.
• Rayon's global thread pool defaults to one thread per CPU core; customize with rayon::ThreadPoolBuilder if you need to limit concurrency.
• Parallel iterators require Send + Sync bounds on the data; closures that capture non-thread-safe types will not compile.