Crate feather

Expand description

§🪶 Feather

Feather is a lightweight, DX-first web framework for Rust — inspired by the simplicity of Express.js, but designed for Rust’s performance and safety.

🧠 No async.
🧱 Middleware-first.
⚡ Just works.

§✨ Why Feather?

🧱 Middleware-First Architecture
Everything is a middleware — route handlers, auth, logging, error handling — all composable and clean.
🪶 Lightweight and Fast
Feather uses traditional threads instead of async, avoiding the overhead and complexity of Rust’s async model.
🏦 Easy State Management Using Context
In the recent version Feather implemented the Context API that allows it have easy state managment without the use of Extractors/Macros
🧑‍💻 Developer Experience First
Feather’s API is minimal, ergonomic, and readable — no lifetimes, no .await, no boilerplate.
📦 Modular and Extensible
Build the framework you want with plug-and-play middleware, simple traits, and clear primitives.
🔨 Great Tooling Out Of the Box
With the use of the Feather-CLI Creating API’s and Web Servers Become a Breeze.

§🚀 Getting Started

Add Feather to your Cargo.toml:

[dependencies]
feather = "0.3.0"

§🧭 Quick Example

use feather::{App, AppContext, MiddlewareResult,Request, Response};

fn main() {
    let mut app = App::new();
    app.get("/",|_req: &mut Request, res: &mut Response, _ctx: &mut AppContext| {
            res.send_text("Hello, world!");
            MiddlewareResult::Next
    });

    app.listen("127.0.0.1:3000");
}

✔️ That’s all — no async, no magic.

§🔌 Middleware in Feather

Middleware is the heart of Feather. Write it as a closure, a struct, or chain them together:

use feather::{App, AppContext, Request, Response};
use feather::middleware::builtins;
use feather::middleware::{Middleware, MiddlewareResult};
// Implementors of the Middleware trait are middleware that can be used in a Feather app.
struct Custom;
impl Middleware for Custom {
    fn handle(&self,request: &mut Request,_response: &mut Response,_ctx: &mut AppContex) -> MiddlewareResult {
      println!("Now running some custom middleware (struct Custom)!");
      println!("And there's a request with path: {:?}", request.uri);
      MiddlewareResult::Next
    }
}

fn main() {
    let mut app = App::new();
    app.use_middleware(builtins::Logger);
    app.use_middleware(Custom);
    app.use_middleware(|_req: &mut Request, _res: &mut Response, _ctx: &mut AppContext| {
        println!("Now running some custom middleware (closure)!");
        MiddlewareResult::Next
    });

    app.get("/",|_req: &mut Request, res: &mut Response, _ctx: &mut AppContext| {
        res.send_text("Hello, world!");
        MiddlewareResult::Next
    });

    app.listen("127.0.0.1:3000");
}

§🏦 State Management using the Context API

Feather’s new Context API allows you to manage application-wide state without extractors or macros. Here’s an example:

use feather::{App,AppContext,MiddlewareResult,Response,Request};

struct MyData{pub data: i32}

fn main() {
    let mut app = App::new();
    app.get("/", |req: &mut Request,res: &mut Response,ctx: &mut AppContext|{
        let data = MyData{data:55};
        ctx.set_state(data);
        MiddlewareResult::Next
    });

    let value = app.context().get_state::<MyData>().unwrap();
}

Context Is more useful when combined with Database/File Accesses

§🔐 Built-in JWT Authentication

Feather has native JWT middleware activated using a cargo feature jwt:

[dependencies]
feather = { version = "0.3.0", features = ["jwt"] }

use feather::jwt::{generate_jwt, with_jwt_auth};
use feather::{App, AppContext};

fn main() {
    let mut app = App::new();
    app.get("/auth",with_jwt_auth("secretcode", |_req, res,_ctx, claim| {
        println!("Claim: {:?}", claim);
        res.send_text("Hello, JWT!");
        feather::MiddlewareResult::Next
      }),
    );
    // Check the JWT Example for more complete version!
    app.listen("127.0.0.1:8080")
}

§No need to reach out for 3rd Party Crates Feather Got you Covered!

§🧱 Goals

🪶 Be the simplest Rust web framework to get started with
🧩 Be modular and easy to extend
💡 Focus on DX without sacrificing Rust’s safety and performance

§🤝 Contributing

PRs welcome!
If you’ve got ideas or bugs, open an issue or submit a pull request.

# Getting started with dev
git clone https://github.com/BersisSe/feather.git
cd feather
cargo run --example app

§📄 License

Feather is MIT licensed. See LICENSE.

§🙏 Acknowledgments

Feather is inspired by Express.js and exists to bring that same productivity to Rust.

Thanks to the Rust community for the incredible ecosystem this project builds on.

§📣 Spread the Word

If you like Feather:

⭐ Star it on GitHub
📰 Share it on Reddit, HN, or Discord
🛠 Build something and show us!

Re-exports§

pub use middleware::MiddlewareResult;

Modules§

jwt
middleware: The [Middleware] trait and some common middleware primitives.

Macros§

chain: A macro to chain multiple middlewares together.
This macro takes a list of middlewares and chains them together.

Structs§

App: A Feather application.
AppContext: AppContext Is Used for Managing state in your Feather Application
Context Should only used with objects like Connections and Custom Structs!
Request
Response

Crate featherCopy item path