What Is the 'static Lifetime in Rust?

Memory/Lifetimes
2026-04-17T16:32:01+00:00
The `'static` lifetime in Rust signifies that a reference is valid for the entire duration of the program's execution, meaning it never goes out of scope.

The 'static lifetime in Rust signifies that a reference is valid for the entire duration of the program's execution, meaning it never goes out of scope. It is the longest possible lifetime and is automatically assigned to string literals and any data that is effectively constant or owned by the program itself.

You encounter 'static most often when working with string literals, which are embedded directly into the binary, or when a function needs to return a reference that outlives the function call without borrowing from its arguments. If a generic function requires a 'static lifetime, it is demanding data that will not be dropped until the program terminates.

Here is a practical example showing how string literals are 'static by default, while local variables are not:

fn main() {
    // String literals are 'static because they live in the binary
    let s: &'static str = "Hello, world!"; 

    // Local variables have a limited scope and cannot be 'static
    let local = String::from("temporary");
    // let r: &'static str = &local; // ERROR: local does not live long enough

    // You can explicitly annotate the 'static lifetime if needed
    let explicit_static: &'static str = "Another literal";
    
    println!("Static: {}", s);
    println!("Explicit: {}", explicit_static);
}

When writing generic functions, you might need to constrain a type parameter to 'static if you are storing references in a global context or sending them across threads without owning the data. For instance, a function accepting a reference that must live forever would look like this:

fn process_data(data: &'static str) {
    // This function guarantees 'data' is valid for the whole program
    println!("Processing: {}", data);
}

fn main() {
    let literal = "safe";
    process_data(literal); // Works: literal is 'static

    let owned = String::from("unsafe");
    // process_data(&owned); // ERROR: owned is dropped at end of main
}

Be careful not to overuse 'static constraints. Requiring 'static on a function parameter forces the caller to provide data that lives forever, which often leads to awkward workarounds like forcing users to use Box::leak or string literals instead of normal variables. Only use it when the data truly must persist for the entire program lifetime, such as configuration constants or data stored in global statics. If you need to share data across threads or scopes, consider using Rc, Arc, or cloning the data instead of forcing a 'static reference.