Debug vs. Release Builds

Rust separates compilation into two primary build profiles with radically different performance characteristics: Debug builds (cargo build / [profile.dev]), which prioritize sub-second compilation speed and runtime safety checks, and Release builds (cargo build --release / [profile.release]), which apply aggressive whole-function and cross-module optimizations to generate machine code that runs 10x to 100x faster.

Same Rust Source (`iter().map(...).filter(...).sum()`)
       |
       +--- `cargo build` (`opt-level = 0`, Debug):
       |    - Every iterator `.next()` and closure call is a real stack-frame call
       |    - Every `+` checks for arithmetic overflow and branches to panic
       |    - Every variable lives on the stack (`alloca`) for debugger inspection
       |    ---> ~500 ms for 100M elements
       |
       +--- `cargo build --release` (`opt-level = 3`, Release):
            - Iterator adapter chain inlined & fused into a single register loop
            - Auto-vectorized into 256-bit AVX2 / 128-bit NEON SIMD instructions
            - Bounds checks and dead stores eliminated
            ---> ~8 ms for 100M elements!

Comparing Debug and Release Profile Behavior

Why Benchmarking a Debug Build Produces Misleading Results

Because Rust relies heavily on zero-cost abstractions—generics, trait methods, iterator adapters (map, filter, zip), and newtype wrappers—a debug build (opt-level = 0) leaves every tiny abstraction layer as an un-inlined function call.

Measuring performance on a debug build measures the overhead of un-inlined abstraction layers rather than the actual algorithm! Always benchmark and profile with --release (or cargo bench).

pub fn sum_of_squares_even(limit: u64) -> u64 {
    (0..limit)
        .filter(|&x| x % 2 == 0)
        .map(|x| x.wrapping_mul(x))
        .fold(0u64, u64::wrapping_add)
}

fn main() {
    let is_debug = cfg!(debug_assertions);
    let result = sum_of_squares_even(1_000);

    println!("Debug assertions active: {is_debug}");
    println!("Sum of even squares < 1000: {result}");
}

Debug assertions active: true
Sum of even squares < 1000: 166167000

Enabling Overflow Checks or Debug Symbols in Release Builds

If you want release speed while still catching accidental arithmetic overflows or retaining line-table symbols for production CPU profilers (perf, samply, Instruments), customize [profile.release] in Cargo.toml:

[profile.release]
overflow-checks = true       # ~1-2% overhead; prevents silent integer wrap bugs
debug = "line-tables-only"   # Enables function/line attribution in CPU flamegraphs