Please star the repo if you like it, so that I know someone is using it.

HexStack is a complete, modern web framework for Rust that combines the familiar developer experience of Express.js, WS and Drizzle with the performance and safety of Rust. HexStack brings together three powerful libraries to create a unified full-stack development experience:

• Ripress - Lightning-fast HTTP server (97% of Actix-Web performance)
• Wynd - Simple, powerful WebSocket server
• Lume - Type-safe ORM with intuitive API (coming soon)

🚀 Unmatched Performance

• HTTP performance: 97% of Actix-Web speed
• WebSocket performance: Built on Tokio for maximum async efficiency
• Nearly 10x faster than Express.js + Socket.io

💡 Superior Developer Experience

• Express.js-familiar API that feels natural
• Type-safe from the ground up
• Comprehensive CLI for rapid scaffolding
• Seamless integration between all components

⚡ Modern Architecture

• Async/await support throughout
• HTTP/2 support via Hyper
• Real-time WebSocket capabilities
• Production-ready from day one

• Overview
• Features
• Installation
• CLI Usage
• Examples
• Documentation
• Ecosystem
• Changelog

HexStack is designed to be the Rails/Laravel of the Rust ecosystem - a complete, opinionated framework that provides everything you need to build modern web applications. With its CLI tool, you can scaffold new projects in seconds and start building immediately.

• 🔧 Powerful CLI - Scaffold projects with hexstack new
• 🌐 HTTP + WebSocket - Unified server handling both protocols
• 📦 Zero Configuration - Works out of the box with sensible defaults
• 🏗️ Multiple Templates - HTTP-only, WebSocket-only, or full-stack apps
• 🛡️ Type Safety - Compile-time guarantees throughout the stack
• 🚀 Hot Reload - Fast development iteration (coming soon)
• 📊 Built-in Middleware - CORS, logging, file uploads, rate limiting
• 🔄 Real-time Ready - WebSocket support for live features

Install HexStack CLI globally:

cargo install hexstack

Or add individual components to an existing project:

cargo add ripress --features with-wynd
cargo add wynd --features with-ripress
cargo add tokio --features macros,rt-multi-thread

# Full-stack HTTP + WebSocket application
hexstack new my-app --template full

# HTTP-only application
hexstack new my-api --template http

# WebSocket-only application
hexstack new my-ws --template websocket

• http - Ripress HTTP server only
• websocket - Wynd WebSocket server only
• full - Ripress + Wynd integrated server (default)

use ripress::{app::App, types::RouterFns};
use wynd::wynd::{Wynd, WithRipress};

#[tokio::main]
async fn main() {
    let mut wynd: Wynd<WithRipress> = Wynd::new();
    let mut app = App::new();

    // WebSocket handling
    wynd.on_connection(|conn| async move {
        conn.on_text(|event, handle| async move {
            let _ = handle.send_text(&format!("Echo: {}", event.data)).await;
        });
    });

    // HTTP routes
    app.get("/", |_, res| async move {
        res.ok().text("Welcome to HexStack!")
    });

    app.get("/api/health", |_, res| async move {
        res.ok().json(json!({"status": "healthy"}))
    });

    // Mount WebSocket
    app.use_wynd("/ws", wynd.handler());

    app.listen(3000, || {
        println!("🚀 HexStack server running on http://localhost:3000");
        println!("📡 WebSocket available at ws://localhost:3000/ws");
    })
    .await;
}

use ripress::{app::App, types::RouterFns};

#[tokio::main]
async fn main() {
    let mut app = App::new();

    app.get("/", |_, res| async move {
        res.ok().json(json!({"message": "Hello from HexStack!"}))
    });

    app.use_cors(None)
        .use_rate_limiter(None);

    app.listen(3000, || {
        println!("🚀 HexStack API running on http://localhost:3000");
    })
    .await;
}

use wynd::wynd::{Wynd, Standalone};

#[tokio::main]
async fn main() {
    let mut wynd: Wynd<Standalone> = Wynd::new();

    wynd.on_connection(|conn| async move {
        println!("Client connected");

        conn.on_text(|event, handle| async move {
            println!("Received: {}", event.data);
            let _ = handle.send_text("Message received!").await;
        });

        conn.on_binary(|event, handle| async move {
            let _ = handle.send_binary(event.data.clone()).await;
        });
    });

    wynd.listen(3000, || {
        println!("📡 WebSocket server running on ws://localhost:3000");
    })
    .await
    .unwrap();
}

View more examples in the Examples directory.

Ready to build something amazing? Get started in 30 seconds:

# Install HexStack CLI
cargo install hexstack

# Create a new full-stack app
hexstack new my-app

# Navigate and run
cd my-app
cargo run

Your server will be running on http://localhost:3000 with WebSocket support at ws://localhost:3000/ws.

• Getting Started Guide
• CLI Reference
• HTTP Server Guide
• WebSocket Guide
• Deployment Guide
• API Reference

HexStack is built on top of these powerful libraries:

• 97% of Actix-Web performance
• Express.js-inspired API
• Built-in middleware ecosystem
• Production ready v1.0+

• Event-driven async API
• Automatic connection management
• Type-safe message handling
• Seamless HTTP integration

• Type-safe queries
• Schema-first approach
• Migration system
• Relationship handling

HexStack delivers exceptional performance across the stack:

• HTTP: 97% of Actix-Web performance
• WebSocket: Full async/concurrent connections
• Memory: Efficient connection and resource management
• Throughput: 10x faster than Express.js + Socket.io equivalents

We don't take contributions yet, but your feedback is always welcome! If you have any questions or suggestions, feel free to reach out to us on X.

This project is licensed under the MIT License - see the LICENSE file for details.

HexStack v0.3.0 - The Future of Rust Web Development ⚡