Crate of the Week

jsonpath_lib: Implements a convenient query language for JSON, used by Rust for testing the rustdoc_json experimental backend.


I'm suggesting my crate drpc - Correct, high performance, robust, easy use Remote invocation framework

  • based T-L-V.for example: [Tag][Length][Value]
  • support Custom Serialization crate. for example: bincode,json,bson...any serde Serialization
  • support Load Balance.(Round/Random/Hash/MinConnect)
  • support Custom registry, microservices. see redis_registry
  • support tokio,this is async/await crate
  • high performance, Accept/Response only serialize the once and deserialization once. double of performance(qps) as fast as Tarpc (Google) with one server/one client
1 Like

I'd like to suggest heph if it hasn't been shared before.

I think the whole approach to actors with recovery is really neat as it's based around simple async fns, rather than entire async traits. It's early on, but very well documented!


I'd like to suggest the aliri family of crates, in particular aliri_actix, aliri_tower, and aliri_tokens.

aliri_tower and aliri_actix and provide a simple mechanism to plug JWT authentication and OAuth2 scopes authorization into your favorite web service project, whether axum, actix-web, or any other server that can use tower-http middleware.

aliri_tokens provides a means for a client using OAuth2 client credentials or refresh tokens to reliably and robustly renew those tokens in the background without impacting the latency of outgoing requests. This functionality will soon be expanded to support injecting authorization tokens using reqwest-middleware, a great crate in its own right.

These projects build on the functionality of aliri_oauth2 and the base JOSE implementation crate, aliri. They are maintained by the same author of the aliri_braid (a crate to combat stringly-typed interfaces) and aliri_base64 (a crate to make working with base64 encoded buffers friendlier) crates.

I wrote new unit/dimension support library.
Please check it out.

I'd like to nominate hash_hasher, a library for handling hash tables and hash sets when your keys are already hashes (for instance, cryptographic hashes). This avoids spending time competing the hash of a hash.

1 Like

Hi! I am the maintainer of async-stripe (rust bindings for the stripe api) which I think is ready for prime-time after a good year of on-and-off work.

We just released 0.14 this week which comes with a host of changes and we're reaching a stable API.


My bet crate (for "bynary expression tree") was noticed by nobody, maybe because it's a little abstract, but it could probably get more use.
It allowed me to implement query languages in a few dozens lines in several applications, for example queries like this one in lfs:

lfs -f 'size>2TB'


lfs -f '(disk=ssd | type=xfs) & free < 2.5G'

(it's also behind the fast queries in rhit and broot)


I submit my own new crate, impl-tools:

  • a variant on our beloved #[derive(Trait)] supporting where bounds, using and ignore
  • derive trait on definition for reference types
  • impl Self syntax to avoid repeated generics
  • implement Default on a struct using field initializers
  • extensible (but third-party macros cannot be extended in the same way as #[derive])

Status is barebones (only supports Clone, Debug, Default, Deref, DerefMut traits) but tested.

Hey! I'd like to nominate git-drive a nice CLI tool written by my friend and colleague knutwalker who helped me a lot getting started with Rust :slight_smile:

The tool is especially useful for teams who pair a lot and want to use the Co-Authored-By feature to give credit to everyone involved in a commit.

It's as simple as:

git drive with alice


➜ git drive
  Select any number navigator(s)
  Use [space] to select, [return] to confirm
❯ [✔] alice
  [ ] bob

and the corresponding Co-Authored-By lines are added to your commit message template.

Nice change. Much wow.

Co-Authored-By: Alice <>

# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.

Hacking alone? Simple:

git drive alone

I hope you guys like it as much as me and my team does :slight_smile:


I would like to self-nominate my crate num-order. It just reached version 1.0!

This crate is used to support numerically consistent ordering and hashing on various fundamental numeric types (including integers, floats, rational and complex numbers, etc.). This enables the comparing between different numeric types, which might be useful for implementing uniform numeric type and other applications.

Please see the readme for examples! Thank you :grin:

1 Like

Self nomination of hifitime, currently in version 3.1 (and no-std for most).

It's a high fidelity time management library that guarantees exactly one nanosecond precision for 32,768 years before 01 January 1900 and 32,767 years after that 01 January 1900. It supports several time systems: TAI, UTC, ET, TDB, and GPS time. It also includes high precision duration calculations like let dur: Duration = 23.hours() + 14.minutes();, so adding time zone support should straight forward. All epochs are stored in TAI under the hood in just 80 bits!


self nominating xbuild build/deploy a rust mobile/desktop app in less than 30 min

1 Like

actually, unnominating crate of the week. the crate will likely be renamed soon

I'd like to nominate the ttrpc crate, which implements "GRPC for low-memory environments." More information on the ttrpc protocol is available alongside the Go implementation.

1 Like

I'd like to self-nominate shuttle a crate that uses traits and annotations to configure your backend deployment - including databases. shuttle lets you deploy Rust apps with a single Cargo command


I'd like to nominate enum_dispatch.

enum_dispatch transforms your trait objects into concrete compound types, increasing their method call speed up to 10x.

I discovered it on this Reddit thread of crates considered essential.

1 Like

darkbird is an in-memory storage also
persist data to disk with non-blocking disk_log

Self-ish nominating rustdoc-types, which contains the types to deserialize the output of rustdoc --output-format json, allowing programatic access to a crates API without having to use all of rustc or rust-analyzer.


Build concurrent and multi-stage data ingestion and data processing
pipelines with Rust+Tokio. TokioSky allows developers to consume data efficiently
from different sources, known as producers, such as Apache Kafka and others.
inspired by elixir broadway