Crateful 01/25

Transactional Actors, CRB 0.0.28, uiio protocol, crate-hunter tool.

Jan 29, 2025

Handcrafted in the age of AI

Hello! I'm excited to introduce Crateful, a brand-new publication for Rust developers. Initially, my idea was to create several agents that would gather up-to-date Rust news, focusing primarily on new and interesting crates.

However, when I tried to bring this idea to life, I quickly realized that the current ecosystem for building agents in Rust is somewhat limited. My first attempts also didn’t deliver the quality I hoped for. At the same time, I had significant experience working with actor systems, which seemed like a perfect foundation for creating a useful tool for developers. Starting with small experiments, I soon discovered that developing custom AI agents is an incredibly promising field—and, most importantly, I have something valuable to offer developers in this space.

While my original goal was to build an assistant that could read Rust news and present it in a polished format, I’m not sure how quickly I’ll be able to achieve that. What’s more important, though, is that I want to embark on this journey together with you. I’ll share all my progress and findings in this crab-sized practical journal, with the hope that, over time, it will be filled with content curated by a team of crab-agents.

Let’s explore this path together!

Transactional actors

If you've ever worked on a large and complex project in Rust, you're likely familiar with the challenges of building a solution with low coupling between components while maintaining flexibility and fault tolerance—especially when mixing synchronous and asynchronous code.

Typically, developers start with either tokio or actix.

tokio

Both frameworks are excellent, but if you rely solely on raw tokio, you’ll find yourself needing to implement a lot of functionality and components from scratch. This might include manually setting up channels, making them concurrent, and building robust error handling on top. Let me put it this way: creating complex branching logic with tokio can be incredibly challenging. For instance, imagine you’ve written a large codebase with asynchronous functions and methods, and now you want to add timeouts for certain coroutines and restart them after a specified duration. This can become so convoluted that you might settle for a simpler, less capable solution.

This approach works fine for building an HTTP server, but creating an agent framework in such a way can be quite difficult.

actix

The actix framework provides more convenient building blocks for development, but there are some challenges I’ve encountered:

Combining synchronous and asynchronous code: While actix makes this easier than tokio, you still need to do a fair amount of manual work. In some cases, you may need to use tools like SyncArbiter.
State machine implementation: Creating a state machine is possible, but you have to manually track and change states, which can be tedious. Things get even more complex when you need to manage multiple state machines—for example, one for initialization and another for merging data from different databases.
Blocking message processing for critical tasks: It’s particularly challenging to pause message handling to complete an important task. You’ll often need to implement mechanisms like deferred message handling—where a request arrives, but the actor hasn’t yet received all the necessary data to process it fully. This requires extra effort and planning.

Another challenging scenario is implementing a handler for all actors for a specific type of event. In other words, it’s not possible to directly achieve something like this in Rust:

impl<A: Actor> Handle<EventForAll> for A { }

While actix certainly delivers great performance, the framework is not designed with code composition in mind.

Composable Runtime Blocks

To address the challenges mentioned earlier, I developed a new type of actor—a hybrid actor that combines two runtime models: a state machine and a message handler. This led to the creation of a framework with hybrid actors called CRB (Composable Runtime Blocks)—a nod to the Rust crab mascot 🦀.

To ensure the framework's extensibility, I designed a core module, with additional features implemented in separate crates. Tasks or activities within the framework are represented by a crate called Agent. The idea is to enable seamless transitions between different operating modes of the agent: as a state machine or as an actor. Essentially, a hybrid actor is always a state machine, but it includes a special state for listening to and handling events.

In state machine mode, you gain full control over the sequence of handler executions, which can be either synchronous or asynchronous. This flexibility allows developers to address a wide range of scenarios efficiently.

One of the key advantages of this approach is the ability to implement complex branching logic that would be difficult to achieve with simple functions and methods. This makes it straightforward to build systems for agent-based solutions, such as pipelines.

Example

Let’s implement a solution to see how to create a transactional actor in action. The logic will work as follows:

The agent starts.
It runs an initialization procedure.
A timer is started.
It transitions into a state where it waits for messages (actor mode).
It receives a timeout event.
It transitions to an asynchronous processing state.
Then it transitions to a synchronous processing state.
Finally, it completes and shuts down.

The code in the examples below is slightly simplified. You can find the full version here in the corresponding to this issue folder (transactional-actor example).

Starting an agent

We have a structure that contains a timer. When the timer finishes, it sends a Tick event, which we will define ourselves.

struct Tractor {
    timeout: TimeoutSwitch<Tick>,
}

The example is implemented using the CRB crate, where the hybrid actor is called Agent (to emphasize the actor's autonomous ability to perform complex actions and handle various errors).

impl Agent for Tractor {
    type Context = AgentSession<Self>;

    fn begin(&mut self) -> Next<Self> {
        Next::duty(Initialize)
    }
}

The begin method is called when the agent starts, and it specifies the next state of the state machine. In our case, this state is Initialize.

You can execute the agent within the current asynchronous context by running the Future returned by the run() method.

#[tokio::main]
async fn main() -> Result<()> {
    Tractor::new().run().await
}

Initialization and starting a timer

The first state to be called is Initialize. A special handler, Duty, provides access to the context (the actor’s address), allowing the agent to add itself as a listener for the Tick event from the Timeout worker.

impl Duty<Initialize> for Tractor {
    async fn handle(&mut self, _: Initialize, ctx: &mut Context<Self>) -> Result<Next<Self>> {
        self.timeout.add_listener(ctx);
        self.timeout.start();
        Ok(Next::events())
    }
}

Once the timer is started, the service state (by calling the events() method) is returned, initiating the processing of events in the queue. As a result, the agent begins to behave like an actor.

Handling events in an actor mode

The timeout event will be placed in the agent's queue, which it processes while in actor mode. Therefore, we need to add a handler for the Tick event, which will be sent by the timer.

impl OnEvent<Tick> for Tractor {
    async fn handle(&mut self, _: Tick, ctx: &mut Context<Self>) -> Result<()> {
        ctx.do_next(Next::do_async(()));
        Ok(())
    }
}

The actor does not automatically transition to another state in the state machine; instead, it continues processing messages. Using access to the context, we set the next state to be handled—an asynchronous handler.

For simplicity, we will use () as the state since we’re demonstrating just one asynchronous handler. However, you can specify any value there, such as a specific named state.

Asynchronous handler

An asynchronous state involves handling a state machine message by calling an asynchronous method. This is achieved by implementing the DoAsync trait.

impl DoAsync for Tractor {
    async fn once(&mut self, _: &mut ()) -> Result<Next<Self>> {
        Ok(Next::do_sync(()))
    }
}

In the handler, we simply return the next state—a call to the synchronous handler.

Synchronous handler

The synchronous handler works in a similar way but calls a regular (non-async) method. Before doing so, it exits the asynchronous context, ensuring that it does not block the asynchronous runtime (e.g., tokio).

impl DoSync for Tractor {
    fn once(&mut self, _: &mut ()) -> Result<Next<Self>> {
        Ok(Next::done())
    }
}

After executing the synchronous code, the actor can be terminated by setting the final state using the done() function. As a result, the agent will finish its lifecycle without returning to actor mode. This decision reflects our choice to stop processing incoming messages, apart from the brief period when we were waiting for the timer event.

This approach allows you to write very simple and sequential code while parallelizing it as needed by launching other agents. All these capabilities are implemented in the CRB crate, and I’ll discuss the latest version of it in the next section.

CRB 0.0.27

I have already released quite a few versions of the CRB library, its functionality keeps expanding, and the 0.0.27 release includes a lot of interesting features.

Switches

The ability to easily enable and disable timers has been added, with new structures featuring the Switch suffix introduced for this purpose.

IntervalSwitch - controls a worker that sends events at a specified interval.
TimeoutSwitch - controls a worker that sends a single event after a specified timeout.

In the next version, Timeout will be renamed to Timer and may be combined with Interval, with repetition controlled by a special flag.

Let's take a look at a small example of how to use this timer switch, using IntervalSwitch as an example.

Subscription

Support for a new agent interaction pattern, Subscription, has been introduced (similar to the Observer pattern in Java). The purpose of this pattern is to allow agents to subscribe to a specific set of messages. A Handle is returned for the subscription, and when the handle is removed, an unsubscribe message is automatically sent.

To use the pattern, an agent must implement the ManageSubscription trait, which includes the subscribe and unsubscribe methods. The subscribe method is called when a subscription is created, and the unsubscribe method is invoked when the subscription's Entry is dropped.

For example, this pattern is used in the Ice-Nine project to subscribe to updates from a configuration file:

impl ManageSubscription<ConfigUpdates> for ConfigLoader {
    async fn subscribe(
        &mut self,
        sub_id: UniqueId<ConfigUpdates>,
        _ctx: &mut Context<Self>,
    ) -> Result<Value> {
        self.subscribers.insert(sub_id);
        Ok(self.current_config())
    }

    async fn unsubscribe(
        &mut self,
        sub_id: UniqueId<ConfigUpdates>,
        _ctx: &mut Context<Self>,
    ) -> Result<()> {
        self.subscribers.remove(&sub_id);
        Ok(())
    }
}

To create a subscription, you can use the subscribe() method, which becomes available on the Address of an agent that implements this pattern.

`Context` wrapper

In the previous subscription example, you might have noticed that the Context is a structure that takes the agent type as a parameter:

async fn subscribe(
    &mut self,
    sub_id: UniqueId<ConfigUpdates>,
    _ctx: &mut Context<Self>,
) -> Result<Value>

Internally, the structure only contains a reference to the actor’s context. However, by using a full-fledged structure, it became possible to define extension traits alongside Address and add custom features for all context types at once.

`ToAddress` trait

With the new context structure, it became possible to add the ToAddress trait. This trait can be used in constructors to directly obtain an address, whether through a reference, a context, or the context itself.

Below is another example from Ice-Nine demonstrating a method where any agent can subscribe to events about configuration updates.

pub async fn live_config_updates<A, C>(
    &self,
    address: impl ToAddress<A>,
) -> Result<(C, Entry<ConfigSegmentUpdates>)>

Renaming

Some types were also renamed; for example, InContext has been renamed to Duty. This is a state machine trait that provides access to the context, which is typically useful for writing initialization states.

EventSender has been renamed to the much more intuitive Recipient.

Removal of `Output`

The Output result has been removed from the agent, as it was previously mandatory.

impl Agent for MyAgent {
    type Context = AgentSession<Self>;
    type Output = ();
}

Now, the agent does not return a result at all. Instead, a new module called mission has been introduced for this purpose.

`mission` module

The superagent crate now includes a convenient mission module, which allows you to extract results from an actor.

axum example

An interesting example of integrating a framework with Axum has emerged. In this case, an agent acts as a state machine that processes requests. Here’s what a minimalist Handler looks like:

const URL: &str = "https://rust-lang.org";

pub struct CrbWorld;

impl Agent for CrbWorld {
    type Context = AgentSession<Self>;

    fn begin(&mut self) -> Next<Self> {
        Next::done()
    }
}

impl AxumAgent for CrbWorld {
    type Response = Redirect;

    fn from_request(_request: Request) -> Self {
        Self
    }

    fn to_response(self) -> Option<Self::Response> {
        Some(Redirect::temporary(URL))
    }
}

In the given example, the agent (or actor) immediately terminates and redirects the request to another resource. However, it is possible to manage it in a transactional mode through different states, such as accessing a database sequentially and even incorporating error handling.

The integration is handled by the AxumAgent trait, which is also defined in the example.

uiio protocol

Throughout my career, I have often needed a convenient protocol that could be used for debugging and intervening in the operation of an application.

System debuggers are quite slow and cumbersome to use, and dealing with something complex and dynamic usually ends with digging through logs.

One day, a wonderful yet very simple idea came to me. What if we created a dashboard based on values extracted from the tails of logs? We could present them in the following format:

[2025-01-25T21:40:55Z INFO  ice9_std::config_loader] !uiio! actor.loader.status=started

Take a universal separator, for example, !uiio!, and after it add a key-value pair. The key would have a hierarchical structure.

This opens up two very cool possibilities:

You can enhance standard logs with additional information that can be programmatically parsed.
You can dynamically build a dashboard that displays a tree of elements with their values.

Such a tool would be very handy for debugging actors, like the CRB I mentioned earlier.

Input-output extension

Eventually, I started developing such a protocol, but soon a new idea emerged: we could actually repurpose the mundane stdio for interacting with the program or extracting information from it without having to develop a complex infrastructure or protocol.

Of course, this implementation would have limitations, but a significant advantage is that you can set it up in just a few minutes. And if you create a dashboard for this format, it could be used for any programs, not just those written in Rust.

Here's how the protocol capabilities would align with the stdio streams:

stdout - Key-value pairs that are rendered on the dashboard.
stdin - Receiving control signals from the dashboard (which the program could listen to).
stderr - Continuously receiving logs, but also displaying them in a structured format on the dashboard.

In the end, I set about creating such a protocol and conducted several experiments. There are already a couple of projects where I plan to implement this concept: the uiio protocol and the hug dashboard.

First of all, I am implementing a TUI dashboard that will display events and logs in real time. Currently, key-value pair display has already been implemented.

crate-hunter

Initially, I planned to create Crateful as a magazine entirely written and designed using AI. However, achieving this in a short timeframe has proven to be incredibly challenging, likely requiring at least a year of research and experimentation.

Rather than delaying the magazine's launch, I decided to start publishing it right away, using it as a platform to share my progress and insights along the way. I have no doubt that this vision is achievable, so the magazine will steadily work toward this goal with every issue.

The first project I’m embarking on within the journal is a utility for downloading lists of new crates from crates.io. With so many new crates released each week (about ~700), I aim to leverage AI to help discover and explore them efficiently.

What will the utility do?

The tool, crate-hunter, will function as follows: it will download the data dump of crates, read the information from it, filter the crates by publication date, and then send the filtered list to an AI system to identify the most interesting options.

All such utilities will be grouped under the project riir, which is literally an acronym for "Rewrite It In Rust."

I believe additional metadata will be necessary, such as the number of commits and stars on a project, to filter out smaller, less significant experiments as well as components of large applications structured as workspaces.

How is it all implemented?

Currently, the utility includes three small agents (a hybrid actor, in CRB terminology). One is responsible for downloading the file, another for extracting data from it, and the third for saving the list of crates into a CSV file.

I deliberately separated the CSV dumper and file downloader, as these are useful components that can later be reused for other purposes and utilities.

Here’s an example of how these components are implemented (focusing only on the parts responsible for performing the core tasks).

`DumpLoader`

The first agent launched in crate-hunter is the file loader. I think it makes sense to turn it into a universal module in the future, capable of loading any files. Take a look at how it's implemented.

impl DoAsync<DownloadDump> for DumpLoader {
    async fn once(&mut self, _: &mut DownloadDump) -> Result<Next<Self>> {
        if !self.path.exists() {
            let response = reqwest::get(URL).await?.error_for_status()?;
            let mut stream = response.bytes_stream();
            let mut dump_file = File::create(&self.path).await?;
            while let Some(chunk) = stream.next().await.transpose()? {
                dump_file.write_all(&chunk).await?;
            }
        }
        Ok(Next::done())
    }

    async fn fallback(&mut self, err: Error) -> Next<Self> {
        fs::remove_file(&self.path).await.ok();
        Next::fail(err)
    }
}

The DumpLoader sends a request to download a file via a URL and opens a byte stream. It also opens a file and transfers the contents into it in a loop. Firstly, this allows for downloading very large files, pre-allocating space for them, and displaying the download progress.

Note the convenience of implementing this process in CRB: by using a fallback method, you can delete a partially written file in case of an error.

`CrateExtractor`

The next step in the process of collecting crates is unpacking the archive and filtering its contents. This is done using the db_dump crate, and crates released in the last 7 days are filtered out.

impl DoSync<ExtractLatest> for CrateExtractor {
    fn once(&mut self, _: &mut ExtractLatest) -> Result<Next<Self>> {
        let week_ago = Utc::now().date_naive() - Duration::days(7);
        Loader::new()
            .crates(|row| {
                let created_at = row.created_at.naive_utc().date();
                if created_at < week_ago {
                    return;
                }
                if row.repository.is_none() {
                    return;
                }
                self.latest.push(row.into());
            })
            .load(&self.path)?;
        Ok(Next::done())
    }
}

CrateExtractor is implemented slightly differently; it uses the DoSync handler, which frees up the asynchronous context for other tasks while performing its activity in a separate thread. This allows for invoking the synchronous Loader and gathering results with it.

`MarkdownReport`

The final step in the crate selection process is generating a report. Currently, this is simply an export to Markdown without filtering crates based on any criteria.

impl DoAsync<WriteReport> for MarkdownReport {
    async fn once(&mut self, _state: &mut WriteReport) -> Result<Next<Self>> {
        let mut stdout = io::stdout();
        for info in &self.crates {
            let line = format!("[{}]({}) - {}\n\n", info.name, info.repository, info.description);
            stdout.write_all(line.as_ref()).await?;
        }
        stdout.flush().await?;
        Ok(Next::done())
    }
}

The MarkdownReport worker is implemented as an asynchronous activity that generates lines in Markdown format and writes them to a file.

What's next?

For now, this is the current implementation, which simply retrieves a list of crates published over the past week. In the next update, I plan to add functionality for downloading all repositories, allowing for more detailed exploration. This could include reading README files, counting the number of commits, or determining the project’s start date.

In the meantime, below is the full list of crates from this week. Take a look to see what Rust developers are working on right now!

Crates released this week

sosistab3-obfsws - Websocket Pipe (pluggable-transport) support for sosistab3

mpfs-hal-embassy - Embassy integration for PolarFire SoC

battler-wamprat-error-proc-macro - Procedural macro for custom WAMP errors.

battler-wamprat-error - Procedural macro for custom WAMP errors.

wdym - What Do You Mean: Look up definitions and translations online. Has a library and TUI interface

rust_decimal_cql - A library that wraps rust_decimal::Decimal and implements traits for integration with ScyllaDB's native DECIMAL column type.

rustcraft - 一个 Rust 下的 OpenGL 集成框架|An OpenGL integration framework in Rust

famedly_rust_utils - Random rust utility functions and types

base116_cli - CLI binary for crate base116

xum1541 - Rust driver to access Commodore disk drives using XUM1541 USB device

bexeval - bexeval is a Rust crate for evaluating string formulas restricted to values as integers only.

async-opcua-server - OPC UA server API

async-opcua-client - OPC UA client API

async-opcua-crypto - OPC UA cryptography library

async-opcua-nodes - OPC UA node representation and import framework

async-opcua-core - OPC UA core utils for client and server

async-opcua-core-namespace - OPC UA generated code for the core namespace

async-opcua - OPC UA client and server API

castwright - Scripted terminal recording.

yiirs - Rust API development scaffolding, support salvo and axum.

amareleo-chain-account - Account for a lite Aleo development node

bonsol-schema - Bonsol types, schema definitions

amareleo-node-metrics - A node for a lite Aleo development node

monoio-rust2go-cli - Monoio Rust2go commandline tool.

monoio-rust2go-common - Monoio Rust2go common library.

monoio-rust2go-macro - Monoio Rust2go macro.

monoio-rust2go - Monoio Rust2go main shared library.

amareleo-node-sync-locators - Locators to synchronize a lite Aleo development node

amareleo-node-bft-storage-service - A storage service for the memory pool in a lite Aleo development node

dharitri-sdk-http - SDK for interacting with the Dharitri blockchain

dharitri-sdk-dapp - SDK for interacting with the Dharitri blockchain for wasm-bindgen environments

jproxy - Just a proxy

amareleo-node-bft-ledger-service - A ledger service for the memory pool in a lite Aleo development node

augur - Vulnerability research assistant that extracts strings and related pseudo-code from a binary file.

bevy_cached_query - Simple high level query library for Bevy based on async tasks and Observer API very loosely inspired by TanStack Query.

amareleo-node-bft-events - Events for the gateway in a lite Aleo development node

amareleo-node-sync - A synchronization module for a lite Aleo development node

amareleo-node-bft - A memory pool for a lite Aleo development node

amareleo-node-consensus - A node consensus for a lite Aleo development node

amareleo-node-rest - A REST API server for a lite Aleo development node

chunk_norris - A Rust library for splitting large text into smaller batches for LLM input.

io_capitalize - A crate to simplfy Rust,s IO scripts as similar to Python.

amareleo-node - A node for a lite Aleo development node

amareleo-chain-cli - A CLI for a lite Aleo development node

bevy_flair_style - Bevy UI styling using CSS

bevy_flair_core - Bevy UI styling using CSS

bevy_flair_css_parser - Bevy UI styling using CSS

bevy_flair - Bevy UI styling using CSS

mr_socketio - A brief description of what your crate does

libannict - Annict API のクライアントライブラリ

valust-regex-utils - Regex utilities for the Valust crate

ctxs - 显式的代码上下文管理设施

android_native_window - Android Native Window ffi ,supported to Android14.

watchr_filesystem - A simple file watcher that watches a list of paths and calls a callback when any of them change

userscript - userscript

cargo-msrv-cargo_metadata - structured access to the output of cargo metadata

deltalake-lakefs - Native Delta Lake implementation in Rust

any-fn - Dynamically-typed functions to represent any functions in Rust

ip-parse-rs - A library for parsing IP addresses

tracing-fancytree - tracing subscriber with readable tree output

ankurah - Observable, event-driven state management for native and web

sigma-types-macros - Macros to enhance the sigma-types crate

serde_table_internals - Proc-macro crate for serde_table.

serde_table - Write structs in an easy table format.

doom-status - Show the CPU load in a menu or status bar by displaying the face of Doom Guy

popparoach - Cut my life into pieces

logger_rust_i18n - Macro rust-i18n into logger and user prompt

twine-data - Codec for the twine-data binary serialization format

custom-string - This macro generates string types with custom validation.

aoc-ornaments - Advent of Code tools

snekrs - A fun and quirky terminal-based snake game written in Rust 🐍

dharitri-sc-wrewa-swap - Dharitri Wrapped REWA Smart Contract

neis-client - 나이스 교육정보 개방 포털 API client

spideroak-crypto - SpiderOak's cryptography library

ark-secret-scalar - Secret scalars for non-constant-time fields and curves

swarm-rs-macros - Macros for swam-rs

wav2c - Convert WAV files to C arrays for embedded LPCM audio playback

egui-qr - QR painter for egui

yew-callback - Macro helps you to create yew::Callback

clerr - This library aids in displaying command-line errors.

wasmshield - Library for verifying WebAssembly components

wasmshield-cli - A CLI Tool for verifying WebAssembly components

gen - A sequence graph and version control system.

staging-dleq_vrf - VRFs from Chaum-Pedersen DLEQ proofs, usable in Ring VRFs

dusk-rusk - Rusk is the Dusk Network node implementation

gis-tools - A collection of geospatial tools primarily designed for WGS84, Web Mercator, and S2.

oz-keystore - A multi-chain keystore library that provides a unified interface for managing private keys.

filesystem-table - A library for reading and writing filesystem tables.

staging-bandersnatch_vrfs - Ring VRFs and thin VRF on bandersnatch

csgrs - Constructive solid geometry on meshes using BSP trees in Rust

ratch-job - 一个rust实现的分布式任务调度平台服务。计划完全兼容xxl-job协议，然后再增强一些任务调度平台能力。

ratchjob - 一个rust实现的分布式任务调度平台服务。计划完全兼容xxl-job协议，然后再增强一些任务调度平台能力。

edgee-api-client - Edgee API client

rtsan-standalone-macros - Macro crate for RTSan standalone

rtsan-standalone - A Rust wrapper for RTSan standalone

edgee-components-runtime - Edgee components runtime (using wasmtime)

kutil-cli-macros - Procedural macros for kutil-cli

picoserve_derive - Macros for picoserve

tail-s3 - A command-line utility that monitors and streams content from an S3 object in real-time, similar to the Unix tail -f command but for S3 objects.

rtsan-standalone-sys - Unsafe Rust bindings for RTSan standalone library

kutil-io - I/O utilities from Kutil

windows-clang - Windows clang parser

miku-h2 - An HTTP/2 client and server

auto-lsp-core - Core crate for auto_lsp.

auto-lsp-macros - Macros for auto_lsp.

r2pc - A Rust RPC framework.

r2pc-macro - A Rust RPC framework.

amareleo-chain - A lite Aleo development node

foxerror - yet another proc macro for deriving Error on enums

laddu-python - Amplitude analysis made short and sweet

buggy - A less panicky replacement for unreachable!() and unwrap

miku-hyper - A protective and efficient HTTP library for all.

pane-resizer - A simple pane resizer for Leptos

miku-hyper-util - hyper utilities

osc8er - Convert file or url to be clickable on supported terminal emulators by tagging it using OSC 8

twine-core - A Rust framework for functional and composable system modeling.

twine-macros - Macros for Twine, a Rust framework for functional and composable system modeling.

json2markdown - A Rust library to convert JSON data into well-structured Markdown format.

auto-lsp - A rust crate for creating AST and LSP servers powered by tree-sitter queries.

check_openai_models - A TUI tool to check and display OpenAI models information

staging-sp-ark-ed-on-bls12-381-bandersnatch - Bandersnatch: a curve defined over the scalar field of the BLS12-381 curve, optimized for Substrate

staging-sp-ark-bls12-381 - The BLS12-381 pairing-friendly elliptic curve, optimized for Substrate

staging-ark-transcript - Arkworks friendly transcripts for proofs using Fiat-Shamir

wasmtime-math - Low-level math routines used in Wasmtime

spideroak-base58 - Base58 encoding and decoding

json_to_struct - Convert JSON into Rust structs for efficient and type-safe data management.

notu - A placeholder for future project written in Rust

staging-sp-ark-ed-on-bls12-377 - A Twisted Edwards curve defined over the scalar field of the BLS12-377 curve, optimized for Substrate

tailwindcss_colors - Tailwind v4 colors in Rust's color crate

cbd - Command-line CBOR decoder and encoder

mrdirector - A narrative game development package for the Turbo Game Engine.

fixed-resample - An easy to use crate for resampling at a fixed ratio

faf-replay-parser-derive - Derive crate for faf-replay-parser

topkio - Not all AI agent frameworks are called topkio.

rust_transiter_types - Some generated rust types for the transiter API https://github.com/jamespfennell/transiter. Meant for no std enviromnets that have an alloc.

schema2struct - Convert a JSON schema into Rust structs for efficient and type-safe data management.

imagebox - command line image utility

read-url-cli - Read from a wide variety of URL types

ulmensa - A command-line utility for retrieving and displaying current meal plans from the University of Ulm canteen.

monoio-transports-netreq-fork - This is a personal fork of the monoio-transports crate

monoio-netreq - monoio-netreq is a user-friendly HTTP client library designed for use with the Monoio runtime

bevy_platform_support - This crate is reserved for the Bevy Engine project

esix - A simple wrapper of the e621 API

prompt-input - A simple and lightweight library for user input prompts in Rust, designed to make input handling straightforward.

tailwindcss_palette - Tailwind v4 colors in Rust's palette crate

ketje - Ketje v2

chia-serde - Serialization and deserialization helpers for Chia types

nostr-grpc - Nostr GRPC types

mcp-commune - Rust client and server for building discoverable Model Context Protocol (MCP) networks

roblox-rs-shared-context - This crate communicates between roblox-rs bindings and the tooling.

niffler-temp - Simple and transparent support for compressed files

ntt - A crate for performing Number Theoretic Transform (NTT) based polynomial multiplication.

mcsr-ranked-api - MCSR Ranked API wrapper in Rust

coppice - Dynamic programming library for acyclic analytical queries

roblox-rs-macro-definitions - This crate exposes the roblox-rs procedural macros.

roblox-rs - This crate contains support for Luau bindgen and generated bindings to the Roblox API.

herring-automata - Automata construction for Herring

herring-derive - Macro implementation of #[derive(Herring)]

herring - Lexer generator

okamoto - Implementations of Okamoto 'Efficient Blind and Partially Blind Signatures Without Random Oracles' (2006)

roblox-rs-macro-expansion - This crate implements the roblox-rs procedural macro expansion.

pake-cpace-embedded - A simple implementation of CPace, a balanced PAKE.

local_static - Local static variable

noob-builder - A simple proc macro that allows the user to auto generate a simple builder pattern.

tinychange - A tool for creating tiny changelogs on a fly!

crate2bib-cli - A CLI tool for the crate2bib crate

mini-scopeguard - A minimal scopeguard implementation

roblox-rs-cli - Work in progress

syt - Hackish things for serde_yml.

tb-sys - Bindings for the tb compiler backend

shapdf - Create Shapes into PDF

datafusion-dft - An opinionated and batteries included DataFusion implementation

crashfeishu - A Supervisor event listener that sends Feishu notifications when managed processes crash.

gni - Library to create a GPU Node ID

ccsum - Convenient Checksum Utility

crate2bib - Create BibLaTeX entries for crates hosted on crates.io

versioneer - crate for working with semantic versions

versioneer-cli - crate for working with semantic versions

lynn_tcp - Lightweight Tcp framework

particle - A GPU accelerated physics engine for the Bevy game engine with first class support for WebGPU.

inline-doc - Embed markdown/text files as documentation

datafusion-functions-parquet - DataFusion helper functions for working with Parquet files

kbvm-proc - Internal dependency of kbvm

fuel-streams-types - Types for fuel streams

sqr - Scan QR with Quircs

fuel-streams-store - A database storage and retrieval system for Fuel blockchain data streams, providing PostgreSQL integration, async operations, and transaction management for the Fuel Data Systems ecosystem

test-data-file - test macro helper to provide test data from a file

dqr - Decode QR with Quircs

fuel-streams-domains - Domains definitions for fuel streams

fuel-message-broker - A message broker for the Fuel Streams

init-data-rs - Telegram Mini Apps init data parser and validator for Rust

fuel-web-utils - Fuel library for web utils

brbitcoin - A Bitcoin-related library providing cryptographic utilities

dbk64 - A simple library that uses cheat engines dbk64 driver to read/write process memory

Lion-cli - A developer tool to create files of different coding languages

rs-ls-fast-raw - Faster ls(up to 10x faster on mac, 140% faster on linux)

rob-vm - A cmdline tools to run brainfuck & ook & shortook code

string_art_ui - A gui interface for string_art.

string_art - Convert images into thread patterns for creating string art. It generates detailed instructions in text format and provides graphical previews of the resulting patterns.

pxls - A library for pixelising images

synd-stdx - syndicationd lib

rsgl - A Rust library for OpenGL

halt_and_catch_fire - Halt and catch fire.

yes_parser - Your Extensible Script standard parser reads so you can write!

tform - A crate to format plain text into well-structured Markdown or HTML.

wasmedgeup - An installer for the Wasmedge runtime and plugins.

license-picker - A simple command-line tool to generate a license file

backend-kit - Provides a set of tools and helpers for building backend services in Rust.

ratskin - A wrapper around termimad that produces ratatui widgets from markdown

fee_source - Get bitcoin network fees from mempool instance and convert to formats needed by other services

hashify - Fast perfect hashing without dependencies

mats - 用于处理矩阵和向量的 Rust 库 | A Rust library for handling matrices and vectors

yamson - A simple tool to convert YAML to JSON and vice versa.

s2energy - Provides type definitions and utilities for the S2 energy flexibility standard

deimos - Control-loop and data pipeline for Deimos data acquisition system

rizlib - A library for interacting with Rizline game files

biblib - Parse, manage, and deduplicate academic citations

sfo-pool - A work allocation pool

ankiconnect-rs - A package for convenient interaction with AnkiConnect.

pankosmia_web - A web server for pankosmia desktop applications

rusk-wallet - A library providing functionalities to create wallets compatible with Dusk

clap-dispatch - Ergonomically dispatch CLI subcommands

onise - An async client for Kraken's APIs in Rust.

websocket-web - WebSockets on the web 🕸️ — WebSocket support in a JavaScript runtime environment, usually a web browser.

neutralts - Neutral is a web application template system, a template engine designed to work with any programming language via IPC and natively as an IPC or library/crate in Rust.

skeleton-key - An all-in-one offensive security protocol

gravitron_plugin - Gravitron Plugin

gravitron_window - Gravitron Window

gravitron_hierarchy - Gravitron's ECS Hierarchy

lastfm-rust - Rust library for accessing the Last.fm API.

dysco - where did my disk space go?

cu-udp-inject - A simple UDP packet injector that takes a PCAP file and sends it to a remote host

vortex-scan - Vortex scan contains logic for smartly performing a filter + projection scan operation.

vortex-layout - Vortex layouts provide a way to perform lazy push-down scans over abstract storage

tauri-axum-htmx - Build interactive UIs in Tauri applications using HTMX and Axum, enabling server-side rendering patterns by running the Axum app in the Tauri backend.

vortex-mask - Vortex Mask - sorted, unique, positive integers

tcp-echo-benchmark - A high-performance TCP echo server benchmark tool measuring throughput using concurrent async clients. Supports configurable payload size, connection count, and test duration.

yahvim - A lightweight terminal-based released on 15/01/2025 text editor.

tracing_log_error - A set of helpers to capture rich error context in tracing logs

apiraa - A Rust program that finds and copies the activate script path of a virtual environment to the system clipboard.

chunnel - Async mpmc(multi producer multi consumer) channel

vgnr - Le Chiffre Indéchiffrable

raw-stdio - Cross-platform, unbuffered, direct STDIO access

jp-deinflector - A package for deinflecting Japanese words

convert-af - A library for converting alevin-fry output to the AnnData format

htmf - hypertext markup functions: functions for generating HTML

mathfun - high-performance math functions

docuxide - DX

gravitron_renderer - Gravitron Renderer

objc-rs - Objective-C Runtime bindings and wrapper for Rust. Maintained fork of objc crate

ract - Ract is a conversational CLI tool written in Rust, providing an all-in-one solution for integrating dependencies, setting up environments, generating project templates, running, and packaging projects with frameworks like GenUI and Makepad. Simplify your development workflow with minimal arguments and intuitive dialogs. 🚀

swarm-rs - A minimalist framework for building agentic workflow

tee-s3 - A command-line utility that streams stdin to both stdout and Amazon S3, similar to the Unix tee command but with S3 as an output.

nstree - construct branched 'namespace strings' for nested subcomponents, often for logging

cu29-runtime - Copper Runtime Runtime crate. Copper is an engine for robotics.

cu-livox - Copper driver for Livox Tele15. Note: the actual parsing is usable outside of Copper if you need a Livox Tele15 driver for another project.

cu-v4l - This is a source task that captures video from a V4L2 device.

cfg-elif - Conditional compilation in expressions

trait_deref - Macro that simulates inheritance in a trait.

kbvm-cli - A CLI for working with XKB

utf8-console - Cross-platform enabling of UTF-8 console IO

ironsmith-parser - Transforms Smithy 2.0 IDL files into an abstract syntax tree

repo_path_lib - Access the root directory of your repository.

cu-config-variation - Example of a Copper configuration with programmatic multiple variations

input-handle - Simple library to handle input of any type

pinocchio-associated-token-account - Pinocchio helpers to invoke Associated Token Account program instructions

forgot-my-password - Simple password manager

solana_mirror - A Rust SDK for exploring a given Solana wallet

droppy - Friendlier dropwatch

maili-serde - Serde related helpers for Maili

maili-superchain - Core superchain types for Maili

etsy - An Etsy API wrapper

cklein - High-level safe bindings to the Klein scripting language.

laddu-core - Core of the laddu library

gtfs-generator - Convienience helpers for writing GTFS converters

laddu-extensions - Extensions to the laddu library

global-channel - Simple global channels.

getfileicon - A Rust library for extracting the pixels of a file icon and saving them as a PNG image.

paradex - Paradex client library

borrow_channel - A channel for borrows

bitnuc-mismatch - Create unambiguous one-off mismatch hash tables from bitnuc scalars.

binary-options-tools-macros - Macros for the binary-options-tools crate

binary-option-tools - binary-options-tools crate and the python library BinaryOptionsToolsV2.

proc-heim - Library for running and managing short-lived and long-lived processes using asynchronous API

binary-options-tools-core - The core of the binary-options-tools crate and the python library BinaryOptionsToolsV2.

heavy_duty_bools - A library for working with heavy-duty boolean values.

snif - 🐕‍🦺 Your friendly digital detective for sniffing out cryptocurrency wallets. Because every .dat deserves to be found!

orx-tree - A beautiful tree 🌳 with convenient and efficient growth, mutation and traversal features.

sonar-rs - A Rust library for the Sonar Perplexity API.

udled - Tokenizer and parser

apksig - Decoding the APK Signing Block

webcrawler - A simple Rust web crawler

ohkami_openapi - OpenAPI types for Ohkami - intuitive and declarative web framework

usbpd - USB-PD library for [no_std].

x32_osc_state - X32 State Tracker via Open Sound Control

tokenomics-simulator - Simulate trades, calculate various metrics, and visualise the results over different time intervals.

tower-lsp-server-macros - Internal procedural macros for tower-lsp-server

tower-lsp-server - Language Server Protocol implementation based on Tower

adarank - AdaRank: a boosting algorithm for information retrieval

dlt_log - Log crate adapter for integrating with the Diagnostic Log and Trace (DLT) system

common_sequence_diagram_io - A generic interface to parse, print and draw interaction languages

fans - Simple structures common to controlling fans

more-convert-derive-internal - This crate adds macros for various conversions.

more-convert-derive - This crate adds macros for various conversions.

more-convert - This crate adds macros for various conversions.

backend-test-kit - Provides a set of tools and helpers for testing backend services in Rust.

lambda-otel-lite - Lightweight OpenTelemetry instrumentation for AWS Lambda

ractor-supervisor - Supervisor module for ractor framework.

sockonsole - Sockonsole is a basic utility to be used for running something like a shell in the background, and be able to connect and interact with it whenever you want, through unix sockets.

unirun - Universal project runner

math-jit - Compile arithmetic expressions to native code

atomic_web_push - A library that eliminates potential risks (occasional crashes due to OpenSSL library's setenv conflicts in Linux environments) from the web push library

deepseek_rs - A Rust client library for the DeepSeek API

cavacore - A rust wrapper of cavacore from the cava music visualizer.

major - Next-gen integrated entity component system

ringmap - A hash table with consistent deque-like order and fast iteration.

context_manager_macro - Process macro for context_manager crate

context_manager - Python's like context_managers in Rust

tprint - A simple crate to print tabular data

netstat-esr - Maintained version of netstat-rs which is a cross-platform library to retrieve network sockets information.

rustclock - a stopwatch or timer cli made in rust

winnow_datetime - Parsing dates using winnow

totp-sm-rs - A TOTP (Time-based One-Time Password) implementation in Rust with SM3 support

winnow_datetime_assert - Testing/Benchmarking winnow-datetime parsers

winnow_rfc3339 - Parsing RFC 3339 dates using winnow

terminput - TUI input parser/encoder and abstraction over input backends

tree-sitter-asciidoc - asciidoc grammar for tree-sitter

tree-sitter-asciidoc-inline - asciidocInline grammar for tree-sitter

lento-quick-js - QuickJS Javascript engine wrapper

voir - CLI Utility to Peek on Files

bitflag-attr-macros - Attribute macro implementation for bitflags-attr. Do not use directly, use the reexport in the bitflags crate. This allows for better compatibility across versions.

asterisk-manager - This library provides an implementation to manage connections and authentication with an Asterisk Call Manager (AMI) server

max7800x-hal - A Hardware Abstraction Layer for the MAX7800X microcontroller family

simdphrase - Extremely fast phrase search implementation.

bonsol - Solana channel to bonsai

starknet_infra_utils - Infrastructure utility.

rs_ctx - Context propagation for rs framework

innofile - InnoFile

bye_orb_rs - A Rust library for ORB (Oriented FAST and Rotated BRIEF) keypoints.

bonsol-interface - Interface to Bonsol on-chain program instructions, PDA methods and non-flatbuffer types

json-fixer - A robust library for fixing and formatting malformed JSON with support for type conversion

rusotp - Rust implementation of the HOTP and TOTP algorithms

future-metrics - Instrument futures with execution metrics

markitdown - A Rust library designed to facilitate the conversion of various document formats into markdown text.

bonsol-sdk - SDK for interacting with Bonsol programs

bitask - Bitask is a Rust implementation of Bitcask, a log-structured key-value store optimized for high-performance reads and writes.

trussed-auth - Authentication extension for Trussed

solana-loader-v2-interface - Solana non-upgradable BPF loader v2 instructions.

tracing-rewrite - Tracing logs conditional rewrite wrapper

ezark - Open source archive utility written in Rust

study_2025_1_7 - A brief description of what your crate does.

daipendency-extractor-rust - Daipendency extractor for Rust library crates

async-llm - A Rust library for OpenAI-compatible APIs

vls-common - Common code for Validating Lightning Signer

vls-policy-derive - A library for implementing a Lightning signer, which externalizes and secures cryptographic operations.

r-projects - Descripción breve de tu binario o proyecto

daipendency-extractor - Core library for Daipendency extractors

tracing-subscriber-multi - Configure multiple log destinations for tracing_subscriber.

starknet_sierra_multicompile - A utility crate for compiling Sierra code into CASM and / or native.

datafusion-sqllogictest - DataFusion sqllogictest driver

time_priority_order_algoritmh - This is an algorithm create a cronogram of action sorted by time of occurrence time avoiding time colisions.

daipendency - Provides AI coding assistants with public API from dependencies

addr_of - fn addr_of(ptr: &T) -> usize

block_compression - Texture block compression using WGPU compute shader

scale-compressed - Compress SCALE encoded data

amico-plugins - The plugins of the Amico AI Agent Framework

amico-firmware - The firmware of the Amico AI Agent Framework

mockdown - Mockdown is a single file and macro/dependency free mock library for Rust

op-alloy-flz - Tiny FastLZ compression library

zkstack_cli_git_version_macro - Procedural macro to generate metainformation about build in compile time

embedded-sdmmc-dev - A basic SD/MMC driver for Embedded Rust.

system-pause - system-pause is a Rust library for stopping program execution temporarily. It offers simple macros for pausing the console, either waiting for user input or pausing with a countdown timer. This is useful for debugging or interactive console applications.

rsii - RSII - Rust AI Command-line Assistant

hs1-siv - Pure Rust implementation of the HS1-SIV Authenticated Encryption with Additional Data Cipher. Based on ChaCha.

eros - Context aware, ergonomic and precise error handling.

ajj - Simple, modern, ergonomic JSON-RPC 2.0 router built with tower and axum

zksync_vm_interface - ZKsync Era VM interfaces

zkstack_cli_types - ZK Stack CLI is a set of tools for working with zk stack.

zkstack_cli_config - ZK Stack CLI is a set of tools for working with zk stack.

zkstack - ZK Stack CLI is a set of tools for working with zk stack.

zkstack_cli_common - ZK Stack CLI is a set of tools for working with zk stack.

inference-gateway-sdk - Rust SDK for interacting with various language models through the Inference Gateway

progenitor-cli - A CLI tool for generating custom code templates

ic-response-codes - Internet Computer Response Codes

ic-management-canister-types - Types for calling the IC management canister

sqlite-wasm-macro - Helps generate multithreading code

udled-tokenizers - Tokenizers for udled

mime-multipart-hyper1 - MIME multipart parsing, construction, and streaming compatible with hyper v1.x (fork of mime_multipart crate)

prefer-dynamic2 - Copies the pre-compiled dynamic std library to your target directory, for -Cprefer-dynamic and dylib crates

pemel - Parsing and Evaluating of Math Expressions Library

tiff2 - temporary async implementation of tiff - to be upstreamed into image-tiff

podzol - A modpack package manager

dirbuf - reusable directory bufferes

flakysed - Clean CircleCI log files. Processes the input file to extract and clean log lines related to a specific worker, stopping at the first failure if present, and writes the normalized output to the specified file.

duvet-macros - Internal crate used by duvet

scanix - Scanix is tool to search a text or pattern in files. A fast and lightwight text tool.

duvet-core - Internal crate used by duvet

miden-proving-service-client - Client library for the Miden rollup proving service

ceylon-core - Ceylon framework core

styledlog - Styledlog: A Rust crate combining versatile logging features with styled output.

toresy - Simple term rewriting system based on tokenization

lld-rx - Updated LLD bindings for Rust

bevy_bsn - This crate is reserved for the Bevy Engine project

kaps - 🔐 Enterprise-grade file encryption toolkit

script-format - A simple DSL to format data via rhai scripting

shhh - Get alerts when you are too loud

chaste-bun - Parser for bun lockfiles

bip39-rusty - Bip39 implementation mnemonic system in rust

easycron - rust cron library

user_ - user_

integrity - Rust library for verifying STARK proofs from swiftness on integrity

replaxe - A command-line tool to replace text in files with easy patterns

brick - a lib

ghoul - A placeholder for future project written in Rust

geo-buf - This crate provides methods to buffer (to inflate or deflate) certain primitive geometric types in the GeoRust ecosystem via a straight skeleton. This crate builds upon the (presumably abandoned) geo-buffer crate.

pickle - a future project written in Rust.

tui-qrcode - A Ratatui widget for displaying QR codes in the terminal

static_ - init async as global static

caffine - Newsboat-like RSS reader written in Rust.

mirage - Arch Linux mirrorlist generator written in Rust

story - A placeholder for future project written in Rust

daze - Blinkenlight effect animation for terminal

jitaku - Keep home/dotfiles simple

deimos_shared - Shared packet formats and related resources for Deimos DAQ ecosystem

enigmatick_wasm - Enigmatick WASM Component

panchi - little X hotkey/macro automation

pktmon - A library for capturing network packets on Windows using the PktMon service

game_of_colors - command line game of life ... but colorful

sifli-pac - Peripheral Access Crate (PAC) for SiFli MCUs.

dcap-qvl-cli - Command line interface for Intel SGX DCAP Quote Verification Library

sifli-hal - Hardware Abstraction Layer (HAL) for SiFli MCUs

single_thread_cell - Create a cell that can only be accessed by a single thread.

wl_isomorphism - Implementation of the WL and 2-WL algorithms for graph isomorphism testing

abstract-impl - Create abstract implementations for traits

cnp - A utility tool written in Rust to check unused node packages.

miden-proving-service - Miden rollup proving service

composite_modulus_proofs - Proofs about several propoerties of a composite modulus - square-free, product of 2 primes, a blum integer

kbvm - An implementation of the XKB specification

ollie - An abstraction layer on top of lapin, to align with traditional HTTP API routing.

objc2-intents - Reserved crate name for objc2 bindings to the Intents framework

numcodecs-pco - Pcodec implementation for the numcodecs API

log_manager - log manager using tracing crates

dotporter - A CLI tool to manage your dotfiles

vsomeip-proc-macro - Useful proc macros for generating necessary extern 'C' fns for use with vsomeip.

libp2p_dandelion - Proof-of-concept modified Dandelion implementation extending from libp2p

normal-rust-task-manager-lol - A normal command-line task manager

braillix - A dot-matrix display implemented with braille characters

braillix_ratatui - Adapter to use braillix as a ratatui widget

vsomeip-sys - Somewhat low level unsafe wrapper around vsomeip

up-transport-vsomeip - Layer-1 uTransport implementation for vsomeip (SOME/IP)

webidl2wit - Library that proivdes conversion from WebIDL to WebAssembly Interface Types (WIT)

req_ - Extract message form headers only once for one request ( support async and sync ) / 一个请求只提取一次消息, 支持异步和同步

y-engine - A micro-engine that handles boilerplate (winit, wgpu, etc.) and adds quality-of-life features for easy application setup.

forc-migrate - Migrate Sway projects to the next breaking change version of Sway.

async-opcua-xml - OPC UA XML loading library

cost_time - util for cost time

forevervm-sdk - foreverVM SDK. Allows you to start foreverVMs and run a REPL on them.

forevervm - foreverVM CLI. Allows you to start foreverVMs and run a REPL on them.

echo_http - Axios like http client for the typescipt devs that just can't let go

wasmcloud-provider-http-server - Http server for wasmcloud, using Axum. This package provides a library, and a capability provider

wasmcloud-provider-messaging-nats - A capability provider that satisfies the 'wasmcloud:messaging' contract using NATS as a backend.

async-opcua-macros - OPC UA support proc macros

async-opcua-types - OPC UA data types

aggligator-transport-websocket - Aggligator transport: WebSocket

spawn-cli - A command-line tool for creating files and folders from a template.

sketchlib - Genome and amino-acid sketching

aggligator-monitor - Aggligator link monitor and speed test

aggligator-transport-bluer - Aggligator transport: Bluetooth on Linux

aggligator-wrapper-tls - Aggligator transport wrapper: TLS

aggligator-transport-tcp - Aggligator transport: TCP

aggligator-transport-usb - Aggligator transport: USB

json_repair_rs - json repair library for rust

watermelon-proto - #[no_std] NATS Core Sans-IO protocol implementation

watermelon-mini - Minimal NATS Core client implementation

watermelon-nkeys - Minimal NKeys implementation for NATS client authentication

watermelon-net - Low-level NATS Core network implementation

watermelon - High level actor based implementation NATS Core and NATS Jetstream client implementation

dbg-ranges - Helps with debug formatting lists of items that have many sequential items

tuono_internal - Superfast React fullstack framework

aggligator-transport-websocket-web - Aggligator transport: WebSocket for the web targeting WebAssembly

openai-rust2 - An unofficial library for the OpenAI API

nt-user-call - Provides bindings to all functions accessible via the NtUserCall* family of system calls.

chia-puzzle-types - CLVM types for standard Chia puzzles.

gs-rust-cache - Thread safe cache developed using lru crate(https://crates.io/crates/lru) as its core. Supports LRU, positive and negative TTLs and miss handler function.

nostra - A placeholder for future project written in Rust

spideroak-crypto-derive - Proc macros for spideroak-crypto

proton-cli - A template command line application written in Rust leveraging the clap framework

miami - Minimal dependency MIDI file format parser and writer

gridlife - An library to generate and simulate Conways Game of Life cellular automatons

robinson - For when you go to a lonely island and survival depends on parsing XML.

ourobuf - A no_std circular buffer with constant-time operations

evm_ekubo_sdk - Types for interacting with Ekubo Protocol on EVM chains

zarrs_data_type - Zarr data types for the zarrs crate

amareleo-chain-resources - Resources for a lite Aleo development node

disperror - Displaying errors instead of Debugging them when returned from main.

tree-sitter-mtf - MegaMek mtf parser

crc10-atm-fast - SIMD-powered implementation of CRC-10/ATM (CRC-10 CRC-10/I-610)

crc10-cdma2000-fast - SIMD-powered implementation of CRC-10/CDMA2000

crc10-gsm-fast - SIMD-powered implementation of CRC-10/GSM

crc11-flexray-fast - SIMD-powered implementation of CRC-11/FLEXRAY (a.k.a. CRC-11)

crc11-umts-fast - SIMD-powered implementation of CRC-11/UMTS

beekeeper - A full-featured worker pool library for parallelizing tasks

ureeves-userfaultfd-sys - Low-level bindings for userfaultfd functionality on Linux.

ureeves-userfaultfd - Rust bindings for the Linux userfaultfd functionality

robin_cli_tool - A CLI tool to run scripts for any project

mapstic - Tooling to generate Elasticsearch index mappings from type definitions

slabbable - Slabbable data structure trait

mapstic-derive-impl - Implementation of the derive macro provided by the mapstic crate

mapstic-derive - Derive macro exported by the mapstic crate

mapstic-core - Internal functionality used by the mapstic crate at runtime

slabbable-slab - Slabbable slab impl

bandurria - Self-hosted lightweight comment system for static websites and blogs.

slabbable-stablevec - Slabbable stablevec impl

slabbable-hash - Slabbable hash impl

slabbable-impl-selector - Slabbable data structure impl selector

slabbable-validation - Slabbable data structure trait impls validation

networker-rs - A Rust library providing TCP, UDP, and HTTP easier calls.

cherry-evm-schema - EVM schema definitions for cherry

librsmsx - a MSX emulator written in rust, a port from gomsx

pubsub-rs - This crate provides a simple yet powerful publish-subscribe (pubsub) system that allows multiple subscribers to receive messages published to specific topics. It is designed to be thread-safe, async-friendly, memory-efficient, and supports clean shutdown.

laddu-amplitudes - Amplitudes for the laddu library

poise_error - An opinionated plug-and-play library for error handling in Discord bots made with poise.

Subscription & Support

This journal is completely free. Additionally, all open-source projects I develop are licensed under the permissive MIT and Apache-2.0 licenses.

If you like the project, you can support it by subscribing to Knowledge.Dev, an e-book about Rust that I am developing in my free time. This allows you to support my projects while also gaining access to premium content for learning Rust in practice, which I carefully curate.

Also, subscribe to this crab-sized journal, Crateful, to receive interesting news about Rust development for agent-based systems and distributed applications.