# What Is the Default Parallelism for Checking Rustlings Exercises?

> Discover the default parallelism for checking Rustlings exercises. Rustlings uses 8 parallel threads by default for efficient exercise verification.

- Repository: [The Rust Programming Language/rustlings](https://github.com/rust-lang/rustlings)
- Tags: internals
- Published: 2026-03-05

---

**Rustlings uses 8 parallel threads as the default degree of parallelism when checking exercises, falling back to this constant when the system cannot detect available CPU cores.**

When working with the `rust-lang/rustlings` repository to learn Rust, understanding how the tool utilizes system resources can help you optimize your development workflow. The default parallelism for checking Rustlings exercises is hardcoded into the application state, ensuring consistent performance across different environments while providing a fallback mechanism for hardware detection failures.

## Where the Default Parallelism Is Defined

The constant that controls default thread usage is located in [`src/app_state.rs`](https://github.com/rust-lang/rustlings/blob/main/src/app_state.rs) at line 27. Here, the Rustlings codebase explicitly defines the baseline concurrency level:

```rust
const DEFAULT_CHECK_PARALLELISM: usize = 8;

```

This value represents the number of exercises that Rustlings will attempt to check simultaneously when running the verification process. The choice of 8 threads provides a balance between execution speed and system resource consumption on typical development machines.

## How Rustlings Determines Thread Count at Runtime

While the default is set to 8, Rustlings attempts to detect your system's actual hardware capabilities before falling back to the constant. In [`src/app_state.rs`](https://github.com/rust-lang/rustlings/blob/main/src/app_state.rs) at lines 415-417, the application queries available CPU cores using Rust's standard library:

```rust
let n_threads = thread::available_parallelism()
    .map_or(DEFAULT_CHECK_PARALLELISM, |count| count.get());

```

This implementation uses `thread::available_parallelism()` to retrieve the number of hardware threads available on the host machine. If this system call succeeds, Rustlings uses the detected core count for checking exercises. However, if the call fails or returns an error, the code immediately falls back to `DEFAULT_CHECK_PARALLELISM` (8 threads) to ensure the checking process can still proceed.

## Customizing the Check Parallelism

If you need to adjust the concurrency level for specific hardware constraints or performance testing, you can modify the default value in the source code. To change the parallelism constant, edit the definition in [`src/app_state.rs`](https://github.com/rust-lang/rustlings/blob/main/src/app_state.rs):

```rust
// Change from 8 to your desired thread count
const DEFAULT_CHECK_PARALLELISM: usize = 4;  // Use 4 threads instead of 8

```

For temporary runtime adjustments without modifying source constants, you would need to patch the logic at lines 415-417 to accept an environment variable or command-line argument, though this requires rebuilding the Rustlings binary from your modified source.

## Summary

- **Default value**: Rustlings uses **8 parallel threads** defined by `DEFAULT_CHECK_PARALLELISM` in `src/app_state.rs:27`
- **Hardware detection**: The tool attempts to use `thread::available_parallelism()` to detect actual CPU cores before falling back to the default
- **Fallback mechanism**: If system hardware detection fails, Rustlings automatically defaults to 8 threads to ensure checking continues
- **Customization**: You can modify the constant in [`src/app_state.rs`](https://github.com/rust-lang/rustlings/blob/main/src/app_state.rs) to adjust parallelism for your specific hardware or performance requirements

## Frequently Asked Questions

### How does Rustlings decide how many threads to use when checking exercises?

Rustlings first attempts to query your system's hardware using `thread::available_parallelism()` at `src/app_state.rs:415-417`. If this call succeeds, it uses the detected number of CPU cores. If the system call fails or returns an error, it falls back to the `DEFAULT_CHECK_PARALLELISM` constant of 8 threads defined at line 27 of the same file.

### Can I change the default 8-thread parallelism without editing source code?

Currently, the Rustlings codebase does not expose a command-line flag or environment variable to override the default parallelism. To change the thread count, you must modify the `DEFAULT_CHECK_PARALLELISM` constant in [`src/app_state.rs`](https://github.com/rust-lang/rustlings/blob/main/src/app_state.rs) and rebuild the binary from source. The constant is used directly in the fallback logic and influences the maximum concurrency during exercise verification.

### Why does Rustlings use 8 threads as the default instead of detecting CPU cores?

While Rustlings does attempt to detect CPU cores using `thread::available_parallelism()`, the 8-thread default serves as a reliable fallback when hardware detection fails or is unavailable on certain platforms. This ensures consistent behavior across diverse environments—including virtual machines, containers, or restricted systems where hardware introspection might be limited—while providing reasonable performance on typical development machines with 4-16 logical cores.