What are the safety invariants of unsafe

Unsafe Rust requires the programmer to manually guarantee memory safety, valid pointers, and single-threaded access to mutable statics since the compiler skips these checks.

The safety invariants of unsafe require you to manually guarantee that raw pointers are valid, mutable statics are accessed by only one thread, and no undefined behavior occurs. You must uphold these guarantees yourself because the compiler skips its usual safety checks inside unsafe blocks.

static mut COUNTER: u32 = 0;

/// SAFETY: Calling this from more than a single thread at a time is undefined
/// behavior, so you *must* guarantee you only call it from a single thread at
/// a time.
unsafe fn add_to_count(inc: u32) {
    unsafe {
        COUNTER += inc;
    }
}

fn main() {
    unsafe {
        // SAFETY: This is only called from a single thread in `main`.
        add_to_count(3);
        println!("COUNTER: {}", *(&raw const COUNTER));
    }
}

The unsafe keyword tells the compiler to trust you and skip its automatic safety checks. You must promise that your code won't crash or corrupt memory, such as ensuring only one thread touches a shared variable at a time. Think of it as turning off the guardrails on a highway; you can drive faster, but if you make a mistake, there is nothing to stop you from crashing.