This page lists the Rust libraries, frameworks and build tools Niro was tested against, and whether it recognised each one.

What the marks mean.

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 = true
yes: 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)