feather 0.6.0

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—even if it's not, it produces a middleware in the end.
  The new middleware! macro makes writing route and middleware closures concise and ergonomic.

• Easy State Management Using Context
  The Context API makes it very easy to manage state without the use of Extractors/Macros.

• All in One
  Feather is a complete web framework that includes routing, middleware, logging, JWT authentication, and more, all in one package.

• Feel of Async Without Async
  Feather is multithreaded by default, running on Feather-Runtime.

How it works behind the scenes

Feather is powered by Feather-Runtime, a custom runtime built for high concurrency and low latency without using Rust's async/await. Each request is handled by a lightweight coroutine, enabling thousands of concurrent connections with simple, synchronous code. For more technical details, see Feather-Runtime.

Getting Started

Add Feather to your Cargo.toml:

[dependencies]

feather = "~0.6"

Quick Example

use feather::{App, middleware_fn, next};

#[middleware_fn]
fn hello() -> feather::Outcome {
    res.send_text("Hello, world!");
    next!()
}

fn main() {
    let mut app = App::new();
    app.get("/", hello);
    app.listen("127.0.0.1:5050");
}

That’s all — no async.

Middleware in Feather

Middleware is the heart of Feather. You may write it as a closure (using the middleware! macro), a struct, or chain them together:

use feather::{App, middleware_fn, next};

#[middleware_fn]
fn log_middleware() -> feather::Outcome {
    println!("Custom global middleware!");
    next!()
}

#[middleware_fn]
fn hello() -> feather::Outcome {
    res.send_text("Hello, world!");
    next!()
}

fn main() {
    let mut app = App::new();
    app.use_middleware(log_middleware);
    app.get("/", hello);
    app.listen("127.0.0.1:5050");
}

Or as a struct:

use feather::{middleware_fn, Request, Response, AppContext, Middleware, next, info};""

struct CustomMiddleware(String);

impl Middleware for CustomMiddleware {
    fn handle(&self, _request: &mut Request, _response: &mut Response, _ctx: &AppContext) -> feather::Outcome {
        info!("Hii I am a Struct Middleware and this is my data: {}", self.0);
        next!()
    }
}

State Management using the Context API

Feather's Context API allows you to manage application-wide state without extractors or macros.

use feather::{App, middleware_fn, next};
#[derive(Debug)]
struct Counter { pub count: i32 }

#[middleware_fn]
fn count() -> feather::Outcome {
    let counter = ctx.get_mut_state::<Counter>().unwrap();
    counter.count += 1;
    res.send_text(format!("Counted! {}", counter.count));
    next!()
}

fn main() {
    let mut app = App::new();
    app.context().set_state(Counter { count: 0 });
    app.get("/", count);
    app.listen("127.0.0.1:5050");
}

Context is especially useful when needing to access databases and files.

Built-in JWT Authentication

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

[dependencies]

feather = { version = "*", features = ["jwt"] }

use feather::{App, jwt_required, middleware_fn, next};
use feather::jwt::{JwtManager, SimpleClaims};

#[middleware_fn]
fn token_route() -> feather::Outcome {
    let token = ctx.jwt().generate_simple("user", 1)?;
    res.send_text(format!("Token: {}", token));
    next!()
}

#[jwt_required]
#[middleware_fn]
fn protected(claims: SimpleClaims) -> feather::Outcome {
    res.send_text(format!("Hello, {}!", claims.sub));
    next!()
}

fn main() {
    let mut app = App::new();
    let manager = JwtManager::new("secretcode");
    app.context().set_jwt(manager);
    app.get("/token", token_route);
    app.get("/auth", protected);
    app.listen("127.0.0.1:8080");
}

Logging

When you create a new Feather application, it initializes the logger by default.

fn main() {
    let mut app = App::new();
    info!("Feather app ready to serve requests!");
    // Your app setup here
    app.listen("127.0.1:5050");
    
}

if you don't want it to be initialized, you can disable it by create a App with without_logger method

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 are welcome!
If you have 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.
Huge thanks to the Rust community for their support and contributions!
Special thanks to the contributors who have helped make Feather better!

Spread the Word

If you like Feather:

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