Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.

Overview

Actix Web

Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust

crates.io Documentation Version MIT or Apache 2.0 licensed Dependency Status
build status codecov downloads Chat on Discord

Features

  • Supports HTTP/1.x and HTTP/2
  • Streaming and pipelining
  • Keep-alive and slow requests handling
  • Client/server WebSockets support
  • Transparent content compression/decompression (br, gzip, deflate)
  • Powerful request routing
  • Multipart streams
  • Static assets
  • SSL support using OpenSSL or Rustls
  • Middlewares (Logger, Session, CORS, etc)
  • Includes an async HTTP client
  • Runs on stable Rust 1.46+

Documentation

Example

Dependencies:

[dependencies]
actix-web = "3"

Code:

use actix_web::{get, web, App, HttpServer, Responder};

#[get("/{id}/{name}/index.html")]
async fn index(web::Path((id, name)): web::Path<(u32, String)>) -> impl Responder {
    format!("Hello {}! id:{}", name, id)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().service(index))
        .bind("127.0.0.1:8080")?
        .run()
        .await
}

More examples

You may consider checking out this directory for more examples.

Benchmarks

One of the fastest web frameworks available according to the TechEmpower Framework Benchmark.

License

This project is licensed under either of

at your option.

Code of Conduct

Contribution to the actix-web repo is organized under the terms of the Contributor Covenant. The Actix team promises to intervene to uphold that code of conduct.

Comments
  • Project future

    Project future

    I realized, a lot of people depends on actix. And it would be unfair to just delete repos. I promote @JohnTitor to project leader. He did very good job helping me for the last year. I hope new community of developers emerge. And good luck!

    opened by fafhrd91 143
  • Connection not closed correctly

    Connection not closed correctly

    Connection are not closed correctly by default What I means is: if you do a "netstat -ano" you will see connection list growing and growing. Not all old connection get closed.

    Tested with StaticFile handler ( HTTP2 or not ) on a website with ~20k+ daily users

    With the default config -> Not closed correctly With .keep_alive(None) -> Not closed correctly With .keep_alive(server::KeepAlive::Timeout(5)) -> All connections are closed correctly

    Initially detected in this ticket #426 but it was not the main issue

    C-bug needs-investigation 
    opened by neowutran 116
  • StaticFile & memory leak

    StaticFile & memory leak

    Hi, I am playing a bit with rust/actix-web on my personal website. The code is very basic https://git.neowutran.ovh:8080/neowutran/Website/src/master/src/main.rs

      server::new(|| {
        App::new()
         // .middleware(middleware::Logger::default())
          .resource("/store_stats", |r| {
            r.method(Method::POST)
              .with_config(store_statistics, |config| {
                config.limit(MAX_SIZE_STATS);
              })
          })
        .resource("/store_packets", |r| {
          r.method(Method::POST)
            .with_config(store_packets, |config| {
                config.0.limit(MAX_SIZE_PACKET);
            })
        })
        .handler("/updates",StaticFiles::new("/home/gl0/updates/").unwrap().show_files_listing())
        .handler("/others",StaticFiles::new("/home/gl0/others/").unwrap().show_files_listing())
        .handler("/teraDB",StaticFiles::new("/home/gl0/teraDB/").unwrap().show_files_listing())
        .handler("/",StaticFiles::new("/home/http/neowutran/").unwrap().show_files_listing().index_file("index.html"))
      })
    

    I run 2 instance of this exact same code. One on port 443, one on port 8083

    On port 8083, only /store_packets and /store_stats are used. 0.2% of server memory, stable. Actively used ( ~thousands request by hours, gigabytes uploaded ). Ok.

    On port 443, only the StaticFiles handler are used: /updates, /others, /teraDB, / ( TLS + HTTP2 ) Very actively used (~15k user use the /updates to download things). When I launched it yesterday, it used 0.2% of server memory. Memory used increased over time. Now, after ~15h, it now use 10% of server memory. With the command netstat -ano, I see that a lot of connections (hundreds) are "ESTABLISHED" on the service. Maybe in the case of HTTP2 / TLS, some issues with connection not being released or something like that ? ( For the same thing with apache httpd, ~0.2% of server memory, stable )

    Thanks

    opened by neowutran 53
  • actix-web 1.0

    actix-web 1.0

    I am planing to move 0.7 to separate branch and move 1.0 to master in 1 week.

    Any thoughts, concerns?

    High level tasks:

    • [x] Move 0.7 to separate branch
    • [x] Move 1.0 to master
    • [x] actix-files tidy up #730
    • [x] Migration guide 0.7 -> 1.0
    • [x] Upgrade the book
    • [x] Upgrade example
    opened by fafhrd91 51
  • Memory Leak on Actix 3.2.0

    Memory Leak on Actix 3.2.0

    I'm creating a simple API and put it under stress using loadtest. The API consumes 3MB when idling and not under stress. With the command: loadtest -c 1000 --rps 10000 http://localhost:4000/hello/world the memory consumption goes to ~100MB.

    Expected Behavior

    After the stress test done, the memory consumption goes back to a normal level (~3MB)

    Current Behavior

    After the stress test done, the memory consumption doesn't decrease.

    Possible Solution

    Sorry I can't find any solution for this.

    Steps to Reproduce (for bugs)

    1. Implement a simple API and call the exposed route.

    Context

    I tried to make a benchmark of an API made in Rust vs a one in Spring, and while the rust version is memory efficient, it does show some leaks that are problematic.


    Code used for exposing the route.

    use actix_web::{middleware, web, App, HttpServer, Responder, HttpResponse};
    
    async fn hello_world(
        name: web::Path<String>
    ) -> impl Responder {
        HttpResponse::Ok().json(format!("{}", name))
    }
    
    #[actix_web::main]
    async fn main() -> std::io::Result<()> {
    
        println!("Launching server...");
    
        std::env::set_var("RUST_LOG", "actix_web=info,actix_server=info");
        env_logger::init();
        dotenv::dotenv().ok();
    
        let port = match std::env::var("PORT") {
            Ok(port) => port,
            _ => String::from("4000")
        };
        let address = format!("0.0.0.0:{}", port);
    
        let http_server = HttpServer::new(move || {
            App::new()
                // .wrap(middleware::Logger::default())
                .route("/hello/{name}", web::get().to(hello_world))
        })
            .bind(address.clone())?;
    
        println!("Will listen to {}", address);
    
        http_server
            .run()
            .await
    }
    

    Using LeakSanitizer it does confirm that there's a little problem:

    ==68512==ERROR: LeakSanitizer: detected memory leaks
    Direct leak of 256 byte(s) in 8 object(s) allocated from:
        #0 0x564cae1e4255  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0xd6255)
        #1 0x564cae2f830b  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0x1ea30b)
    
    Direct leak of 192 byte(s) in 8 object(s) allocated from:
        #0 0x564cae1e4255  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0xd6255)
        #1 0x564cae40bf8b  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0x2fdf8b)
    
    Indirect leak of 8192 byte(s) in 8 object(s) allocated from:
        #0 0x564cae1e4255  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0xd6255)
        #1 0x564cae2f830b  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0x1ea30b)
    
    Indirect leak of 32 byte(s) in 8 object(s) allocated from:
        #0 0x564cae1e4255  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0xd6255)
        #1 0x564cae565a5b  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0x457a5b)
    
    SUMMARY: LeakSanitizer: 8672 byte(s) leaked in 32 allocation(s).
    

    Your Environment

    • Rust Version (I.e, output of rustc -V): rustc 1.45.1 (c367798cf 2020-07-26)
    • Actix Web Version: 3.2.0
    C-perf-mem A-web 
    opened by Mcfloy 41
  • Remove several usages of 'unsafe'

    Remove several usages of 'unsafe'

    This PR removes several different usages of unsafe (specifically, UnsafeCell), and replaces them with safe code. While these changes technically add some amount of overhead (Copying a type instead of taking a reference, and runtime RefCell checks), it should be so small as to be invisible on any benchmark.

    By replacing UnsafeCell with the safe Cell/UnsafeCell types, we ensure that any mistakes will lead to a panic! at worst, instead of undefined behavior.

    Each commit modifies a single file, and describes the changes made.

    opened by Aaron1011 41
  • how to run server by #[tokio::main]

    how to run server by #[tokio::main]

    use actix_web::{middleware, web, App, HttpRequest, HttpServer};

    async fn index(_req: HttpRequest) -> &'static str { "Hello world!" }

    #[tokio::main] #[cfg(unix)] async fn main() -> std::io::Result<()> { ::std::env::set_var("RUST_LOG", "actix_server=info,actix_web=info"); env_logger::init();

    HttpServer::new(|| {
        App::new()
            // enable logger - always register actix-web Logger middleware last
            .wrap(middleware::Logger::default())
            .service(
                web::resource("/index.html")
                    .route(web::get().to(|| async { "Hello world!" })),
            )
            .service(web::resource("/").to(index))
    })
    .bind_uds("/tmp/actix-uds.socket")?
    .run()
    .await
    

    }

    #[cfg(not(unix))] fn main() -> std::io::Result<()> { println!("not supported"); Ok(()) }

    opened by IThawk 39
  • bug: actix_web client unable to connect to any host on windows

    bug: actix_web client unable to connect to any host on windows

    Following example code always produces Error: Connect(Timeout):

    use actix_rt::System;
    use awc::Client;
    use futures::future::{
        Future,
        lazy
    };
    
    fn main() {
        System::new("weight_version").block_on(lazy(|| {
    
            awc::Client::new().get("https://google.com") //any address here
                .header("User-Agent", "Actix-web")
                .send()
                .map_err(|error| {
                    println!("Error: {:?}", error);
                })
                .and_then(|response| {
                    println!("Response: {:?}", response);
                    Ok(())
                })
        }));
    }
    

    actix_web::client::Client also produces same error:

    use actix_rt::System;
    use actix_web::client::Client;
    use futures::future::{
        Future,
        lazy
    };
    
    fn main() {
        System::new("weight_version").block_on(lazy(|| {
            let client = Client::default();
    
            client.get("https://www.rust-lang.org/")
                .header("User-Agent", "Actix-web")
                .send()
                .map_err(|error| {
                    println!("Error: {:?}", error);
                    //Err(error)
                })
                .and_then(|response| {
                    println!("Response: {:?}", response);
                    Ok(())
                })
        }));
    }
    

    Tested on 3 totally different windows machines with following:

    openssl version
    OpenSSL 1.1.1c  28 May 2019
    
    needs-investigation A-awc O-windows O-macos v1.x 
    opened by calirofpn 38
  • Call to Community and Participation

    Call to Community and Participation

    Until now i made most of project related decisions. But unfortunately, i dont have much time anymore, also i'd like to spend more time outside of opensource. supporting of this large and complex project is time consuming so i'd like to hand it to contributors, who'd like to spend some time on the project. I am still planing to work on actix, but can not afford to spend that much time as before.

    @actix/contributors

    opened by fafhrd91 37
  • Type-safe path/query parameter handling, using serde

    Type-safe path/query parameter handling, using serde

    Users should be able to define structures that hold parameters that need to be passed to a request handler. We could use the serde Deserialize trait. The goal is to make it easier for users to access parameters without having to deal with error-handling themselves, and hopefully to avoid the current situation where making a typo in your handler vs your route means that you get a runtime error instead of a compile-time error.

    The goal is to somehow allow the user to type this:

    #[derive(Deserialize)]
    struct MyParams {
        name: String,
    }
    

    and then, define a handler like this:

    fn my_handler(req: HttpRequest<_>, my_params: MyParams) -> _ {
    }
    

    or, alternatively:

    fn my_hadler(req: HttpRequest<_>) -> _ {
        let my_params = req.get_params::<MyParams>();
    }
    

    This will require some way to declare the route for my_handler with MyParams.

    opened by radix 37
  • UDP Socket Leak

    UDP Socket Leak

    I have a service that after ~18 - 24 hours runs out of file descriptors after a lot of investigation and some production debugging we were able to track it down to being leaked UDP sockets. My first thought is something about DNS resolution is wrong. When caught in the act the server had 418 UDP sockets open and it climbs up to the ulimit of 1024 and then server CPU spikes and the health check fails and the container is cycled.

    C-bug-upstream 
    opened by glademiller 35
  • actix-test: allow dynamic port setting

    actix-test: allow dynamic port setting

    PR Type

    Features

    PR Checklist

    • [x] Tests for the changes have been added / updated.
    • [ ] Documentation comments have been added / updated.
    • [x] A changelog entry has been made for the appropriate packages.
    • [x] Format code with the latest stable rustfmt.
    • [x] (Team) Label with affected crates and semver status.

    Overview

    This is a quick change to allow the user to set a port instead of forcing a random assignment every time.

    this is a tiny thing that I need in my own project. Might be nice for others.

    B-semver-minor A-test-server 
    opened by kristian1108 2
  • Not panic if bind failed

    Not panic if bind failed

    This only exists on windows platforms.

    Expected Behavior

    Panic if can not bind to port

    Current Behavior

    continue runs, but can not really listen

    Steps to Reproduce (for bugs)

    1. build
    2. run at least 2

    Context

    My code: HttpServer::new(|| { App::new() .service(echo) .service(user::login_request) .service(user::register_request) .service(user::verify_email_request) }).bind(("0.0.0.0", unsafe { &CONFIG }["connection"]["serverPort"].as_i64().unwrap() as u16)).expect("Can not bind server to port").run().await.expect("Can not start server");

    Your Environment

    Windows 10 22H2 19045.2364

    • Rust Version (I.e, output of rustc -V): rustc 1.68.0-nightly (77429957a 2023-01-01)
    • Actix-* crate(s) Version: { version = "4.2.1", features = ["rustls"] }
    opened by zrll12 0
  • Hide authorization header in httprequest debug output

    Hide authorization header in httprequest debug output

    PR Type

    Bug fix

    PR Checklist

    • [X] Tests for the changes have been added / updated.
    • [X] Documentation comments have been added / updated.
    • [X] A changelog entry has been made for the appropriate packages.
    • [X] Format code with the latest stable rustfmt.
    • [x] (Team) Label with affected crates and semver status.

    Overview

    Hides Authorization header from HTTPRequest Debug output. In the case of HTTP Basic Authentication, this header would have the username and password of the authenticated user. Preventing this header from showing up in debug would prevent this password leakage into the logs. In other schemes the value may not be as sensitive, but still in most cases would allow impersonation of the user in some form.

    Whether or not you want this conditional or not is of course up to you. Willing to consider other locations for this check if you want a more general approach to prevent all debug outputs of sensitive headers.

    Thanks for a great library, keep it up!

    B-semver-patch A-web 
    opened by nshaaban-cPacket 3
  • minor optimization: reserve buffer once length is known (ws)

    minor optimization: reserve buffer once length is known (ws)

    PR Type

    Other

    PR Checklist

    • [x] ~Tests for the changes have been added / updated.~
    • [x] ~Documentation comments have been added / updated.~
    • [x] ~A changelog entry has been made for the appropriate packages.~
    • [X] Format code with the latest stable rustfmt.
    • [x] (Team) Label with affected crates and semver status.

    Overview

    No behavior change. Just an optimization.

    No breaking changes.

    A-http B-semver-norelease 
    opened by moh-eulith 0
  • add setup to compress middleware

    add setup to compress middleware

    PR Type

    Feature

    PR Checklist

    • [ ] Tests for the changes have been added / updated.
    • [ ] Documentation comments have been added / updated.
    • [ ] A changelog entry has been made for the appropriate packages.
    • [x] Format code with the latest stable rustfmt.
    • [ ] (Team) Label with affected crates and semver status.

    Overview

    A-http B-semver-minor A-web 
    opened by topenkoff 0
Releases(router-v0.5.1)
  • router-v0.5.1(Sep 19, 2022)

    • Fix typo in error string in Deserializer::deserialize_i32 implementation for Value. #2876
    • Minimum supported Rust version (MSRV) is now 1.59 due to transitive time dependency.
    Source code(tar.gz)
    Source code(zip)
  • web-v4.2.1(Sep 12, 2022)

  • web-v4.2.0(Sep 11, 2022)

    Added

    • Add #[routes] macro to support multiple paths for one handler. #2718
    • Add ServiceRequest::{parts, request}() getter methods. #2786
    • Add configuration options for TLS handshake timeout via HttpServer::{rustls, openssl}_with_config methods. #2752

    Changed

    • Minimum supported Rust version (MSRV) is now 1.59 due to transitive time dependency.
    Source code(tar.gz)
    Source code(zip)
  • http-v3.2.2(Sep 11, 2022)

    Changed

    • Minimum supported Rust version (MSRV) is now 1.59 due to transitive time dependency.

    Fixed

    • Avoid possibility of dispatcher getting stuck while back-pressuring I/O. #2369
    Source code(tar.gz)
    Source code(zip)
  • codegen-v4.1.0(Sep 11, 2022)

  • awc-v3.0.1(Aug 25, 2022)

    Changed

    • Minimum supported Rust version (MSRV) is now 1.57 due to transitive time dependency.

    Fixed

    • Fixed handling of redirection requests that begin with //. #2840
    Source code(tar.gz)
    Source code(zip)
  • test-v0.1.0(Jul 24, 2022)

  • http-v3.2.0(Jul 24, 2022)

    Changed

    • Minimum supported Rust version (MSRV) is now 1.57 due to transitive time dependency.

    Fixed

    • Websocket parser no longer throws endless overflow errors after receiving an oversized frame. #2790
    • Retain previously set Vary headers when using compression encoder. #2798
    Source code(tar.gz)
    Source code(zip)
  • http-test-v3.0.0(Jul 24, 2022)

  • files-v0.6.2(Jul 23, 2022)

    • Allow partial range responses for video content to start streaming sooner. #2817
    • Minimum supported Rust version (MSRV) is now 1.57 due to transitive time dependency.
    Source code(tar.gz)
    Source code(zip)
  • http-v3.2.1(Jul 2, 2022)

  • web-v4.1.0(Jun 11, 2022)

    Added

    • Add ServiceRequest::extract() to make it easier to use extractors when writing middlewares. #2647
    • Add Route::wrap() to allow individual routes to use middleware. #2725
    • Add ServiceConfig::default_service(). #2338 #2743
    • Implement ResponseError for std::convert::Infallible

    Changed

    • Minimum supported Rust version (MSRV) is now 1.56 due to transitive hashbrown dependency.

    Fixed

    • Clear connection-level data on HttpRequest drop. #2742
    Source code(tar.gz)
    Source code(zip)
  • http-v3.1.0(Jun 11, 2022)

    Changed

    • Minimum supported Rust version (MSRV) is now 1.56 due to transitive hashbrown dependency.

    Fixed

    • Revert broken fix in #2624 that caused erroneous 500 error responses. Temporarily re-introduces #2357 bug. #2779
    Source code(tar.gz)
    Source code(zip)
  • files-v0.6.1(Jun 11, 2022)

    • Add NamedFile::{modified, metadata, content_type, content_disposition, encoding}() getters. #2021
    • Update tokio-uring dependency to 0.3.
    • Audio files now use Content-Disposition: inline instead of attachment. #2645
    • Minimum supported Rust version (MSRV) is now 1.56 due to transitive hashbrown dependency.
    Source code(tar.gz)
    Source code(zip)
  • codegen-v4.0.1(Jun 11, 2022)

  • http-v3.0.4(Mar 9, 2022)

  • http-v3.0.3(Mar 8, 2022)

  • awc-v3.0.0(Mar 8, 2022)

    Dependencies

    • Updated actix-* to Tokio v1-based versions. #1813
    • Updated bytes to 1.0. #1813
    • Updated cookie to 0.16. #2555
    • Updated rand to 0.8.
    • Updated rustls to 0.20. #2414
    • Updated tokio to 1.

    Added

    • trust-dns crate feature to enable trust-dns-resolver as client DNS resolver; disabled by default. #1969
    • cookies crate feature; enabled by default. [#2619]
    • compress-brotli crate feature; enabled by default. #2250
    • compress-gzip crate feature; enabled by default. #2250
    • compress-zstd crate feature; enabled by default. #2250
    • client::Connector::handshake_timeout() for customizing TLS connection handshake timeout. #2081
    • client::ConnectorService as client::Connector::finish method's return type #2081
    • client::ConnectionIo trait alias #2081
    • Client::headers() to get default mut reference of HeaderMap of client object. #2114
    • ClientResponse::timeout() for set the timeout of collecting response body. #1931
    • ClientBuilder::local_address() for binding to a local IP address for this client. #2024
    • ClientRequest::insert_header() method which allows using typed and untyped headers. #1869
    • ClientRequest::append_header() method which allows using typed and untyped headers. #1869
    • ClientBuilder::add_default_header() (and deprecate ClientBuilder::header()). #2510

    Changed

    • client::Connector type now only has one generic type for actix_service::Service. #2063
    • client::error::ConnectError Resolver variant contains Box<dyn std::error::Error> type. #1905
    • client::ConnectorConfig default timeout changed to 5 seconds. #1905
    • ConnectorService type is renamed to BoxConnectorService. #2081
    • Fix http/https encoding when enabling compress feature. #2116
    • Rename TestResponse::{header => append_header, set => insert_header}. These methods now take a TryIntoHeaderPair. #2094
    • ClientBuilder::connector() method now takes Connector<T, U> type. #2008
    • Basic auth now accepts blank passwords as an empty string instead of an Option. #2050
    • Relax default timeout for Connector to 5 seconds (up from 1 second). #1905
    • *::send_json() and *::send_form() methods now receive impl Serialize. #2553
    • FrozenClientRequest::extra_header() now uses receives an impl TryIntoHeaderPair. #2553
    • Rename Connector::{ssl => openssl}(). #2503
    • ClientRequest::send_body now takes an impl MessageBody. #2546
    • Rename MessageBody => ResponseBody to avoid conflicts with MessageBody trait. #2546
    • Minimum supported Rust version (MSRV) is now 1.54.

    Fixed

    • Send headers along with redirected requests. #2310
    • Improve Client instantiation efficiency when using openssl by only building connectors once. #2503
    • Remove unnecessary Unpin bounds on *::send_stream. #2553
    • impl Future for ResponseBody no longer requires the body type be Unpin. #2546
    • impl Future for JsonBody no longer requires the body type be Unpin. #2546
    • impl Stream for ClientResponse no longer requires the body type be Unpin. #2546

    Removed

    • compress crate feature. #2250
    • ClientRequest::set; use ClientRequest::insert_header. #1869
    • ClientRequest::set_header; use ClientRequest::insert_header. #1869
    • ClientRequest::set_header_if_none; use ClientRequest::insert_header_if_none. #1869
    • ClientRequest::header; use ClientRequest::append_header. #1869
    • Deprecated methods on ClientRequest: if_true, if_some. #2148
    • ClientBuilder::default function #2008

    Security

    Source code(tar.gz)
    Source code(zip)
  • http-v3.0.2(Mar 5, 2022)

  • http-v3.0.1(Mar 4, 2022)

  • actors-v4.1.0(Mar 2, 2022)

  • web-v4.0.1(Feb 25, 2022)

  • web-v4.0.0(Feb 25, 2022)

  • multipart-v0.4.0(Feb 25, 2022)

  • http-v3.0.0(Feb 25, 2022)

  • files-v0.6.0(Feb 25, 2022)

  • codegen-v4.0.0(Feb 25, 2022)

  • codegen-v0.5.0(Feb 25, 2022)

  • actors-v4.0.0(Feb 25, 2022)

  • router-v0.5.0(Feb 22, 2022)

Owner
Actix
Actix - web and actor frameworks for Rust
Actix
A (flash) message framework for actix-web. A port to Rust of Django's message framework.

actix-web-flash-messages Flash messages for actix-web Web applications sometimes need to show a one-time notification to the user - e.g. an error mess

Luca Palmieri 31 Dec 29, 2022
Volt - A powerful, fast and memory safe package manager for the web

Volt - A powerful, fast and memory safe package manager for the web

Volt Package Manager 811 Dec 30, 2022
A simple authentication flow using Rust and Actix-web, with a PostgreSQL database and a sveltekit frontend.

Rust-auth-example This repository aims to represent a simple authentication flow using Rust and Actix-web, with a PostgreSQL database and a sveltekit

Kival Mahadew 4 Feb 19, 2023
Web Application with using Rust(Actix, Diesel and etc)

Santa Service App Used technology stack Web Server with using Rust (Actix, Actix-web, Diesel) Data base (Postgres) Console Application (Tokio) Tasks o

null 3 Jan 8, 2023
An API project using Rust, Actix Web and JWT. *WIP*

Actix-web REST API with JWT (WIP) A simple CRUD backend app using Actix-web, Diesel and JWT Require Rust Stable Postgres Or using Docker How to run Ma

Akhil Sharma 4 Sep 21, 2023
A newsletter with actix-web and sqlx-postgres

Newsletter backend Health check: production Pre-requisites You'll need to install: Rust Docker There are also some OS-specific requirements. Windows c

Nadeem Bhati 4 Dec 10, 2022
RESTful Todo API with Actix-web and SeaORM. Documented by swagger-ui

RESTful Todo RESTful Todo API with Actix and SeaORM. Documented by swagger-ui Prerequisites Rust Usage Clone the repository and run the following comm

Awiteb 4 Dec 27, 2022
Thruster - An fast and intuitive rust web framework

A fast, middleware based, web framework written in Rust

null 913 Dec 27, 2022
Seed is a Rust front-end framework for creating fast and reliable web apps with an Elm-like architecture.

Seed is a Rust front-end framework for creating fast and reliable web apps with an Elm-like architecture.

null 3.6k Jan 6, 2023
Perseus is a blazingly fast frontend web development framework built in Rust with support for major rendering strategies

Perseus is a blazingly fast frontend web development framework built in Rust with support for major rendering strategies, reactivity without a virtual DOM, and extreme customizability

arctic_hen7 1.2k Jan 8, 2023
Super Fast & High Performance minimalist web framework for rust

Super Fast & High Performance minimalist web framework for rust

null 6 Oct 12, 2022
Sauron is an html web framework for building web-apps. It is heavily inspired by elm.

sauron Guide Sauron is an web framework for creating fast and interactive client side web application, as well as server-side rendering for back-end w

Jovansonlee Cesar 1.7k Dec 26, 2022
Ergonomic and modular web framework built with Tokio, Tower, and Hyper

axum axum is a web application framework that focuses on ergonomics and modularity. More information about this crate can be found in the crate docume

Tokio 7.9k Dec 31, 2022
A simple, modular, and fast framework for writing MEV bots in Rust.

What is Artemis? Artemis is a framework for writing MEV bots in Rust. It's designed to be simple, modular, and fast. At its core, Artemis is architect

Paradigm 1.4k Jun 26, 2023
A rust web framework with safety and speed in mind.

darpi A web api framework with speed and safety in mind. One of the big goals is to catch all errors at compile time, if possible. The framework uses

null 32 Apr 11, 2022
A full-featured and easy-to-use web framework with the Rust programming language.

Poem Framework A program is like a poem, you cannot write a poem without writing it. --- Dijkstra A full-featured and easy-to-use web framework with t

Poem Web 2.2k Jan 6, 2023
Demo of Rust and axum web framework

Demo of Rust and axum web framework Demonstration of: Rust: programming language that focuses on reliability and stability. axum: web framework that f

Joel Parker Henderson 115 Dec 29, 2022
The simplest build-time framework for writing web apps with html templates and typescript

Encoped A build-time fast af tool to write static apps with html and TypeScript Features Template-based ESLint, Prettier and Rollup integration No ext

null 1 Dec 11, 2021
Hirola is an opinionated web framework for that is focused on simplicity and predictability.

Hirola Hirola is an opinionated web framework for that is focused on simplicity and predictability. Goals Keep it simple. Most Rust web frameworks hav

null 27 Nov 3, 2022