I'd like to nominate anodized which is a fairly new crate that provides a standardized (and ergonomic) way to enforce specs in Rust code.
3 Likes
My suggestion is complex-bessel, a pure Rust implementation of Amos (TOMS 644) algorithm for computing Bessel, Hankel, and Airy functions of complex argument. No Fortran/C FFI dependencies — works on any target Rust supports.
1 Like
I would like to self-nominate docstr which is a crate that provides the macro docstr! for ergonomically creating multi-line string literals using documentation comments
use docstr::docstr;
let hello_world_in_c: &'static str = docstr!(
/// #include <stdio.h>
///
/// int main(int argc, char **argv) {
/// printf("hello world\n");
/// return 0;
/// }
);
assert_eq!(hello_world_in_c, r#"#include <stdio.h>
int main(int argc, char **argv) {
printf("hello world\n");
return 0;
}"#)
My favorite feature about docstr! is that it supports composition. Instead of creating docstr_println!, docstr_format!, docstr_format_args!, etc - docstr! takes another macro as the first argument, and passes the generated string literal into the passed macro.
use docstr::docstr;
let age = 21;
let name = "Bob";
let colors = ["red", "green", "blue"];
let greeting: String = docstr!(format!
//^^^^^^^ the generated string is passed to `format!`
// as the 1st argument
/// Hello, my name is {name}.
/// I am {age} years old!
///
/// My favorite color is: {}
// anything after the doc comments is passed directly at the end
colors[1]
);
//^ above expands to: format!("...", colors[1])
assert_eq!(greeting, "Hello, my name is Bob.\nI am 21 years old!\n\nMy favorite color is: green");
Ever since I made docstr, I ended up incorporating it into virtually every single one of my projects. Especially when writing tests. Here is a use-case for tests in one of my projects cargo-reedme that I just wrote a few minutes ago:
#[test]
fn update() {
let output = t(
docstr!(
/// Header
///
/// <!-- cargo-reedme: start -->
///
/// hello world
///
/// <!-- cargo-reedme: end -->
///
/// Footer
),
"goodbye moon",
)
.unwrap();
assert_str_eq!(
output,
docstr!(format!
/// Header
///
/// <!-- cargo-reedme: start -->
///
/// {}
///
/// goodbye moon
///
/// <!-- cargo-reedme: end -->
///
/// Footer
alert()
)
);
}
5 Likes
I'd like to self-nominate oxigdal!
What is it?
A 100% Pure Rust, cloud-native geospatial data abstraction library, designed as a modern alternative to the traditional C/C++ GDAL.
Why it matters:
If you've ever wrestled with gdal-sys build failures, massive Docker images, or C++ dependency hell just to read a GeoTIFF or GeoParquet, oxigdal is here to help. It compiles straight down to a statically linked binary with zero C/C++ dependencies.
It also brings to the table:
- SIMD-accelerated CRS math (transforms 1M points in < 10ms)
- Arrow-native GeoParquet integration
- WASM support for browser-based geospatial analysis
It's a big step towards a fully memory-safe, easily deployable GIS ecosystem in Rust.
Links:
- Crates IO: https://crates.io/crates/oxigdal
- Repo: https://github.com/cool-japan/oxigdal
2 Likes
I'd nominate hyper, it's the best and most mature http crate in the ecosystem and not a lot of people recommend it over something like reqwest so I think it deserves some attention
I'd like to self nominate ply-engine.
Ply is a cross-platform app engine for Rust that runs on Linux, macOS, Windows, Android, iOS, and the web. It has a builder-pattern + closure API, a flexbox-like layout engine, full text input with selection and undo/redo, GLSL shaders on any element, accessibility via AccessKit, a Chrome DevTools-style debug inspector, HTTP/WebSocket networking, and interactive WASM documentation with live code playgrounds.
Links:
I think that might be because they are written by the same person and hyper is meant to be a lower level crate and reqwest builds on top of it to give a more user friendly API for simple requests.
Thanks a lot for including "Crate of the Week" in this week in rust. I've learned about a lot of useful crates that I didn't know I was looking for. It's my first time recommending a create for create of the week and I'm not sure if there is more I'm meant to do than just provide the name. Please guide me if I miss the mark in that regard.
I came across a create office2pdf that converts office documents into PDFs. It's a very new crate and I haven't had time to dive deep into it nor research alternatives but I wasn't looking for it but was happy to become aware of it hence I'm sharing in case it's useful to someone else who also wasn't looking for it but benefits from being aware of it.
2 Likes
I would like to nominate numrs.
It is a high-performance numerical computing library, designed as a Rust-native alternative to NumPy. It provides N-dimensional arrays, linear algebra operations, SIMD optimization, GPU acceleration and in general looks like an interesting alternative to nalgebra, worth taking a glance. I was not using it heavily for any project so far but from description, I am impressed.
3 Likes
I would like to nominate sentencex, a sentence segmentation library.
This is developed by Wikimedia Foundation and I am core maintainer of it. It is used in various Wikipedia projects and other opensource projects.
Sentencex is the fastest sentence segmentation library. It can split the entire works of Shakespeare in 200milliseconds to 150K sentences.
Sentencex is written in Rust, with python, js bindings. Supports 300+ languages.
Thanks!
6 Likes
I would like to self-nominate grab for Crate of the Week.
It’s a high-performance, declarative bridge from delimited text to JSON. It’s designed to be a "schema-aware" ingress for pipelines using jq, replacing fragile awk/cut column indexing with a readable mapping syntax.
Features:
- Processes ~12.8M fields/sec (often hitting system pipe limits).
- Zero-copy, SIMD-accelerated architecture.
- Strict UTF-8 and schema validation (or just opt it out for flexibility).
- ~800KB static binary (Rust/musl).
Thank you very much!
2 Likes
I'd like to self nominate ResExt
ResExt is an error handling crate heavily inspired by anyhow and thiserror, it combines the ergonomics of anyhow with the performance of thiserror by defining a proc-macro attribute that generates From impls like thiserror and context methods like anyhow but with full no-std no-alloc support and minimal effects on performance using inline context buffers with optional heap spilling, lazily evaluated closures and minimum format_args!() possible while maintaining UTF-8 safety and providing custom formatting per error struct
Example
use resext::ctx;
use resext::resext;
use std::io::{Error, ErrorKind};
#[resext(alloc = true, delimiter = "\n -> ")]
enum AppError {
Io(Error),
Parse(std::num::ParseIntError),
}
fn read_config(path: &str) -> Res<String> {
let content: String = std::fs::read_to_string(path)
.context(ctx!("Failed to read file: {}", path))?;
if content.is_empty() {
return Err(ResErr::new(
"Content is is empty",
Error::new(ErrorKind::UnexpectedEof, "Data is empty"),
));
}
let value = content
.trim()
.parse::<i32>()
.context(ctx!("Failed to parse config value: {}", &content))?;
if value < 32 {
return Err(ResErr::from_args(
ctx!("Value: {} is less than 32", value),
Error::new(ErrorKind::InvalidData, "Data is less than 32"),
));
}
Ok(content)
}
The crate currently uses syn and quote for the proc-macro which I'm currently working on replacing with a manual proc-macro for improved compile times
1 Like
I would like to nominate VT Code, a semantic AI coding agent.
VT Code has a multi-layered security model (tree-sitter-bash command validation, macOS Seatbelt / Linux Landlock+seccomp sandboxing, configurable tool policies), multi-provider LLM support (OpenAI, Anthropic, Gemini, DeepSeek, Ollama, and more) with automatic failover, a Ratatui TUI, and ACP/A2A/MCP protocol support for editor integration. The workspace is a Cargo monorepo (~92% Rust) with fuzz targets, an eval framework, and cross-compilation support via cross. cargo install vtcode.
Thank you!