Supported in Rust
This page lists the Rust libraries, frameworks and build tools Niro was tested against, and whether it recognised each one.
What the marks mean.
- Supported: Niro recognised every way of using it that the test code tries.
- Partly: Niro recognised some of those ways, or recognised one only in part.
- Not yet: Niro did not recognise it in the test code.
The test code is made up for the purpose: one small service per library, with the names invented. So "supported" means Niro recognised it there. It is good evidence, but it is not a promise about every codebase. If Niro misses something in your code, the coverage audit reports the gap on its own (see Coverage audit).
The test catalog also holds 4 look-alike cases for Rust: code that Niro must NOT take for a route, a call or a store. They test that Niro ignores the look-alike, so they are left out of this page and its counts.
Web frameworks and HTTP servers (the routes your code serves)
10 supported, 0 partly, 4 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| actix-web | supported | yes: #[get("/path")] attribute on an async fn, registered with App::service yes: #[route(path, method = "PUT", method = "PATCH")] yes: web::scope(prefix).route(path, web::get().to(handler)) yes: web::resource(path).route(web::post().to(handler)) yes: App::new().route(path, web::get().to(handler)) |
| axum | supported | yes: Router::new().route(path, get(h).post(h2)) yes: second verb chained on the method router: get(h).post(h2) yes: Router::nest(prefix, sub_router()) from another module yes: Router::merge(other_router()) built by a helper function |
| gotham | not yet | no: build_simple_router(|route| route.get(path).to(h)) |
| hyper | not yet | no: service_fn(route) with match (req.method(), req.uri().path()) arms |
| iron | supported | yes: router.get(path, handler, route_id) |
| ntex | supported | yes: #[web::get(path)] attribute yes: App::new().route(path, web::delete().to(h)) |
| poem | supported | yes: Route::new().at(path, get(h).post(h2)) with #[handler] fns |
| poem-openapi | not yet | no: #[oai(path, method)] inside #[OpenApi] impl, nested under a prefix |
| rocket | supported | yes: #[get("/x/<id>")] attribute, mounted with routes![] under a prefix yes: #[route(PUT, uri = "...")] yes: #[post(path, data = "<body>")] |
| salvo | supported | yes: Router::with_path(p).get(h).post(h2).push(Router::with_path("<id>").get(h3)) |
| tide | supported | yes: app.at(path).get(h).post(h2) |
| tiny_http | not yet | no: for request in server.incoming_requests() with match on (method, url) |
| utoipa | supported | yes: #[utoipa::path(get, path = ...)] on an axum handler |
| warp | supported | yes: warp::path!("x" / u32).and(warp::get()).and_then(h) yes: warp::path("x").and(warp::post()).and(body).and_then(h) |
The language's own HTTP server
0 supported, 0 partly, 1 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| std::net::TcpListener | not yet | no: TcpListener::bind + match on the request line string "GET /path HTTP/1.1" |
HTTP client libraries (the calls your code makes to other services)
5 supported, 2 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| attohttpc | supported | yes: attohttpc::get(url).send() |
| awc | supported | yes: awc::Client::default().get(url).send() |
| hyper | partly | no: hyper_util legacy Client; Request::builder().method(..).uri(url); client.request(req) yes: client.get(Uri::from_static(url)) |
| isahc | supported | yes: isahc::get(url) yes: HttpClient::new()?.post_async(url, body) |
| reqwest | partly | yes: let client = Client::new(); client.get(literal_url).send().await yes: reqwest::Client::new().post(url).json(&body).send() yes: reqwest::get(url) module function no: client.request(Method::DELETE, format!("{}/x/{}", CONST_BASE, id)) on a ClientBuilder-built client no: base URL from std::env::var with a literal fallback, joined with format! yes: reqwest::blocking::Client::new().get(url).send() no: client held in a struct field, base URL passed to new(), call in a method |
| surf | supported | yes: surf::get(url).recv_string() yes: surf::Client::new().get(url) |
| ureq | supported | yes: ureq::get(url).call() yes: ureq::post(url).send_json(..) yes: let agent = AgentBuilder::new().build(); agent.get(url).call() |
The language's own HTTP client
0 supported, 0 partly, 1 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| std::net::TcpStream | not yet | no: TcpStream::connect(host) then write_all(b"GET /path HTTP/1.1...") |
gRPC
1 supported, 1 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| grpcio | supported | yes: server, form implements: impl <S> for T with RpcContext and UnarySink, create_<s>(impl) registration |
| tonic | partly | yes: server, form implements: #[tonic::async_trait] impl <S> for T, trait imported from pb::<s>_server yes: tonic::include_proto!("pkg") names the proto package used in the wire path yes: registration: Server::builder().add_service(<S>Server::new(impl)) no: client, form factory: <S>Client::connect(literal_url) then client.<rpc>(Request::new(..)) no: client, form constructor: Channel::from_static(url).connect(); <S>Client::new(channel) yes: client, form factory with an address from std::env::var |
Databases and data stores
8 supported, 4 partly, 8 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| aws-sdk-dynamodb | supported | yes: client.put_item().table_name(t).item(..).send() |
| aws-sdk-s3 | supported | yes: client.put_object().bucket(b).key(k).send() |
| deadpool-postgres | supported | yes: let client = pool.get().await?; client.query(sql, &[]) |
| diesel | partly | no: table DSL: invoices::table.filter(col.eq(x)).load::<T>(conn) no: diesel::insert_into(table).values(&x).execute(conn) yes: raw SQL: diesel::sql_query(sql).load(conn) |
| elasticsearch | not yet | no: client.index(IndexParts::IndexId(index, id)) / search(SearchParts::Index(&[index])) |
| memcache | not yet | no: memcache::connect(url); client.set(key, v, ttl) |
| mongodb | not yet | no: client.database(db).collection(name) then insert_one / find / delete_many |
| mysql_async | supported | yes: conn.query_drop(sql) and conn.exec_first(sql, params) |
| postgres | supported | yes: postgres::Client::connect(..) then client.query(sql, &[]) |
| qdrant-client | not yet | no: client.upsert_points(UpsertPointsBuilder::new(collection, points)) |
| redis | not yet | no: con.set(key, v) / con.get(key) through redis::AsyncCommands no: redis::cmd("HSET").arg(key)...query_async(&mut con) |
| rocksdb | not yet | no: DB::open_default(path); db.put(k, v); db.get(k) |
| rusqlite | supported | yes: conn.execute(sql, params![..]) |
| scylla | supported | yes: session.query_unpaged(cql, values) and session.prepare(cql) |
| sea-orm | partly | no: Entity::find().all(db) with #[sea_orm(table_name = ...)] on the model no: ActiveModel { .. }.insert(db) yes: db.query_all(Statement::from_string(backend, sql)) |
| sled | not yet | no: sled::open(path) then db.open_tree(name).insert(k, v) |
| sqlx | partly | yes: sqlx::query_as::<_, T>(sql).bind(x).fetch_one(pool) partly: sqlx::query!(sql, args).execute(pool) yes: sqlx::query_scalar(sql).fetch_one(pool) yes: query(sql).execute(&mut *tx) inside pool.begin() yes: shared table: main writes orders that services/sqlx reads |
| surrealdb | not yet | no: db.select(table) and db.query(surql) |
| tiberius | supported | yes: client.query(sql, &[&p]) on SQL Server |
| tokio-postgres | partly | yes: client.query(sql, &[]) on a connected Client no: let stmt = client.prepare(sql); client.execute(&stmt, ..) |
Messaging and events (queues, topics, streams)
6 supported, 4 partly, 5 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| apalis | not yet | no: storage.push(Job); WorkerBuilder::new(name).backend(storage).build_fn(handler) |
| async-nats | partly | no: client.subscribe(subject) then .next() no: client.publish(subject, payload) no: client.request(subject, payload) yes: async_nats::jetstream::new(client).publish(subject, payload) partly: shared subject: main publishes shipments.created |
| aws-sdk-sns | supported | yes: client.publish().topic_arn(arn).message(m).send() |
| aws-sdk-sqs | partly | yes: client.send_message().queue_url(url).message_body(b).send() no: client.receive_message().queue_url(url) in a polling loop partly: shared SQS queue URL: main sends to refunds |
| crossbeam-channel | supported | yes: in-process: crossbeam_channel::unbounded(); s.send(x); r.recv() |
| google-cloud-pubsub | not yet | no: client.topic(name).new_publisher(None).publish(msg) |
| lapin | partly | no: channel.basic_publish(exchange, routing_key, ..) no: channel.basic_consume(queue, consumer_tag, ..) then stream partly: shared queue: main publishes to the default exchange with routing key invoice-emails |
| pulsar | partly | partly: pulsar.producer().with_topic(t).build(); producer.send(..) yes: pulsar.consumer().with_topic(t).with_subscription(s).build() |
| rdkafka | supported | yes: FutureProducer.send(FutureRecord::to(topic).payload(..), timeout) yes: BaseProducer.send(BaseRecord::to(topic)) yes: StreamConsumer.subscribe(&[topic]); consumer.recv() yes: shared topic: main produces orders.placed that services/rdkafka consumes |
| redis | not yet | no: con.publish(channel, msg) no: client.get_async_pubsub(); pubsub.subscribe(channel); on_message() |
| rumqttc | supported | yes: AsyncClient.subscribe(topic, qos) / publish(topic, qos, retain, payload) yes: client.subscribe(topic, qos) yes: shared MQTT topic: main publishes warehouse/temperature |
| std::sync::mpsc | supported | yes: built-in in-process: std::sync::mpsc::channel(); tx.send(x); for x in rx |
| tokio-cron-scheduler | not yet | no: JobScheduler::new(); sched.add(Job::new(cron, closure)) |
| tokio::sync | supported | yes: in-process: tokio::sync::mpsc::channel(); tx.send(x).await; rx.recv().await yes: in-process: tokio::sync::broadcast::channel(); tx.send(x) |
| zmq | not yet | no: ctx.socket(zmq::PUB).bind(..).send(msg); SUB set_subscribe(prefix) |
Build tools and package managers
3 supported, 0 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| Bazel rules_rust | supported | yes: MODULE.bazel + BUILD.bazel with rust_binary and rust_library, no Cargo.toml |
| Cargo | supported | yes: one package with src/main.rs, src/<mod>.rs, tests/ and inline #[cfg(test)] tests |
| Cargo workspace | supported | yes: virtual manifest with members listed by path; two binaries depend on a library by path yes: members by glob (crates/*), exclude, default-members yes: [workspace.package] and [workspace.dependencies] with a path dependency inherited by x.workspace = trueyes: a proc-macro crate ([lib] proc-macro = true) used by a service through a derive |
Project and folder layouts
5 supported, 0 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| Cargo | supported | yes: one package with src/lib.rs, src/main.rs, src/bin/*.rs, examples/ and benches/ yes: build output target/ beside Cargo.toml with no .gitignore yes: sibling crates with no workspace, path dependencies, one renamed with package = |
| Cargo + cc | supported | yes: build.rs compiles native/*.c with the cc crate; a CMakeLists.txt sits beside Cargo.toml |
| Cargo build script | supported | yes: build.rs writes code to OUT_DIR, included with include!(concat!(env!("OUT_DIR"), ..)); target/ listed in .gitignore |
| cargo vendor | supported | yes: vendor/ holding third-party crates, wired by .cargo/config.toml [source.vendored-sources] |
| Tauri | supported | yes: a web front end (package.json, src/) with the Rust backend in src-tauri/ (Cargo.toml, tauri.conf.json) |