Hyperlane: Unleashing High-Speed Web Development with Rust

Looking for a way to supercharge your web services without sacrificing simplicity? Meet Hyperlane, a Rust-based HTTP server library that’s here to redefine how you build fast, reliable, and scalable applications. Designed for developers who crave performance and elegance, Hyperlane delivers a lightweight yet powerful toolkit for crafting modern web solutions. Let’s dive into what makes Hyperlane a must-try and how you can start using it today! What is Hyperlane? Hyperlane is an open-source HTTP server library written in pure Rust, harnessing the Tokio runtime for asynchronous power. It’s built from the ground up to handle HTTP requests, responses, and TCP connections with minimal fuss. Whether you’re developing APIs, real-time systems with WebSocket and Server-Sent Events (SSE), or cross-platform services, Hyperlane has you covered. Its secret sauce? A lean design with no external dependencies, ensuring rock-solid reliability and a consistent experience across Windows, Linux, and macOS. Hyperlane is all about giving you the tools to build efficiently—without the bloat. Standout Features That Make Hyperlane Shine Blazing Fast: Powered by Rust and Tokio, Hyperlane delivers top-tier performance with low overhead. Cross-Platform Mastery: Uniform APIs across all major operating systems—no platform-specific headaches. Middleware Magic: Customize your request and response flows with ease. Real-Time Ready: Built-in support for WebSocket and SSE keeps your apps interactive and responsive. Pure Rust Simplicity: No external libraries, just clean, dependable code. With Hyperlane, you’re equipped to tackle any web project, big or small. Kickstart Your Hyperlane Adventure Install Hyperlane Get started in seconds by adding Hyperlane to your Rust project: cargo add hyperlane That’s it—you’re ready to roll! Learn the Ropes Check out these resources to hit the ground running: Quick Start Guide Example Repo Clone the repo to explore a working example: git clone https://github.com/ltpp-universe/hyperlane-quick-start.git See Hyperlane in Action: A Simple Server Setup Here’s a taste of Hyperlane’s intuitive API with a sample server that handles middleware, routing, and WebSocket: use hyperlane::*; async fn log_middleware(ctx: Context) { let request_info = ctx.get_request_string().await; ctx.log_info(&format!("Request: {}", request_info), log_handler).await; } async fn greet_route(ctx: Context) { ctx.set_response_status_code(200) .await .set_response_body("Welcome to Hyperlane!") .await; } async fn echo_websocket(ctx: Context) { let data = ctx.get_request_body().await; let _ = ctx.send_response_body(data).await; } #[tokio::main] async fn main() { let server = Server::new(); server.host("0.0.0.0").await; server.port(8000).await; server.enable_nodelay().await; server.log_dir("./logs").await; server.request_middleware(log_middleware).await; server.route("/", greet_route).await; server.route("/ws", echo_websocket).await; server.listen().await.unwrap(); } What’s Happening Here? Middleware: log_middleware logs incoming requests for debugging. Routing: The root (/) sends a friendly greeting, while /ws echoes WebSocket messages. Setup: The server runs on port 8000 with TCP optimizations and logging enabled. This snippet shows how Hyperlane balances power and simplicity—perfect for rapid development. Performance That Packs a Punch Hyperlane isn’t just pretty code—it’s a performance beast. Check out these benchmark results: wrk Benchmark (QPS) Command: wrk -c360 -d60s http://127.0.0.1:60000/ Hyperlane: 324,323.71 Tokio: 340,130.92 Rocket: 298,945.31 Node Std: 139,412.13 ab Benchmark (QPS) Command: ab -n 1000000 -c 1000 -r -k http://127.0.0.1:60000/ Hyperlane: 307,568.90 Tokio: 308,596.26 Rocket: 267,931.52 Node Std: 85,357.18 Latency (10,000 Requests) Hyperlane: 150µs Apache: 2500µs Hyperlane holds its own against the best, delivering near-Tokio-level QPS and crushing latency benchmarks. Curious? Test it yourself with the performance repo. Join the Hyperlane Community Open-Source Freedom Hyperlane is licensed under the MIT License. Dive into the license details to learn more. Contribute to the Future Got ideas or fixes? We’d love your input! Contribute via GitHub. Say Hello Reach out to the creator at [ltpp-universe root@ltpp.vip](mailto:root@ltpp.vip) with questions or feedback. Take Hyperlane for a Spin! Hyperlane is your ticket to building high-performance web services with the ease and safety of Rust. Ready to experience it? Head to the API Documentation and start creating. With Hyperlane, your next big project is just a cargo add away!

cargo add hyperlane

git clone https://github.com/ltpp-universe/hyperlane-quick-start.git

use hyperlane::*;

async fn log_middleware(ctx: Context) {
    let request_info = ctx.get_request_string().await;
    ctx.log_info(&format!("Request: {}", request_info), log_handler).await;
}

async fn greet_route(ctx: Context) {
    ctx.set_response_status_code(200)
        .await
        .set_response_body("Welcome to Hyperlane!")
        .await;
}

async fn echo_websocket(ctx: Context) {
    let data = ctx.get_request_body().await;
    let _ = ctx.send_response_body(data).await;
}

#[tokio::main]
async fn main() {
    let server = Server::new();
    server.host("0.0.0.0").await;
    server.port(8000).await;
    server.enable_nodelay().await;
    server.log_dir("./logs").await;
    server.request_middleware(log_middleware).await;
    server.route("/", greet_route).await;
    server.route("/ws", echo_websocket).await;
    server.listen().await.unwrap();
}