Crate of the Week

community
1620

I wish to self-nominate Test That!, a powerful test assertion library for Rust forked from GoogleTest Rust.

Test That! lets one easily write test assertions which clearly express the intent of the test and then automatically generates test failure messages which provide the full context on the failure. By using composable matchers, it supports asserting on complex data structures. This all makes test failures easier to diagnose, saving time and nerves.

See also the GitHub repository.

1621

I would like to self-nominate deconvolution, a comprehensive image deconvolution and restoration library. Features include known-PSF restoration, blind workflows, PSF/OTF conversion, preprocessing helpers, deterministic simulation fixtures, and support for 2D image arrays and 3D volume deconvolution. There are implementations spanning essentially every major practical deterministic deconvolution and image-restoration family (28 different deconvolution and restoration methods).

1622

I would like to self-nominate tiny-regex. Small (~2.5KB) regex engine for embedded systems.

  • no_std,
  • no alloc - all storage lives on stack,
  • memoization to prevent catastrophic backtracking.
1623

I'd like to nominate mqtt-typed-client for Crate of the Week.

It's a type-safe async MQTT client built on rumqttc. Instead of building
topic strings with format!() and parsing them back with split('/'), you
declare the topic shape once as a struct with #[mqtt_topic("...")] and get a
typed publisher, a typed subscriber that extracts the {params} for you, and
tree-based message routing, all checked at compile time. Topic parameters
round-trip through Display/FromStr, so they can be real types (u32, Uuid, an
enum) rather than always String.

It's a small, focused crate that turns a class of silent runtime bugs into
compile errors. Self-nomination, so take it with that grain of salt.
MIT/Apache-2.0, public issue tracker, docs on docs.rs.

Repo: GitHub - holovskyi/mqtt-typed-client: Type-safe async MQTT client for Rust. Topics as types, automatic routing and (de)serialization on top of rumqttc. Ā· GitHub

1624

I'd like to self-nominate wickra - streaming-first technical indicators with a Rust core. 514 indicators, each updating in O(1) per tick, zero dependencies, and one core that drives native Python, Node and WASM bindings plus a C ABI for C, C++, C#, Go, Java and R - same numbers in every language.

GitHub: GitHub - wickra-lib/wickra: Streaming-first technical indicators with a Rust core and Python, Node.js, WebAssembly, C ABI, .NET, Go, Java, and R bindings. 514 indicators, O(1) per-tick updates, no system dependencies. Drop-in TA-Lib replacement. Ā· GitHub

Live demo (514 indicators over live Binance data, in your browser): https://live.wickra.org

1625

Self-nominating collision2.

It's an experiment in 2D GPU-based particle system simulation powered by wgpu and the awesome wgsl-bindgen.

Everything is done on the GPU: no CPU<->GPU data transfer after the data is uploaded at startup.

  • SDF-based rendering: 6 million particles at 60 FPS on Radeon RX 560.
  • Grid-based collision broad phase, currently implemented using WGSL atomics (working on a more efficient prefix sum implementation utilising subgroup operations).
  • Efficient collision narrow phase employing bitcasts and CAS loop to store f32 forces.
  • Symplectic Euler integrator.
  • "Black holes"! Only gravitational attraction and frame dragging (Lense-Thirring) are implemented, no Minkowsky space-time or anything like that. Check out integrator.rs and the corresponding integrate.wgsl for details.
  • Zoom with mouse wheel.
Notes
  • Grid-based broad phase assumes particles of similar sizes. Performance degrades quickly if they differ significantly. There was a BVH-based broad phase, but I removed it for now. Look up the repo history if you want to check it out.
  • The code barely has any comments, because it requires some proficiency in GPU programming and the lion's share of it is self-explanatory if you have it. And I'm lazy.
  • Simulation step is the DT constant in `main.rs`
  • Indirect dispatch is utilised where appropriate to avoid CPU<->GPU data transfer.
  • Not published on crates.io since it's not a tool
  • Only tested on Manjaro Linux with RADV Vulkan driver on RX 560.
  • Definitely has bugs. If I had a dollar for each one I've found over the course of development, I could easily fund my beer-brewing hobby šŸ˜†

Any feedback is welcome, especially from GPU folks.

UPDATE: 6 million at 60 FPS only applies to rendering. Physics is nowhere near that.

1626

I want to self-nominate contnap.

This is a daemon that wake or shutdown gracefully containers (docker and podman are supported).

It detects containers through labels so no configuration file is needed to manually list containers. So it is a zero-config discovery.

How does it work?

contanap acts as a proxy for the port keeping it open. So when the first packet comes, it is buffered until the container is ready. Once ready, contnap flushes the buffer to the container and bridges the connection bidirectionally.

After being idle for a period of time, the janitor stop the container with a grace period before forcing shutdown.

Additional features

  • lifecycle hook (start/stop) where you can run a shell script (like mounting volume, notification, ...)
  • protocol agnostic: works for TCP and UDP (with stateful session tracking and idle pruning)
  • group management: you can group containers by setting a group name and if any container port is triggered it will start containers from the same group
  • For HTTP containers, it can display a waiting web page while starting
  • schedule gate to allow wake up in the time range you want
  • machine presence check to automatically start containers when machine comes online

Behind the hood, it uses mainly bollard and tokio crates.

There are equivalent in other languages but

  • Container Nursery seems to only listen for HTTP container and does not support TCP and UDP
  • Sablier seems primary HTTP focused but has integration with web servers (Traefik, Caddy, Nginx) with webhook and scaling features. There is Sablier Proxy that adds TCP support.

That is why I decided to make contnap.

I use it at work when running tests: it starts postgres and elastic (postgres could run all the time but Elastic is eating a lot of RAM even when idle).

1627

I am self-nominating my apis-saltans project, providing a Zigbee implementation including a coordinator API.
The most notable crates of the workspace are:

The hardware API is currently implemented for EZSP and tested successfully on a Siliconlabs MGM210P22A.

1628

I would like to self-nominating my dashu crate. This is not the first time to nominate it, but last time it unfortunately didn't get enough likes.

dashu is a Rust-native ergonomic library set of arbitrary precision numbers. It's a full alternative to the GMP + MPFR + MPC set, and its dashu-int is more efficient and feature complete compared to the de-facto standard num-bigint.

Please checkout my recent post on it if you are interested in it: Dashu is approaching v1.0: it's a full alternative to GMP+MPFR+MPC, and it's now more optimized

I hope the crate can obtain more attention and usage by make it mentioned in TWiR, because its v1.0 version will be landed by the end of the year. I hope I can get a good API design before commit its API as stable by v1.0.

1629

I would like to suggest my new jerrycan as the crate of the week.

It's an attempt to replace python flask but in rust and I designed it specifically with agents in mind. Would love to see what you think.

1630

I'd like to nominate xan for crate of the week. I stumbled upon it on accident, yet was impressed with the TUI-based visualizations and "jq for CSV"-type tooling.

1631

I'd like to self-nominate copycopy. It turns a global Ctrl/Cmd+C+C gesture (hold the modifier, press C twice) into a capture of the clipboard content plus the foreground app info, without ever consuming a normal single copy. Works on Windows, macOS, and GNOME Wayland, where it auto-installs a tiny Shell extension because Wayland allows no background observation. I extracted it from an app I'm building so the tricky parts could stand on their own.

1632

Iā€™m self-nominating cargo-efmt. It is a stop-gap solution for the missing .editorconfig support in cargo fmt and rustfmt that originates from my current discussion with the rustfmt team about whether such a feature might be added upstream. In either case, cargo efmt exists now as a functional solution: a drop-in replacement for cargo fmt which additionally respects (most) .editorconfig values for Rust files.

1633

another project hosted on codeberg : D

1635

I would like to nominate swift-topomap: a zero-dependency TUI for microarchitectural observability.

It's an interesting project because it bypasses libhwloc to resolve hardware topology natively via sysfs and uses eBPF CO-RE to map live IPC (Instructions Per Cycle) and cache metrics directly onto a physical block map of the silicon. It's also a great example of a statically-linked Rust binary bundling multiple C-libraries (libbpf, libelf, zstd) for zero-friction deployment.

Repo:Swift topology

1637

I would like to self nominate Typekin, it is a newtype creator, but with concept of c++'s friend classes baked in, so the constructor's validator can be fully bypassed case-by-case and what you'll get at the end in the binary is again plain integers (currently it supports integers only).

Code: Koosha / Typekin Ā· GitLab

I also have a non-procmacro version attemp in a private repo with mountain of commits and experimentation, but I gave up on the idea as the macro rules were turning into a turing complete rust syntax parser, and a nightmare to debug. I'll try to polish it and put in an alternate branch at some point.

1638

I would like to self nominate index_type, a crate for providing strongly typed indices for collections. Prevents you from using an index to one array as an index to another array, at compile time, and provides a full ecosystem for working with such typed indices.

For example, it provides a way to iterate over ranges with custom index types (e.g MyIndex::new(5)..=MyIndex::new(8)). By default, in stable rust, you cannot iterate over this type. With index_type, you can just write MyIndex::new(5)..=MyIndex::new(8).iter() which gives you something you can iterate on.

Additionally, it allows you to use NonZero integer types as indices. This is useful since it makes Option<MyIndex> have the same size as MyIndex, which is useful if you are storing a lot of Option<MyIndex> objects in memory, and may also improve the performance of code that uses Option<MyIndex>.

Basically this crate provides you with everything you need when working with typed indices, and it is very nice to use. I personally used it in some of my own personal projects where it was very useful. I specifically found it very useful when implementing custom graph data structures and other compiler related data structures, where you have many vectors containing many objects of different types, and you have a lot of indices to those vectors in different locations in your code.

1639

Your link seems to have an issue. The direct link is apparently https://github.com/swiftlogicsystems/swifttopology instead of that Google indirection, which triggered a warning in my browser.

1640

Thanks for pointing that out. I have fixed the link.