🪶 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.

Why Feather?

• Middleware-First Architecture
  Everything is a middleware — route handlers, auth, logging — all composable and clean.

• Easy State Management Using Context
  In the recent versions Feather, implemented the Context API that makes it very easy manage state without the use of Extractors/Macros

• Developer Experience First
  Feather’s API is minimal, ergonomic, and readable

• Modular and Extensible
  Feather is designed to Modular, only select the features you need and use the. What you don't use you don't pay

• 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.1"

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,

Middleware in Feather

Middleware is intented to be heart of Feather. You may 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.
As an example:

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

struct Counter {
    pub count: i32,
}

fn main() {
    let mut app = App::new();
    let counter = Counter { count: 0 };
    app.context().set_state(counter);

    app.get("/", move |_req: &mut Request, res: &mut Response, ctx: &mut AppContext| {
        let counter: &mut Counter = ctx.get_mut_state::<Counter>().unwrap();
        counter.count += 1;
        res.send_text(format!("Counted! {}", counter.count));
        MiddlewareResult::Next
    });
    app.get("/count", move |_req: &mut Request, res: &mut Response, ctx: &mut AppContext| {
        let counter = ctx.get_state::<Counter>().unwrap();
        res.send_text(counter.count.to_string());
        MiddlewareResult::Next
    });

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

Context Is more useful when combined with Database/File Accesses

Built-in JWT Authentication

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

[dependencies]
feather = { version = "0.3.1", 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")
}

Goals

• Being the simplest Rust web framework to get started with
• Being modular and easy to extend
• Focusing on DX without sacrificing Rust's safety and performance

Contributing

PRs welcome!
If you’ve got ideas or bugs, please 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.

Spread the Word

If you like Feather:

• ⭐ Star it on GitHub
• Share it on Reddit, HN, or Discord
• Build something and show up!