anyhow

Overview

anyhow is a Rust library designed to simplify error handling within applications. Unlike libraries that focus on defining highly specific, domain-driven error types, anyhow provides a generic, flexible error type that excels in scenarios where detailed error enumeration isn't the primary concern. Its core strength lies in its ability to facilitate easy error propagation and attach contextual information, making debugging more efficient without imposing significant boilerplate.

The library is particularly well-suited for application development, scripting, and rapid prototyping in Rust. Developers can use anyhow::Error as a return type from functions that might fail, leveraging Rust's ? operator for concise error propagation. This approach minimizes the overhead of defining custom enum Error types for every module or function, allowing developers to focus on application logic rather than intricate error type hierarchies. When an error occurs, anyhow allows for chaining additional context messages, providing a clear breadcrumb trail for understanding the failure point and its cause. This contrasts with more formal error handling approaches, like those often advocated for in library design, where explicit error types are crucial for consumers to programmatically react to specific failure modes.

anyhow is built on top of Rust's standard library std::error::Error trait, ensuring compatibility with the broader Rust error ecosystem. It integrates seamlessly with other crates that implement this trait, enabling a unified approach to managing errors originating from various dependencies. This interoperability means that errors from libraries like reqwest or tokio can be easily converted into an anyhow::Error, allowing applications to handle external failures with the same ergonomic patterns. Its design philosophy emphasizes developer experience and simplicity, making it a popular choice for projects where the primary goal is to get an application working reliably with clear error messages, rather than building a comprehensive API for error introspection and recovery. For developers new to Rust or those working on projects with less stringent requirements for detailed error recovery, anyhow offers a gentle introduction to robust error handling practices in the language.

Key features

• Generic Error Type: Provides a single anyhow::Error type that can represent any error, simplifying function signatures and reducing the need for custom error enumerations (docs.rs).
• Easy Error Propagation: Works seamlessly with Rust's ? operator for concise and ergonomic error propagation through function calls.
• Contextual Error Messages: Allows developers to attach descriptive context messages to errors as they propagate, providing a detailed trail for debugging.
• Backtrace Support: Captures and displays a stack backtrace for errors by default in development builds, aiding in pinpointing the source of panics or failures.
• std::error::Error Compatibility: Interoperates with all types that implement the std::error::Error trait, ensuring broad compatibility with the Rust ecosystem.
• Minimal Boilerplate: Reduces the amount of code required for error handling, particularly when compared to manually defining and converting between numerous custom error types.
• Dynamic Error Handling: Enables handling of errors whose concrete type is not known at compile time, useful for scenarios involving third-party libraries or dynamic behaviors.

Pricing

As of May 6, 2026, anyhow is distributed under the Apache 2.0 and MIT licenses.

Common integrations

anyhow's design, based on the std::error::Error trait, allows it to integrate naturally with most Rust libraries and frameworks. Its strength lies in its ability to consume and re-wrap errors from diverse sources, providing a unified handling mechanism within an application.

• Asynchronous Runtimes (e.g., Tokio): anyhow is frequently used in async Rust applications to manage errors propagated from asynchronous operations, such as network requests or file I/O Tokio error handling tutorial.
• Web Frameworks (e.g., Axum, Actix-Web): For web applications, anyhow helps in consistently handling errors that occur during request processing, database interactions, or external API calls.
• File I/O Libraries: Errors from file operations (e.g., std::fs, serde_json for parsing configuration files) can be easily converted to anyhow::Error and enriched with contextual information.
• Database Connectors (e.g., SQLx, Diesel): Errors arising from database queries, connection issues, or ORM operations can be managed with anyhow for consistent application-level reporting.
• Serialization/Deserialization Libraries (e.g., Serde): Parsing errors from JSON, YAML, or other formats processed by Serde can be wrapped in anyhow::Error to provide clearer diagnostics.

Alternatives

• thiserror: A macro for simplifying the implementation of std::error::Error, primarily for libraries that need to define specific error types.
• error-chain: An older, but still used, crate for ergonomic error handling, offering similar features to anyhow and thiserror combined, but with a different macro-based syntax.
• eyre: A drop-in replacement for anyhow, offering similar ergonomics but with a focus on richer error reporting and integration with the color-eyre crate for colored output.
• Standard Library Error Handling: Rust's native Result<T, E> enum combined with custom enum Error types, offering explicit error handling without external crates. This approach is often favored for robust library design.

Getting started

To begin using anyhow, add it to your Cargo.toml file:

[dependencies]
anyhow = "1.0"

Here's a basic example demonstrating how to use anyhow::Result<T> (a type alias for Result<T, anyhow::Error>) and attach context to an error:

use anyhow::{Context, Result};
use std::fs;

fn read_config_file(path: &str) -> Result<String> {
    let config_content = fs::read_to_string(path)
        .with_context(|| format!("Failed to read config file from {}", path))?;
    Ok(config_content)
}

fn parse_and_process_config(filename: &str) -> Result<()> {
    let content = read_config_file(filename)
        .context("Could not load application configuration")?;

    // Simulate parsing and potential processing errors
    if content.contains("invalid_setting") {
        anyhow::bail!("Configuration contains an invalid setting: 'invalid_setting'");
    }

    println!("Successfully loaded and processed config:\n{}", content);
    Ok(())
}

fn main() -> Result<()> {
    // Create a dummy config file for demonstration
    fs::write("app_config.txt", "setting1=value1\nsetting2=value2")
        .context("Failed to write dummy config file")?;

    // Test a successful run
    println!("--- Successful Run ---");
    if let Err(e) = parse_and_process_config("app_config.txt") {
        eprintln!("Error: {:?}", e);
    }

    // Test a file not found error
    println!("\n--- File Not Found Error ---");
    if let Err(e) = parse_and_process_config("non_existent.txt") {
        eprintln!("Error: {:?}", e);
    }

    // Test a parsing error (simulated)
    fs::write("bad_config.txt", "setting1=value1\ninvalid_setting=true")
        .context("Failed to write bad config file")?;

    println!("\n--- Invalid Setting Error ---");
    if let Err(e) = parse_and_process_config("bad_config.txt") {
        eprintln!("Error: {:?}", e);
    }

    Ok(())
}

When you run this code, you'll observe how errors are propagated and how the attached context provides clear messages about what went wrong and where. For instance, a file not found error will produce a message incorporating the filename and the context added by read_config_file.