Looking for the Highest-Performance Rust Backend Stack: Actix-web vs Hyper+Tokio (and any lesser-known high-performance frameworks?)

help
1

Hello everyone,
I’m working on a performance-critical backend project in Rust — the API needs to handle extremely high throughput and very low latency. Because the project is sensitive, performance is my absolute top priority.

Right now, I’m stuck choosing between Actix-web and building my stack manually with Hyper + Tokio. I already understand both approaches, but I’m trying to figure out which one realistically delivers the highest performance possible in real production scenarios.

My questions to the community:

  1. For maximum performance, which approach tends to win today:

Actix-web (with its actor system & optimizations)

or a fully custom Hyper + Tokio setup?

  1. Are there any lesser-known frameworks, libraries, or runtime tools in Rust that outperform both for API servers? I don't mind complexity — I only care about stable, extreme performance.

  2. For those who have built high-load APIs, what stack did you end up using, and what were the results?

Any benchmarks, experience, or deep technical explanations are highly appreciated.
Thanks a lot!

2

Why not axum instead of hand-rolling your own hyper + tokio server?

2 Likes
3

I'd use axum. You can look at the tricks they use for techempower to get the absolute maximum performance

4

There are also backfork (how do you call fork of a project that's made by the original author after he was expelled from his own project?) of actix-web, ntex. It's, most likely, faster because Nikolay Kim is obsessed with speed… whether do you want to trust guy who tells you: “I need unit test that shows UB” and “ this patch is boring” to patch that fixes said UB… is another story.

You may get a nice bonus and if you plan to leave quickly enough and don't mind if the company that employs that service would go after Knight Capital, then it could the best choice…

5

May minihttp, but it uses stackful coroutines, so you can’t use rust async ecosystem with it

The current fastest framework that I tested in 2026 is ntex with neon-uring. It has higher performance than may minihttp and all tokio epoll based frameworks I tried

ntex = { version = "*", features = ["neon-uring"] }

That is also the first rust io uring server that I tested which finally has higher performance than rust epoll servers, even under low load it still performs better. Tokio uring, compio, glommio, monoio mostly perform similarly to rust epoll servers unless in very high load, but this one is really different, I was also very surprised

From my hello world benchmark yesterday on single thread machine, Ubuntu kernel version 5.15, which is not even the latest kernel version. In terms of latency, the results are the same, but in requests per second, there is a big gap

may minihttp = around 21.000 req/s

actix = around 19.000 - 20.000 req/s

axum = around 17.000 - 18.000 req/s

ntex tokio = around 18.000 req/s

ntex neon-uring = around 23.000 - 25.000 req/s

The gap will be even bigger if I scale that single thread to 8 threads machine. Io uring reduces syscalls and enables zero copy between user space and the kernel. The higher the load, the greater the total syscall reduction. For example, let’s say it reduces 100 syscalls per request, if the code runs 1.000 times because there are 1.000 requests, that results in 100 × 1.000 = 100.000 fewer syscalls. The same applies to zero copy benefit, the higher the load and the bigger the data size, the performance will also be higher. It should get even better when using newer io uring features in the newest kernel version

Tokio is currently also experimenting with io uring implementation directly inside tokio library under tokio-unstable flag

6

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.