Crate of the Week

I’d like to nominate Kanata:

Kanata is a software keyboard remapper for Linux and Windows. I use it to get some advanced features from my standard laptop keyboard, remapping spacebar as an extra modifier keys which moves arrows ad other navigation keys to my home row.


I've created an SMTP server for the test and development environment in Rust.

The web interface is developed with Yew frameworks compiled to web assembly and the Backend uses Axum and Tokio.

How is this different from using clippy config files? The project readme doesnt explain this. It only says

Doing this with just Rust/Cargo/Clippy can be a bit of a pain.

1 Like

AFAIK: Clippy Config Files enable specifying configuration values for lints.

To enable lints, one has to include them in the via #![warn(clippy::...)],
which can become quite wordy.
My Cranky.toml currently contains 140 lints, which are allow by default.

And then if i run cargo clippy i no longer can distinguish between genuine clippy lints
and those which which are just pedantic or have false positives (nursery), or i want
to allow for some fn like clippy::too_many_lines.

I like the 3 step approach, which gives me 3 levels of priority, what to fix or look at.

1 Like

I nominate release-plz:

Release-plz helps you release your Rust packages by automating:

  • CHANGELOG generation.
  • Creation of GitHub/Gitea releases.
  • Publishing to
  • Version bumps in Cargo.toml.
1 Like

I nominate

It provides highly-ergonomic abstractions for generating proc macro parsers. The user writes types which represent the nodes in the syntax tree (enums for alternatives, structs for sequences), the crate does the rest.


I nominate rustypaste:

Rustypaste is a minimal file upload/pastebin service which has the following features:

  • File upload & URL shortening & upload from URL
  • Single binary/configuration
  • Easy to deploy via docker
  • No database
  • Self-hosted
  • Written in Rust :crab:

I nominate css-inline

css-inline is designed for scenarios such as preparing HTML emails or embedding HTML into third-party web pages:

  • Built on top of html5ever, cssparser, and selectors
  • Inlines CSS from style and link tags
  • Resolves external stylesheets (including local files)
  • Supports HTML5 & CSS3
  • Has Python, Ruby, and WASM bindings
1 Like

Self nominating dysk (was previously known as lfs but not announced here)




I've made quite a lot of self-nominations in this thread already, let me know if I should stop :slight_smile: Anyway here's another one.

A search-and-replace tool with slightly more features than fastmod.

1 Like

Self-nominating eyeball, a crate that implements the observable pattern for (async) Rust.

As of the latest release from yesterday, it supports (optional) async-aware locking so that you can lock the inner value of an observable for writing across .await points.
Actually, this was already possible before with an async RwLock wrapping Observable<T>, but the new solution of SharedObservable<T, AsyncLock> is more convenient and efficient.

I am going to self-nominate a crate of mine called complate.
complate is a text templating tool for the terminal which allows templating files in interactive mode (with user prompts via tui) or in headless mode.
I've used it in many projects for templating HELM value files, using it as template for semantic commit messages in repos, updating configuration files and more.

  2. GitHub repo
1 Like

allocator-api2: Use the unstable Allocator API on stable Rust!

I'd like to nominate a crate on which I have worked, googletest.

GoogleTest Rust is a test assertion library based on the well-known C++ testing library GoogleTest. It has an extensive set of matchers which can be composed to easily write precise test assertions on complex data structures.

  2. GitHub
1 Like

I nominate Ratatui:


I would like to nominate a ecosystem of crates I have worked on in the past month. It's a full port of the infamous Tower official crates to make use of the new upcoming (for now nightly only) async static fn trait possibilities. Bridging between the two worlds is possible as well. does not compile for now due to a bug in cargo doc, in regards to async static fn trait, but once that bug is fixed the documentation should be live as well. It's a new bug, because I use toolchain nightly-2023-07-07 where it does compile docs fine.

Feedback welcome. I mostly nominate it as I think with the upcoming stabilization of this feature, and given the fact that Rust Lang is promoting it via medium such as its blog, the community and rust ecosystem as a whole probably wants to start thinking about this and preparing for it, as it might be able to simplify a lot of code, even though it will require a major version update due to the massive breaking nature.

Beyond the fact that tower-async makes use of async static fn traits instead of hand written futures, it also got rid of the entire poll_ready concept, making the Service contract a lot simpler as well.

I'd like to nominate fastar: a faster equivalent of tar -cT <(find . -type f) , optimized for tarring many small files stored on HDDs. Fastar utilizes the disk layout of files to minimize random seeks on HDD and maximize contiguous lookaheads.


I'd like to nominate r3bl_tui crate. It is a text user interface engine (TUI) that is inspired by web technologies (DOM, React, Redux, and contemporary web development design patterns) but re-imagined for user interaction in a terminal emulator.

Self-nominating deep_causality, which is the first computational causality crate for Rust and the first library that brings context-aware reasoning to causal hyper-graph structures.


I'm sorry, but this passage is so full of jargon I'm not sure whether you are being genuine or if it's like the "Turbo Encabulator" engineering gag from the 40's.