Crate of the Week

Kondo: clean up build artifacts in rust and other types of projects.

1 Like

Self-nomination: sqids. Helps you generate short unique ids from numbers (useful in url shortening, etc).


let sqids = Sqids::default();
let id = sqids.encode(&[1, 2, 3])?; // "86Rf07"
let numbers = sqids.decode(&id); // [1, 2, 3]
1 Like

I would like to suggest rouille, a small synchronous web framework, built on tiny-http. It is easier to get started with than its asynchronous alternatives like axum and it has become my default for small size web projects.
I would love to see it featured in Crate of the Week as this project seems to be overlooked often in web framework land, undeservedly so!


I would like to nominate fast_pool
a fast async pool based on channel。
You can think of it as a substitute for connection pools such as deadpool and mobc

  • support get(),get_timeout(),state() methods
  • support atomic max_open(Resize freely)
  • Fewer code, clearer logic, less prone to bugs
  • based on flume channel

way fast_pool?

  • fast get() method performance
//---- bench_pool stdout ----
//use Time: 4.0313ms ,each:40 ns/op
//use QPS: 24749412 QPS/s
//---- bench_pool stdout ----
// use Time: 6.373708ms ,each:63 ns/op
// use QPS: 15683710 QPS/s

Self-nomination: named-sem. This is a wrapper for named semaphore in Linux & Windows.


let mut semaphore = NamedSemaphore::create("/my-semaphore", 3)?;

semaphore.wait_then_post(|| {

I would like to recommend ractor a very friendly and easy to use actor framework that I have been very happy with when working on my latest project :slight_smile:


Self nomination: apistos , an OpenAPI documentation tool exposing OAS 3.0 models as well as an actix-web wrapper similar to paperclip.


Hey! long time reader, first time writer (creating an account wasn't that bad)
For next week, I'd like to self nominate GitHub - astrale-sharp/typstfmt
It's a formatter for the typst language, It's far from perfect yet but It's going through it's second iteration atm.



Self-nomination: commit-emoji a git post-commit hook to add pretty emoji to your otherwise dull conventional commits (and a couple qol improvements like replacing predefined commit messages with longer versions, e.g. "bumpdeps" -> "fix: :arrow_double_up: Update dependencies")

Self nominating page-turner as, probably, the first announced library which supports stabilized async in traits.

page-turner is a utility to work with paginated APIs. You specify how to query a single page and then page-turner provides async streams that query all pages automatically and allow to process data as if pagination doesn't exist.


Self nominating Apache Iceberg Rust, the native rust implementation of Apache Iceberg.

iceberg-rust helps to bring apache iceberg to rust, and is designed to be fast, jvm free.


Self nominating double-ended-peekable.

double-ended-peekable is a tiny no-std crate that combines the concepts of Peekable and DoubleEndedIterator, in order to easily peek from both the front and the back of an iterator.

1 Like


sosecrets-rs, secrets management with compile time guarantees that each secret is not exposed more than a certain integer number of times. Each secret when exposed is branded with a unique type that ensures has an invariant lifetime.

Secret<T, MEC: typenum::Unsigned, EC, typenum::Unsigned> uses the typenum crate to enable compile time counting of the number of exposure of the secret and if EC is greater than MEC, the program would not compile.

Here is an example of how one can use it:

use sosecrets_rs::{
use typenum::U2;

// Define a secret with a maximum exposure count of 2
let secret = Secret::<_, U2>::new("my_secret_value".to_string());

// Expose the secret and perform some operations with the exposed value; secret has been exposed once: `EC` = 1, `MEC` = 2;
let (next_secret, exposed_value) = secret.expose_secret(|exposed_secret| {
    // `exposed_secret` is only 'available' from the next line -------
    assert_eq!(&*exposed_secret.as_str(), "my_secret_value"); //     ^
    // Perform operations with the exposed value                     |
    // ...                                                           v
    // to this line... -----------------------------------------------


I would like to self-nominate embedded-cli. It's a library that makes it easy to create CLIs on embedded devices. It has clap-like derive macro to build commands with enums and supports autocompletion, help, history, options and subcommands.
Example running on Arduino Nano:
Arduino Demo


I'd like to self-nominate rphonetic, a Rust port of Apache commons-codec phonetic algorithms.

Disclosure: bkmr has been crate of the week already (Crate of the Week - #1159 by sysid).

Why look at it again?

Fast CLI bookmark manager now got semantic search:

  • it understands the semantics of your search intention, not only keywords
  • find matches via OpenAI embeddings
  • and still being (relatively) fast...


Self-nominating microflow-rs, a robust and efficient TinyML inference engine for embedded systems.

With MicroFlow, it’s possible to locally run AI models on embedded systems. MicroFlow uses a compiler-based approach, making it possible to efficiently use the memory by pre-processing the model and statically allocating on the stack only.

MicroFlow has been tested with multiple MCUs and model architectures, including a speech command recognizer (TinyConv) on an 8-bit ATmega328 (Arduino Uno), a person detector (MobileNet v1) on an ESP32, and more.

Self-submitting Kind, a crate which makes it easier to wrap UUID in safe and visibly typed identifiers from Rust to the database and to the REST APIs.

I wrote a blog post explaining the motivation and usage: A Kind Introduction

Submitting Knope, a CLI tool that we're using to replace the semantic-release npm package everywhere we can. The maintainer is helpful and responsive, and the tool can handle fairly complex workspace configurations.

Self submitting GitHub - orottier/web-audio-api-rs: A Rust implementation of the Web Audio API, for use in non-browser contexts

It's a complete implementation of the Web Audio API specification, which you can now run in Rust or with our related NodeJS-bindings project. This means you can utilize your web audio expertise to build complex audio graphs in Rust, or make your game engine cross platform (web vs native) without rewriting your audio stack. It has been benchmarked against the browser implementations and we are also running the Web Platform Testsuite on it to verify correctness.

1 Like