hyper

Hyper is the backbone of Rust's HTTP ecosystem, and it shows in both performance and complexity. Runtime performance is excellent with efficient connection pooling and zero-copy operations where possible. Memory usage is predictable and tight, though you need to understand the tower Service trait system to leverage it fully. The 1.0 rewrite brought significant breaking changes that required substantial refactoring in our services—particularly around Body types and the complete removal of the built-in Client/Server APIs in favor of hyper-util.

The logging story requires manual instrumentation with tracing spans since hyper itself is fairly quiet. Error handling is robust but verbose—you'll write a lot of boilerplate mapping hyper::Error types. Timeout configuration isn't built-in; you need tower-http middleware or manual timeout layers. Connection pooling works well once configured, but the defaults are conservative and require tuning under load.

Documentation improved significantly but still assumes deep async Rust knowledge. The migration from 0.14 to 1.x was painful—budget substantial time if upgrading. Once operational, it's rock-solid for high-throughput services.

Hyper is the foundational HTTP library in Rust that prioritizes performance and correctness over convenience. In daily use, you'll find it's more of a toolkit than a batteries-included solution. The type system guides you well through request/response construction, and the async integration with Tokio is solid once you understand the executor requirements.

The major version 1.x redesign significantly improved the API by splitting client and server concerns, but it comes with a learning curve. You'll need to understand Pin, async traits, and service tower patterns. Error handling is precise but verbose - expect to write custom error mapping frequently. The documentation has improved substantially with more examples, though you'll still reference external guides for common patterns like connection pooling or middleware.

For production use, hyper shines when you need control and performance. The type safety catches issues at compile time that other languages would only find at runtime. However, expect to write more boilerplate than higher-level frameworks like axum or actix-web, which themselves build on hyper.

Hyper is the foundational HTTP library in Rust's async ecosystem, but it's explicitly low-level and requires substantial upfront investment to use effectively. The transition from 0.14 to 1.0 removed many convenience APIs, making it even more bare-bones. You'll need to understand tokio runtime intricacies, tower services, and manually wire together connectors, executors, and body handling. The documentation assumes you already know what you're doing with async Rust.

Error messages can be cryptic, especially around trait bounds and lifetime issues with async code. Debugging often requires deep-diving into tower middleware and understanding the Service trait hierarchy. Stack Overflow has limited hyper 1.x content since it's relatively new, and many examples online are still for 0.14, causing confusion. GitHub issues get responses, but expect to be pointed to hyper-util or told to use higher-level frameworks.

Common use cases like making simple HTTP requests or building basic servers require surprising amounts of boilerplate. You'll likely spend time figuring out body streaming, connection pooling, and graceful shutdown patterns that higher-level libraries handle automatically.