Tide
MIO
Our great sponsors
Tide | MIO | |
---|---|---|
30 | 21 | |
4,931 | 6,012 | |
1.1% | 1.6% | |
6.6 | 8.5 | |
3 months ago | 4 days ago | |
Rust | Rust | |
Apache License 2.0 | MIT License |
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.
Tide
-
Latest Zen Kernel......
Rust has several, production ready, REST API frame works.
- Which Web Framework do people recommend for Rust in 2023?
-
Becoming Rustacean:Awesome Free Online Resources to Learn Rust Programming
Rust allows me to mainly only run the application to confirm things work from a business perspective.
For people starting out building stuff in rust - understand that there is a distinction of async code and libraries and can lead to confusing compiler errors if you don't realize there is a distinction. It's simple in hindsight but did cause me to waste hours barking up the wrong trees at first. Other wise just learn about `match` and Result/Option types asap, they're fundamental.
https://github.com/http-rs/tide tide is great to create an http server / routes
https://github.com/djc/askama I use this to template out HTML and it checks all my boxes, dynamic data, passing in functions, control flow.
https://github.com/launchbadge/sqlx sql interface for a variety of backend, async safe.
https://github.com/seanmonstar/reqwest http client to make requests
Rust is amazing, don't let the initial few speed bumps discourage you - building real things with rust is no more challenging today than any other modern language stack.
-
Use of Salvo for a REST Api
https://crates.io/crates/salvo - 581k all time and peak daily of ~2750 in last few months https://crates.io/crates/rocket - 2.68mil all-time / ~6200 daily https://crates.io/crates/actix-web - 9.8mil all-time / ~21k daily https://crates.io/crates/axum - 8.8mil all-time / 64k daily https://crates.io/crates/warp - 7.9mil all-time and 19k daily https://crates.io/crates/tide - 886k all-time / 2250 daily
-
Which Rust web framework to choose in 2022 (with code examples)
tide
-
Is Rust good choice for the backend of any mobile application?
I'm developing the backend of https://www.cozydate.com/ in Rust. Async Rust is not productive yet, so I tried rouille http server which lets me write non-async request handlers. Unfortunately, it uses an unbounded thread pool and falls down under load https://github.com/tiny-http/tiny-http/issues/221 . Then I tried Tide and a threadpool to call my non-async API handlers. This worked, but was really ugly, and I had issues with uploads after deploying to Heroku https://github.com/http-rs/tide/issues/878 .
- Ask HN: Anyone using Rust for server side application development?
-
Hey rustaceans, which web framework you guys suggest for a small application?
Because you suggested it might be small I’d suggest tide. it is the flask/express/sinatra of rust: it handles routing, dealing with http parsing, and building http responses, and thats pretty much it. I havent done a thorough comparison, but my guess is its dependency footprint is a bit smaller (comparatively to other frameworks), which is nice.
-
Warp or Rocket.rs or Actix Web?
I enjoy the API of tide, but development seems to have slowed down a bit compared to other frameworks https://github.com/http-rs/tide/commits/main
-
Easiest web api framework?
tide
MIO
-
RFC: A non-blocking networking library for Rust
How does it compare to mio?
-
Looking for Tokio's event loop source code
The real implementation details of the I/O event queue is done in mio as u/hniksic pointed out, but that's more comparable with libuv which is certainly a huge part of the Node runtime. mio and libuv have a lot of similarities (at least they used to).
You are probably looking for mio, which tokio uses for its event loop needs.
-
Python multi-level break and continue
My example was "twice by one developer", not "twice across all indexed repos."
A spot check shows that quite a few in your link are used specifically to ensure correct handling of Rust multi-level breaks work syntax, like https://github.com/rust-lang/rust-analyzer/blob/master/crate... , https://github.com/rust-lang/rustfmt/blob/master/tests/sourc... , https://github.com/rust-lang/rust/blob/master/src/tools/rust... , https://github.com/rust-lang/rust/blob/master/src/tools/rust... and likely more.
Another is a translation of BASIC code to Rust, using break as a form of goto. https://github.com/coding-horror/basic-computer-games/blob/e...
The example at https://github.com/tokio-rs/mio/blob/master/tests/tcp.rs is a nice one
// Wait for our TCP stream to connect
-
Ask HN: Has any Rust developer moved to embedded device programming?
On the code side it's pretty much the same as C++. You have a module that defines an interface and per-platform implementations that are included depending on a "configuration conditional checks" #[cfg(target_os = "linux")] macro.
https://github.com/tokio-rs/mio/blob/c6b5f13adf67483d927b176...
-
`wasm32-wasi` support added to Tokio
Made possible by Wasi support for Mio https://github.com/tokio-rs/mio/pull/1576
-
What are the best software libraries which implement great abstractions (language agnostic)?
mio (rust), which seems to be an even better cross-platform I/O abstraction than libuv, which is what Node.js's nice abstraction was is built around (libuv).
-
Monoio – A thread-per-core Rust async runtime with io_uring
If you need to handle <100,000 sockets, you will probably be fine with a thread per socket. Call set_read_timeout to implement the deadline. Run load tests and adjust the socket limit.
Async lets one process handle millions of sockets.
If you want to handle millions of sockets with threads, you can use `mio` [0]. Mio's API has footguns that can cause UB. If your wire protocol is complicated, you may find yourself implementing something like async, but worse.
You can absolutely do readiness-based IO. Either call the system-specific APIs or use the MIO library, which is a low-level platform abstraction for that: https://github.com/tokio-rs/mio
-
aquatic_udp BitTorrent tracker now achieves up to 1.3 million responses per second
There are now two implementations: the old one using mio and a new, experimental one using glommio, an io_uring thread-per-core framework that requires a recent Linux kernel.
What are some alternatives?
actix-web - Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.
tokio
Rocket - A web framework for Rust.
rust-zmq - Rust zeromq bindings.
tokio - A runtime for writing reliable asynchronous applications with Rust. Provides I/O, networking, scheduling, timers, ...
yourcontrols - Shared cockpit for Microsoft Flight Simulator.
glommio - Glommio is a thread-per-core crate that makes writing highly parallel asynchronous applications in a thread-per-core architecture easier for rustaceans.
Nickel - An expressjs inspired web framework for Rust
actix - Actor framework for Rust.
message-io - Fast and easy-to-use event-driven network library.
libpnet - Cross-platform, low level networking using the Rust programming language.
The FastCGI Rust implementation. - Native Rust library for FastCGI