hyperium/hyper
Hyper
Hyper is a low-level networking library designed for building high-performance HTTP clients and servers. It provides a foundational toolkit for creating network services that leverage asynchronous execution and memory-safe data handling, supporting both HTTP/1 and HTTP/2 protocols.
The library distinguishes itself through a protocol-agnostic architecture that separates transport logic from HTTP semantics. It utilizes a service-trait abstraction to decouple network logic from the underlying transport, enabling developers to inject custom middleware for request interception and response transformation. By employing zero-copy buffer management and asynchronous stream processing, the framework minimizes memory footprint and reduces latency when handling large payloads.
The project covers a comprehensive range of networking capabilities, including connection pool management for high-volume traffic, transport layer security integration, and graceful server shutdown procedures. It provides primitives for constructing concurrent servers and clients, supporting both buffered and streaming data pipelines to accommodate various application requirements.
Features
- HTTP Client Libraries - Acts as a foundational low-level networking library for building high-performance HTTP clients and servers.
- Asynchronous Network Frameworks - Provides a foundational toolkit for building robust, asynchronous, and type-safe network services in Rust.
- HTTP/2 Protocol Implementations - Implements a high-concurrency networking stack supporting modern HTTP/1 and HTTP/2 standards.
- High-Performance HTTP Servers - Provides a high-performance, memory-safe engine for building concurrent HTTP/1 and HTTP/2 servers.
- Networking Libraries - Provides foundational networking primitives for building high-performance HTTP clients and servers.
- Transport Layer Security - Integrates with transport layer security protocols to establish secure connections and protect data during transit.
- HTTP Servers - Provides the core engine for constructing concurrent HTTP/1 and HTTP/2 servers.
- Asynchronous Streams - Handles network data as non-blocking asynchronous streams to minimize memory usage and improve throughput.
- Middleware-Based Request Pipelines - Provides modular middleware pipelines for intercepting and transforming network requests and responses.
- Connection Pooling - Maintains a collection of reusable connections to remote servers to reduce latency and overhead during high traffic.
- HTTP Servers - Executes network listeners to process incoming connections using defined service logic.
- Service Abstractions - Decouples network logic from transport using a standard service-trait interface for request-response transformation.
- Zero-Copy Mechanisms - Optimizes performance by passing memory references between network layers to avoid redundant data copying.
- HTTP Request Handlers - Maps incoming HTTP requests to asynchronous handler functions for processing and response generation.
- Request Interception Middleware - Allows wrapping incoming requests or outgoing responses with custom logic for logging, authentication, or header modification.
- Client Libraries - Low-level HTTP client for fine-grained control over requests.
- Herramientas de desarrollo - Low-level HTTP library for network communication.
- Rust Projects - Listed in the “Rust Projects” section of the Awesome For Beginners awesome list.
- Server Frameworks - Low-level, fast, and correct HTTP implementation for Rust.
- Web Frameworks - High-performance HTTP client and server library.
- Incremental Data Streaming - Processes large network payloads incrementally as asynchronous streams to maintain low memory usage.
- Response Streaming - Handles large payloads incrementally as asynchronous frames to avoid buffering entire content into memory.
- Asynchronous Network Clients - Provides robust asynchronous HTTP client primitives for managing connection pools and secure transmission.
- HTTP Request Builders - Constructs and dispatches HTTP requests with configurable headers and body content.
- Protocol-Agnostic Transport Layers - Separates transport logic from HTTP semantics to support multiple protocol versions through a unified builder.
- Custom Middleware Implementations - Enables modular request and response interception for logging, authentication, and header modifications.
- Task-Based Concurrency Frameworks - Uses future-based state machines to manage concurrent network tasks efficiently.
- Stream Forwarders - Forwards data from an incoming request body directly to a response body as it arrives to minimize memory usage.
- Graceful Shutdowns - Ensures data integrity by allowing in-flight requests to complete before shutting down the server.
- Runtime Abstraction Layers - Integrates custom asynchronous executors via a standard interface to map task spawning to the underlying runtime.
- Request Body Handling - Accepts generic or specific data types to handle incoming and outgoing information streams throughout the HTTP communication lifecycle.
- Request Routing - Matches incoming HTTP requests to specific handlers based on the request method and path.
- HTTP Server Configuration - Configures server communication protocols by selecting appropriate builders and runtime executors.
- Stream Transformers - Applies functional mapping operations to individual data frames within a request body stream to modify content.
