axum VS rust

Compare axum vs rust and see what are their differences.

axum

Ergonomic and modular web framework built with Tokio, Tower, and Hyper (by tokio-rs)

rust

Empowering everyone to build reliable and efficient software. (by rust-lang)
Our great sponsors
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • WorkOS - The modern identity platform for B2B SaaS
  • SaaSHub - Software Alternatives and Reviews
axum rust
149 2674
15,646 91,922
6.2% 2.8%
9.3 10.0
6 days ago 4 days ago
Rust Rust
MIT License GNU General Public License v3.0 or later
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.

axum

Posts with mentions or reviews of axum. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-02-21.
  • Prodzilla: From Zero to Prod with Rust and Shuttle
    6 projects | dev.to | 21 Feb 2024
    Moreover, I especially like where Rust is right now in the web space. It really feels like there’s a lot of smart people working on the next generation of web development tools - it feels like the place to be. There are a range of great open-source web dev tools that are just reaching critical levels of maturity. Axum, which I used to build Prodzilla, feels ready for out of the box web dev, and is crazy-performant, as I write about later. More recently available is Loco, a Rails-like framework for building web applications in Rust that's picking up steam. And in dev-tooling and hosting there’s Shuttle, a 1-line hosting solution for Rust backends.
  • CryptoFlow: Building a secure and scalable system with Axum and SvelteKit - Part 1
    3 projects | dev.to | 5 Jan 2024
    CryptoFlow is a full-stack web application built with Axum and SvelteKit. It's a Q&A system tailored towards the world of cryptocurrency!
  • Cryptoflow: Building a secure and scalable system with Axum and SvelteKit - Part 0
    12 projects | dev.to | 4 Jan 2024
    You also get to specify the accepted HTTP method of the URL via axum::routing. To answer its name, modularity, Axum also supports nested routes as we'll see later in this series. Next is the layer, a method used to apply tower::Layer to all routes before it. This means that routes added after the layer method will not have such a layer applied to their requests. In our case, we used the layer to add tracing to all HTTP requests and responses to our routes. This is needed for proper logging. The tower_http::trace::TraceLayer can even be really customised.
  • My first project with rust
    3 projects | /r/rust | 8 Dec 2023
    I build simple rust axum api server with Prisma client rust. This is my something done with rust and I really enjoyed rust!
  • Getting Started with Axum - Rust's Most Popular Framework
    5 projects | dev.to | 6 Dec 2023
    In this article we'll take a comprehensive look at how to use Axum to write a web service. This will also include the 0.7 changes.
  • Trying out Leptos: Fine-grained Reactive Framework for Rust
    4 projects | dev.to | 18 Oct 2023
    You have a couple of options for the underlying web framework to pair with Leptos: Axum or Actix. Axum seems to carry more favour currently, so we start with that. Assuming you already have Rust set up on your system:
  • Help required: Port kellnr from rocket.rs to axum
    2 projects | /r/rust | 6 Oct 2023
    I’m the author of https://kellnr.io. When I started working on Kellnr three years ago, https://rocket.rs was “the web framework” to use. Unfortunately, the project seems dead. Before adding more functionality using an unmaintained framework, I want to port Kellnr to https://github.com/tokio-rs/axum.
  • Grimoire - A recipe management application.
    7 projects | /r/rust | 5 Oct 2023
    Web Framework : axum.
  • Proper type for axum SSE stream
    2 projects | /r/learnrust | 29 Sep 2023
    I am trying to stream a response from the OpenAI API as an SSE with axum. I have combined the following examples from the async-openai and axum repos to produce the below code I've used iterators in Rust but have not used streams, I have no idea how to reconcile the types here and don't know where to start to solve the problem. A solution or any pointers would be greatly appreciated. https://github.com/tokio-rs/axum/tree/axum-v0.6.20/examples/sse https://github.com/64bit/async-openai/tree/main/examples/chat-stream ``rust async fn sse_handler( TypedHeader(user_agent): TypedHeader, ) -> Sse>> { println!("{}` connected", user_agent.as_str());
  • Introduction to the Tower library
    2 projects | dev.to | 23 Aug 2023
    -- axum README

rust

Posts with mentions or reviews of rust. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-03-25.
  • What Are Const Generics and How Are They Used in Rust?
    3 projects | dev.to | 25 Mar 2024
    The above Assert<{N % 2 == 1}> requires #![feature(generic_const_exprs)] and the nightly toolchain. See https://github.com/rust-lang/rust/issues/76560 for more info.
  • Algorithms for Modern Hardware
    2 projects | news.ycombinator.com | 13 Mar 2024
    There’s also other reasons. For example, take binary search:

    * prefetch + cmov. These should be part of the STL but languages and compilers struggle to emit the cmov properly (Rust’s been broken for 6 years: https://github.com/rust-lang/rust/issues/53823). Prefetch is an interesting one because while you do optimize the binary search in a micro benchmark, you’re potentially putting extra pressure on the cache with “garbage” data which means it’s a greedy optimization that might hurt surrounding code. Probably should have separate implementations as binary search isn’t necessarily always in the hot path.

    * Eytzinger layout has additional limitations that are often not discussed when pointing out “hey this is faster”. Adding elements is non-trivial since you first have to add + sort (as you would for binary search) and then rebuild a new parallel eytzinger layout from scratch (i.e. you’d have it be an index of pointers rather than the values themselves which adds memory overhead + indirection for the comparisons). You can’t find the “insertion” position for non-existent elements which means it can’t be used for std::lower_bound (i.e. if the element doesn’t exist, you just get None back instead of Err(position where it can be slotted in to maintain order).

    Basically, optimizations can sometimes rely on changing the problem domain so that you can trade off features of the algorithm against the runtime. These kinds of algorithms can be a bad fit for a standard library which aims to be a toolbox of “good enough” algorithms and data structures for problems that appear very very frequently. Or they could be part of the standard library toolkit just under a different name but you also have to balance that against maintenance concerns.

  • Rust: Actix-web and Daily Logging
    3 projects | dev.to | 13 Mar 2024
  • Groovy 🎷 Cheat Sheet - 01 Say "Hello" from Groovy
    7 projects | dev.to | 7 Mar 2024
    But that said, - and again I might be a bit biased - Groovy is too slow for me! I compared it to Rust in this LinkedIn post and it was waaaaay slow. Keep in mind that subjectively comparing programming languages might be a tricky business. But at the end, it will be up to your use case/project to prefer a language over the other.
  • Top Paying Programming Technologies 2024
    19 projects | dev.to | 6 Mar 2024
    13. Rust - $87,012
  • Dada, an Experiement by the Creators of Rust
    9 projects | news.ycombinator.com | 6 Mar 2024
    Yes, actually.

    https://github.com/rust-lang/rust/blob/d0ea1d767925d53b2230e...

    Limited to the rust codebase itself, but I'm sure the developers would force it on everyone else if they thought they could get away with it.

  • 7 Programming Languages Every Cloud Engineer Should Know in 2024!
    4 projects | dev.to | 5 Mar 2024
    Rust is gaining momentum in the cloud computing domain due to its emphasis on safety, speed, and concurrency without a garbage collector. These features make Rust an appealing choice for cloud engineers looking to develop high-performance, secure, and reliable cloud services and infrastructure. Rust's memory safety guarantees and efficient compilation to machine code position it as an ideal language for system-level and embedded applications in cloud environments, where performance and security are paramount.
  • Borrow Checking Without Lifetimes
    4 projects | news.ycombinator.com | 4 Mar 2024
    > I'm not sure what's neutered about Rust's current plans for generators

    They're neutered because they can't suspend and transfer control to a function other than the one that called them ("Note also that "coroutines" here are really "semicoroutines" since they can only yield back to their caller." https://lang-team.rust-lang.org/design_notes/general_corouti...) and you can't pass values into resume and get them out from the yield statement in the coroutine (https://github.com/rust-lang/rust/issues/43122#issuecomment-...).

    > and they aren't separate from async, they're the foundation that async desugars to.

    Yeah I just looked it up again and I don't know why I had it in my head that they were separate, you're correct, they are the same thing under the hood, so honestly that eliminates my biggest problem with them.

    > 'm also not sure what your objection is to Polonius, which, so far, is still just a strictly more permissive version of the borrow checker, with nothing new to learn on the user end.

    The entire model is different under the hood, though, since it switches from lifetimes+borrows to loans, and so in order to fully understand its behavior the user really would have to change their mental model, and as I said above I'm a huge fan of the lifetimes model and less so of the loan model. I just feel like it's much more natural to treat the ownership of a memory object and therefore amount of time in your code that object lives as the fixed point, and borrows as wrong for outliving what they refer to, then to treat borrows as the fixed point, and objects as wrong for going out of scope and being dropped before the borrow ends, because the fundamental memory management model of Rust is single ownership of objects, moves, and scope based RAII via Drop, so the lifetime of an object kind of is the more basic building block of the memory model, with borrows sort of conceptually orbiting around that and naturally being adjusted to fit that, with the checker being a way to force you to adhere to that. The loan based way of thinking would make more sense for an ARC-based language where references actually are more basic because objects really do only live for as long as there are references to them.

    4 projects | news.ycombinator.com | 4 Mar 2024
    > you can't pass values into resume and get them out from the yield statement in the coroutine

    I think that the linked comment is out of date, and that this is supported now (hard to tell because it hasn't been close enough to stabilization to be properly documented): https://github.com/rust-lang/rust/pull/68524

    As for Polonius changing the underlying mental model, I think this is a natural progression. Rust 1.0 tried to present a simple lexical model of borrowing, and then enough people complained that it has long since replaced the simple model with non-lexical lifetimes in order to trade simplicity for "do what I mean". And since it's not allowed to break any old code, if you want to continue treating borrowing like it has the previous model then that shouldn't present any difficulties.

  • Why do we need for an Undefined Behavior Annex to C++
    3 projects | news.ycombinator.com | 1 Mar 2024
    I don't see where those methods are getting called from a Unix signal handler but the code is complex enough that it's easy to miss, especially perusing through github instead of vscode.

    AFAICT those methods are called from `guard::current`. In turn, `guard::current` is used to initialize TLS data when a thread is spawned before a signal is generated (& right after the signal handler is installed): https://github.com/rust-lang/rust/blob/26907374b9478d84d766a...

    It doesn't look like there's any UB behavior being relied upon but I could very easily be misreading. If I missed it, please give me some more pointers cause this should be a github issue if it's the case - calling non async-safe methods from a signal handler typically can result in a deadlock which is no bueno.

What are some alternatives?

When comparing axum and rust you can also consider the following projects:

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

Rocket - A web framework for Rust.

carbon-lang - Carbon Language's main repository: documents, design, implementation, and related tools. (NOTE: Carbon Language is experimental; see README)

poem - A full-featured and easy-to-use web framework with the Rust programming language.

warp - A super-easy, composable, web server framework for warp speeds.

zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.

rust-web-framework-comparison - A comparison of some web frameworks and libs written in Rust

rust-web-benchmarks - Benchmarking web frameworks written in rust with rewrk tool.

ntex - framework for composable networking services

salvo - A powerful web framework built with a simplified design.

Nim - Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula. Its design focuses on efficiency, expressiveness, and elegance (in that order of priority).

Odin - Odin Programming Language