awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
dtolnay avatar

dtolnay/anyhow

0
View on GitHub↗
6,569 stars·212 forks·Rust·Apache-2.0·18 views

Anyhow

Anyhow is a dynamic error handling library for Rust applications that provides a flexible error container using type erasure. It serves as a tool for simplifying error signatures by wrapping diverse failure types into a single object, allowing for the propagation of any error that implements the standard error trait without requiring a custom enumeration for every function.

The project functions as an error context provider by attaching high-level diagnostic information and recording execution stack traces at the point of failure. It enables the recovery of concrete error implementations from generic containers through downcasting and supports the generation of ad hoc errors using string interpolation.

Features

  • Error Type Unifications - Provides a dynamic error container that wraps diverse failure types into a single trait object to simplify function signatures.
  • Dynamic Error Containers - Provides a trait-object based wrapper for managing diverse error types without custom enums.
  • Error Handling - Implements a dynamic error type for capturing and propagating any Rust error implementing the standard trait.
  • Type-Erasure Error Containers - Wraps diverse error types into a single dynamic type using trait-object based erasure.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
  • Error Contextualization - Enriches errors with source location and high-level diagnostic metadata.
  • Heap-Allocated Error Containers - Uses heap allocation to allow diverse error types to be handled by a single uniform container.
  • Standardized Error Traits - Manages disparate error types through a dynamic trait object implementing the standard Error trait.
  • Error Propagation Systems - Simplifies the propagation of various error types without requiring exhaustive custom enums.
  • Error Wrapping - Nests errors within a recursive structure to append high-level diagnostic context.
  • Error Object Downcasters - Enables casting a generic error trait object back to its original concrete type.
  • Rust Application Debugging - Captures backtraces and diagnostic information to identify the cause and location of failures.
  • Ad Hoc Error Generation - Provides a mechanism to generate formatted error messages without defining a custom type.
  • Runtime Failure Backtrace Capturers - Automatically captures the execution stack at the point of failure for debugging.
  • Ad Hoc Error Generation - Generates one-off error messages using string interpolation for rapid failure reporting.
  • Star history

    Star history chart for dtolnay/anyhowStar history chart for dtolnay/anyhow

    How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.

    Frequently asked questions

    What does dtolnay/anyhow do?

    Anyhow is a dynamic error handling library for Rust applications that provides a flexible error container using type erasure. It serves as a tool for simplifying error signatures by wrapping diverse failure types into a single object, allowing for the propagation of any error that implements the standard error trait without requiring a custom enumeration for every function.

    What are the main features of dtolnay/anyhow?

    The main features of dtolnay/anyhow are: Error Type Unifications, Dynamic Error Containers, Error Handling, Type-Erasure Error Containers, Error Contextualization, Heap-Allocated Error Containers, Standardized Error Traits, Error Propagation Systems.

    What are some open-source alternatives to dtolnay/anyhow?

    Open-source alternatives to dtolnay/anyhow include: dtolnay/thiserror — thiserror is a Rust error handling library and procedural macro designed to define custom error types. It functions as… rust-lang/rust-by-example — This project is an interactive programming education resource and tutorial designed for learning the Rust programming… go-errors/errors — errors is a Go error handling library and stack trace utility that wraps standard errors with execution call stacks… rust-lang/rfcs — The Rust RFCs repository is the formal home for the Rust language evolution process, housing the structured design… pkg/errors — pkg/errors is a Go library that provides primitives for creating, annotating, and inspecting errors with stack traces… c3lang/c3c — c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static…

    Open-source alternatives to Anyhow

    Similar open-source projects, ranked by how many features they share with Anyhow.
    • dtolnay/thiserrordtolnay avatar

      dtolnay/thiserror

      5,459View on GitHub↗

      thiserror is a Rust error handling library and procedural macro designed to define custom error types. It functions as a trait implementation automator that generates the necessary code for standard library error traits at compile time. The library focuses on eliminating boilerplate by using derive macros to automatically implement display and source methods. It allows for the creation of custom error structs and enums that can map low-level errors to high-level variants while preserving the original cause and backtrace information. Its capabilities cover custom error formatting through temp

      Rust
      View on GitHub↗5,459
    • rust-lang/rust-by-examplerust-lang avatar

      rust-lang/rust-by-example

      8,026View on GitHub↗

      This project is an interactive programming education resource and tutorial designed for learning the Rust programming language and systems programming concepts. It provides a collection of runnable and editable code examples that serve as a practical reference for language syntax and implementation. The resource features an interactive code sandbox that allows users to execute and test code snippets in real time. It emphasizes the verification of technical accuracy by executing embedded code blocks during the build process to ensure all examples remain functional. The content covers a compre

      Handlebars
      View on GitHub↗8,026
    • go-errors/errorsgo-errors avatar

      go-errors/errors

      1,005View on GitHub↗

      errors is a Go error handling library and stack trace utility that wraps standard errors with execution call stacks and contextual information. It captures program execution paths at the exact moment an error is initialized, extracting granular file paths, line numbers, and function symbols from raw program counter addresses. The library maintains parent-child relationships between wrapped errors to allow deep inspection, unwrapping of root causes, and combination of multiple errors into unified structures. It implements standard error interfaces so enhanced error objects can be used intercha

      Go
      View on GitHub↗1,005
    • rust-lang/rfcsrust-lang avatar

      rust-lang/rfcs

      6,406View on GitHub↗

      The Rust RFCs repository is the formal home for the Rust language evolution process, housing the structured design documents and community review mechanisms that govern changes to the Rust programming language, its compiler, and its standard library. It defines the complete lifecycle for proposing, discussing, and implementing substantial changes through RFC documents, from initial submission and community feedback through final comment periods and sub-team sign-offs. The repository codifies the governance and collaboration processes that shape Rust's development, including mechanisms for com

      Markdownrfcrfc-processrust
      View on GitHub↗6,406
    See all 30 alternatives to Anyhow→