Crate of the Week

community
1390

Self-nominating embed_it.

A crate that helps you to embed assets into your binary and generates structs / trait implementations for each file or directory

Unlike include_dir and rust-embed it generates strongly-typed structures to avoid problems with hardcoded paths and vanished files.

In addition, it allows you to choose what exactly should be compiled, for example, if you only need file metadata or only a hash of a certain type, then you can embed them only

The simplest example:

#[derive(Embed)]
#[embed(path = "$CARGO_MANIFEST_DIR/assets")]
pub struct Assets;

assert_eq!(
    Assets
        .dir_1()
        .subdir()
        .readme()
        .content(), 
    b"My content"
);
4 Likes
1391

Self-nominating check_config.

In our company we have a lot of repo's. Some config for tools like ruff, is included in the repo ie via a pyproject.toml. The build pipeline can check if the latest config is used via check_config. When we want to change the config, ie using a different line length, we can update the config via check_config --fix.

See check-config for usage and examples.

1 Like
1392

Interesting project! Btw, the links in the ReadMe file are mostly dead.

1393

Thanks. Links are fixed

1394

Self nominate Docker Utils: A friendly Rust crate that simplifies Docker container management with a clean and intuitive API.

I wrote this crate a while ago because a lot of existing crates back then relied on the Docker Api and therefore were often outdated or not functioning anymore. However, I have a CI setup where testcontainers isn't an option hence I wrote the DockernUtils that only rely on the much more stable Docker CLI.

https://crates.io/crates/docker_utils

1395

unsure if binaries are eligible, but if they are, i'd like to nominate fend.

It's a very featureful calculator an it boots up very fast, even on hdd systems.

2 Likes
1396

Nominating Vello.

It is a 2D graphics rendering engine, with a focus on GPU compute. It can draw large 2D scenes with interactive or near-interactive performance, using wgpu for GPU access.

I've used it recently, and let me tell you what: Vello made it easy to get > 100 fps with 90000 small circles, which is great news for any semi-decent particle system simulator. All I had to do is to split them into chunks using rayon, return a Scene for each chunk, and merge these subscenes into one scene, which is then rendered. This is a very fast 2D engine, yet the code reads like render_circle(...) rather than the usual 1000 lines to draw a triangle. Thanks to Vello, I still don't know how to write shaders and don't need to.

2 Likes