Crateful 02/25

Transactional actors, CRB 0.0.28 release, presentation of the new Nine framework, and a list of over 300 crates.

Feb 18, 2025

The interface of the future

Last week, social media platforms were buzzing with discussions about DeepSeek—a new language model. The model is truly impressive. I’m not sure how exactly it was trained, but I tested it by implementing a protocol on libp2p, and to my surprise, it handled the task exceptionally well.

But what’s even more important—and something we might have overlooked—is how much demand there is for such models and how quickly users are willing to try new tools and switch to different products. The interface of these AI-powered services is so simple and intuitive that the only thing keeping users engaged is the quality of the model itself.

This reinforced my belief that a high-quality language model is the interface of the future—it’s how we will interact with various systems and services. More models will emerge, becoming increasingly human-like, and it seems clear that breakthroughs in this field will pay off rapidly. For modern developers, this is a crucial shift to embrace—learning, building, and innovating—because the iceberg has already broken off, and it’s reshaping the world right now.

CRB 0.0.28

For the past two weeks, I’ve been working with the Nine framework, which also helped in debugging the CRB framework that powers Ice-Nine. As a result, a new version, 0.0.28, has been released with a huge number of updates. The most important improvements include fixes for issues in starting and stopping agents.

New activity interruption system

The agent interruption system has undergone significant improvements. Previously, it relied on two key components:

The Interruptor structure, which contained an AbortHandle for emergency termination and an AtomicBool for a softer interruption notification that could be processed at a convenient runtime moment.
The agent's Address and an Interrupt message, which was only accepted when the agent was running in actor mode.

In practice, only the first method was actively used at runtime, while the second operated at the message-handling level. This limitation made it impossible to interrupt a finite state machine (FSM) using an address, which became problematic when the FSM got stuck in a loop while processing messages.

To create a more elegant solution, I introduced the Interruptor trait. This trait is now implemented both for the original Interruptor structure (which has been renamed to Stopper) and for a combination of Address and Stopper.

Now, it is possible to interrupt an agent not only in actor mode but also when functioning as a finite state machine. Additionally, support for different interruption levels has been added, along with a new interrupt_with_level() method that accepts an interruption level as a parameter. This allows for a more granular approach to handling interruptions, ranging from soft interruptions to emergency application termination.

async fn join_or_signal<A: Agent>(addr: Address<A>) -> Result<()> {
    let mut level = InterruptionLevel::EVENT;
    loop {
        select! {
            _ = signal::ctrl_c() => {
                addr.interrupt_with_level(level);
                level = level.next();
            }
            _ = addr.join() => {
                break;
            }
        }
    }
    Ok(())
}

With intermediate interruption levels, developers can implement flexible logic. For instance, an initial soft interruption might close active connections without stopping execution, while a subsequent interruption could trigger a refill mechanism, eventually leading to socket closure only after multiple attempts.

This system offers significant flexibility. As part of these changes, a new Main trait has been introduced. This trait launches an actor, listens for application interruption signals, and translates them into agent interruption signals. Each time Ctrl+C is pressed, the severity level of the interruption increases.

I have already found this approach incredibly useful—when something is not implemented correctly in my agents, they can still exit a locked state and terminate gracefully.

Pinging agents

In a previous update, I mentioned that CRB is designed to allow developers to create custom extensions for actors or implement specific message handling across all actors.

While working with the framework, I encountered a common need: waiting for an agent to fully initialize and be ready to process messages in actor mode. To address this, I introduced a Ping message, now implemented for all actors.

Additionally, I created the PingExt extension for both Address and Context, which adds a convenient ping() method.

impl MeshNode {
    pub async fn activate() -> Result<()> {
        Self::new().spawn().ping().await
    }
}

With this update, you can now use any agent's address to call ping(), receiving a response when the actor is ready. The method returns a Fetcher object, allowing you to await the response asynchronously or handle it as a message within the actor system.

This feature makes it easier to manage actor readiness, ensuring smooth communication and coordination in your applications.

Stream сonsumption

A common requirement when working with actors is consuming a stream and transforming its elements into messages. In the past, I often implemented this manually, so I decided to integrate this functionality into the superagent extension.

To achieve this, I introduced Drainer, a wrapper that takes a Stream implementation in its new() constructor. Each Item from the stream is converted into a message and delivered to the OnEvent message handler of the corresponding agent.

pub fn from_receiver<M>(rx: mpsc::UnboundedReceiver<M>) -> Drainer<M>
where
    M: Tag,
{
    let stream = UnboundedReceiverStream::new(rx);
    Drainer::new(stream)
}

Drainer functions as a standalone agent responsible for reading and forwarding the stream. It can run under a supervisor’s observation, ensuring continuous processing even when the main agent is busy handling other messages.

One key advantage of this approach is that Drainer operates as an independent asynchronous task, allowing the main agent to stay responsive while the stream is being processed. Additionally, Drainer can be enhanced with more advanced logic, such as limiting the number of messages processed per second, providing better control over message flow.

This new functionality simplifies stream handling in the actor framework, making it easier to integrate real-time data processing into actor-based applications.

Assigning streaming tasks to a `Supervisor`

The introduction of subtasks like Drainer marks the beginning of a broader approach—where child tasks are responsible for delivering messages to a supervisor. To simplify the integration of such activities into an agent, a new trait, ForwardTo, has been added.

This trait allows an agent implementing ForwardTo to be wrapped in a runtime environment, such as RunAgent, and launched while providing the address of its supervisor.

impl<F: Flow> DoAsync<Initialize> for RemotePlayer<F> {
    async fn handle(&mut self, _: Initialize, ctx: &mut Context<Self>) -> Result<Next<Self>> {
        let node = MeshNode::link()?;
        let mut control = node.connector.get_control().await?;
        let stream = control.open_stream(self.peer_id, PROTOCOL.clone()).await?;
        let (drainer, writer) = from_stream(stream);
        ctx.assign(drainer, (), ());
        self.writer.fill(writer)?;
        Ok(Next::events())
    }
}

To start and attach an agent that implements ForwardTo, you can now use the new assign() method in the supervisor’s context. This makes it easier to manage child tasks, ensuring seamless message forwarding and improved modularity in actor-based applications.

Message Tagging

Traditionally, the OnEvent trait could only be implemented once for a specific message type and actor type pair. This is similar to how the Handler trait works in the actix framework.

But what if you need to handle a message defined in a separate crate while also having two different handlers, with the choice of handler being determined when sending the message to the actor?

The OnEvent trait now includes a type parameter for a tag, which defaults to (). By explicitly specifying this type, you can define as many handlers as needed.

Why is this useful? For example, you can pass a stream or task ID, or some other key that helps determine where to store the results of message processing.

For example, the code below processes stream messages (a block of bytes) while also passing a stream identifier:

impl OnEvent<Vec<u8>, StreamId> for StreamPorcessor {
    async fn handle_tagged(&mut self, data: Vec<u8>, tag: StreadId, ctx: &mut Context<Self>) -> Result<()> {
        self.handle(data, ctx).await
    }
}

By default, the handle() method is called—this was explicitly shown in the previous code for clarity. If your existing OnEvent handlers already override handle(), you don’t need to change anything.

To send a message with a specific tag, use the event_tagged() method:

address.event_tagged(item, stream_id)?;

Deferred agents launch

Agents are launched either by executing the asynchronous run() method or using the spawn() method, which starts the agent in a separate asynchronous task.

Another approach is to start an agent with the supervisor’s spawn_agent() method. However, this does not provide control over the agent’s runtime, as it starts immediately. In some cases, it is necessary to create a runtime, obtain its address, and launch it later. For example, if you want to store the address of a running agent in a global variable, but until it is saved, any launched agents attempting to access the variable may encounter an error.

To address this issue, a special deferred pool called Stacker has been introduced. Agents can be added to this pool, where an AgentRuntime will be created for them but not started. Here’s how it works in practice:

impl DoAsync<Initialize> for Hub {
    async fn handle(&mut self, _: Initialize, ctx: &mut Context<Self>) -> Result<Next<Self>> {
        let mut stacker = Stacker::new();

        let server = HubServer::new();
        let server = stacker.schedule(server, Group::Server);

        let client = HubClient::new();
        let client = stacker.schedule(client, Group::Client);

        let reporter = Reporter::new();
        stacker.schedule(reporter, Group::Reporter);

        let link = HubLink {
            hub: ctx.to_address(),
            server: server.equip(),
            client: client.equip(),
        };
        HUB.set(link).map_err(|_| anyhow!("Hub is already activated"))?;

        stacker.spawn_scheduled(ctx);

        Ok(Next::events())
    }
}

The agent is scheduled for execution using the schedule() method. Later, to launch it, you simply call the spawn_scheduled() method, passing the supervisor's context as a parameter. This allows the supervisor to be extended with the required number of deferred pools and to start actors when the time is right.

Nine - AI agent framework

In this issue, I’d like to introduce a project built on the CRB framework: the AI agent framework Nine - Nethermind Intelligent Nodes Environment - which I’m currently developing at Nethermind.

Nine is an incredibly powerful framework that I’m sure you’ll find extremely useful. Its main goal is to let you build custom mesh networks of agents featuring live configuration and a dynamic user interface. These agents can operate in different environments - STD, WASM, and TEE - making Nine a highly versatile solution for various applications.

The concept

I’ve already made significant progress on various parts of the framework, and I’d like to share some key features that will be available soon.

Composable Agents

AI agents in Nine are created by combining different “particles” into a single “substance.” You can mix various LLMs, connectors for messaging platforms, and different methods of loading data into the model.

Distributed Architecture

Newly created AI agents can immediately work in a distributed mode, where one component connects to another via a P2P connection. This setup gives you the flexibility to add new tools and expand the agent’s capabilities without stopping its operation.

No-code UI

The user interface is generated automatically based on the elements you use. This provides both a visualization layer and a control panel for the entire agent system—no extra coding or deployment steps required.

Live Reconfiguration

A deployed agent network can seamlessly adjust its settings on the fly thanks to transactional actors. For example, you can connect to a specific LLM model or change parameters like temperature and timeouts—all without restarting the agent.

Progress

Here’s a quick summary of what I’ve been working on over the past week.

TUI Interface

A small integration and TUI interface are already ready. In the recorded screencast, you can see how the interaction with the model takes place, as well as the event tracing and control system, which promptly reports on what is happening in the system.

Implemented components

Transactional actors – Manage different parts of the system, coordinating updates and actions.
Live configuration updates – Automatically notifies relevant actors whenever any part of the configuration changes.
Model interaction framework – A system for interacting with AI models.
OpenAI integration – Currently without tools, but fully operational for basic model interactions.
Anthropic integration – Contributed by a hackathon participant (not yet production-ready, but we value all external contributions).
libp2p integration – Enables direct, peer-to-peer information exchange between nodes.
Custom tracing system – Similar to OpenTelemetry but designed for bidirectional interaction, state exchange, and deltas. This forms a meta-layer that will eventually support no-code agent development.
Initial distributed UI components – Laying the groundwork for a scalable user interface.
Telegram connector – Currently interacts directly with the core; will later connect to the meta-layer and become a standalone component.
Early TUI interface – Simple but demonstrates full agent interaction.
Stdio-based interaction app – Already quite polished; a screen recording demo is on the way.

Further steps

Tools Support – In progress. I prioritized building the P2P layer first to better understand how tools should integrate dynamically.
dydx Agent – This will be the first complete use case. After that, I plan to create a chatbot (similar to Eliza) with live personality shifting (think real-time mood changes).
More Informative TUI – Aiming for a more visual and user-friendly text interface to showcase the system to a broader audience.

You can already try out the functionality, and I’m planning to enhance Rust content collection using Nine.

Flows

One of the key concepts implemented within the framework is stateful flows - specialized streams that retain their current state. These flows serve as the foundation of the meta-layer, enabling interactions between different components of the agent.

These flows and their states are transmitted over P2P connections upon request, making the system fully adaptable to any structure.

For example, the flow below handles a dialogue with an LLM, where the state is represented as a collection of messages:

#[derive(Clone, Serialize, Deserialize, Default, Debug)]
pub struct Chat {
    pub messages: Vec<Message>,
}

In our implementation, a message is a structure that includes both the role of the participant who generated the message and the message text itself.

#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct Message {
    pub role: Role,
    pub content: String,
}

#[derive(Clone, Serialize, Deserialize, Debug)]
pub enum Role {
    Request,
    Response,
}

State management in flows

The state supports serialization and deserialization, allowing it to be easily restored on a remote machine.

To update the state, the framework utilizes the concepts of events and actions. These are implemented within the Flow trait, which enables the propagation of events to the state.

Events are sent by the state provider, which is responsible for managing and forming the state. In our case, this role is handled by the actor that facilitates interactions with the LLM.
Actions, on the other hand, are sent by the subscriber. They allow the subscriber to initiate specific actions on the state provider, such as sending a request or adding a message.

impl Flow for Chat {
    type Event = ChatEvent;
    type Action = ChatAction;

    fn apply(&mut self, event: Self::Event) {
        match event {
            ChatEvent::Add { message } => {
                self.messages.push(message);
            }
        }
    }
}

The Flow trait requires you to define how incoming messages will modify the state. However, it does not enforce any specific logic for handling actions—you have full control over this in your actor implementation.

You can even ignore certain actions if they are not relevant at a given moment in the agent's workflow.

I plan to make actions interactive in the future, meaning they will generate responses when triggered.

For chat interactions, we primarily need:

An event to add a message to the list.
An action to send a prompt to the LLM.

All of this can be elegantly implemented using enumerations:

#[derive(Clone, Serialize, Deserialize, Debug)]
pub enum ChatEvent {
    Add { message: Message },
}

#[derive(Clone, Serialize, Deserialize, Debug)]
pub enum ChatAction {
    Request { question: String },
}

Chat is just one use case. The same system is also used for peer connection notifications, internal system events, and, in the future, will provide detailed tracking of sent requests and received responses from every integration participant—whether it's an LLM or a tool. This will enable real-time experimentation and exploration of agent-based solutions

Content

I’ve noticed that AI enables me to gather an enormous amount of information about various projects - far more than I could collect by hand. And it’s not just a list of repositories; it’s detailed reports on project architectures and updates. With each new issue, I’ll strive to provide even more information compiled with the help of agents.

First, it will allow more frequent journal releases, and second, it ensures we won’t miss anything happening in the Rust world. I believe that’s exactly what we all want to see. And now, let’s move on to the section compiled for us by the crab-agents.

Crates released this week

TOTAL: 358 crates

dela (21 stars) - A task runner that delegates to others, discovering tasks from Makefiles, package.json, and more

tagid-derive (0 stars) - Defines a derive macro for the tagid newtype labeled tagging for different types of ids.

tagid (0 stars) - Defines a newtype labeled tagging for different types of ids.

socks2 (0 stars) - SOCKS proxy clients

prk_async_dataflow (1 stars) - An asynchronous dataflow processing library for Rust to parse JSON/NDJSON streams.

adflib-cli (0 stars) - The Command Line Toolkit for managing ADF disk images with extended features.

vectormatrix (0 stars) - Idiomatic Matrix and Vector types for Rust

nu_plugin_port_extension (14 stars) - A nushell plugin to list all active connections and scanning ports on a target address

console-timer (0 stars) - Simple timer in your terminal.

rule_rs (1 stars) - A lightweight rule engine implemented in Rust that supports asynchronous execution, component extension, and rule chain orchestration.

altius-benchtools (0 stars) - A high-performance profiler for tracing RPC server execution

lcd_ili9225_rs (0 stars) - A simple crate for ili9225 lcd with embedded-hal

vdf-serde-format (0 stars) - A VDF serialization/deserialization file format using serde.

googleapis-tonic-google-storage-platformlogs-v1 (1 stars) - A Google APIs client library generated by tonic-build

namada_apps (2458 stars) - Namada CLI apps

actix-cookie (0 stars) - Cookie extractor middleware for actix-web

bevy_replicon_example_backend (399 stars) - A simple transport intended only for examples

ndarray-polyfit (0 stars) - Polynomial fitting based on ndarray

geosite-rs (0 stars) - A simple crate that parses geosite.dat file format

derive2 (0 stars) - An attribute macro that executes a function-like macro

include_url_macro (0 stars) - A procedural macro to include URL content as static strings at compile time

async (11005 stars) - async

windows-sync (11005 stars) - async

windows-futures (11005 stars) - async

string-literal-const-replace (7 stars) - Proc macro for compile-time find/replace on string literals

ladfile (464 stars) - Language Agnostic Declaration (LAD) file format for the bevy_mod_scripting crate

yapi-rs (0 stars) - A Rust port of [Yet Another Process Injector] that reduce differences between x64, wow64 and x86 processes.

solagent-rig-birdeye (43 stars) - solagent.rs rig birdeye

rindexer (317 stars) - A no-code or framework to build blazing fast EVM indexers - built in rust.

wasm-http-hyper (1 stars) - A Rust WebAssembly library that provides seamless integration between Node.js's IncomingMessage and Rust's hyper::Request

bbgun (0 stars) - A builder for builders running builders!

color-debug (0 stars) - Monkey-patches Rust's fmt system to make Debug colored

ferrite_ml_framework (1 stars) - A modern, robust and simple to use ML framework written in Rust for pure performance and memory safety

serde-devo-derive (0 stars) - A derive macro for shared type compatibility

serde-devo (0 stars) - A shared type compatibility helper

libprettylogger (1 stars) - A highly customizable logger library.

pulsarss (0 stars) - RSS Aggregator for Gemini Protocol

globalsearch (1 stars) - Global optimization with scatter search and local NLP solvers written in Rust using argmin

a8mini-camera-rs (0 stars) - This project is a Rust port of A8mini-gimbal-camera-control (C version) originally created by thiagolages.

stylus-test (273 stars) - Testing utilities for Arbitrum Stylus contracts

passnag (0 stars) - a tool that nags you to train your passwords

westem (2 stars) - This is a simple calculator program written in Rust that performs basic arithmetic operations. It takes three command-line arguments: the left operand, the operator, and the right operand. The program then calculates the result of the operation and prints it to the console.

bimultimap (0 stars) - A Bidirectional multi map

mdsecheck (0 stars) - Tools for generating unconditionally secure square MDS matrices over prime finite fields for partial substitution-permutation networks, which are widespread designs of symmetric ciphers and hash functions.

xml-canonicalization (0 stars) - XML Canonicalisation Library in pure Rust

enum-generator-macros (0 stars) - Macros for enum generator crate

prin (5 stars) - A simple reverse proxy terminal utility

enum-generator (0 stars) - Generate enum from template

gabelang (1 stars) - A high level, interpretted and garbage collected programming language

pcal6416a (0 stars) - Platform-agnostic Rust driver for the Texas Instruments BQ25773 battery charge controller.

ic_tee_gateway_sdk (10 stars) - The rust SDK for the IC TEE Gateway

hpt-allocator (1 stars) - A library for memory allocator for hpt

hpt-macros (1 stars) - A library for generating helper functions for hpt

unlimited-ammo (0 stars) - Hot reloader for Rust codebases, never waste time rebuilding again.

hpt-common (1 stars) - A library for common utilities for hpt

hpt-display (1 stars) - A library for displaying tensors

alisa (0 stars) - A framework for building apps with real-time collaboration

hpt-dataloader (1 stars) - A library for data loading for hpt

alisa-proc-macros (0 stars) - Procedural macros for the Alisa framework

dbsdk-vu-asm (0 stars) - Proc macro support for assembling in-line VU programs for the Dreambox fantasy console

pierro (1 stars) - An immediate mode UI library for Rust

pf_cmd (0 stars) - petit-filou scans wordpress websites to find videos

hpt-cudakernels (1 stars) - A library implements cuda kernels for hpt

sem-tool (1 stars) - A simple Semantic Versioning CLI tool for parsing, filtering and sorting

const-macros (1 stars) - Various macros for const contexts.

cursor-iter (1 stars) - Nicer string iteration

issue-hunter (3 stars) - A command line tool to capture the status of issue lists from multiple repositories

cargo-clicker (0 stars) - who's a good programmer? you are!

hpt-iterator (1 stars) - A library implements iterator for hpt

pfs_unpacker (0 stars) - Artemis Engine archive unpacker ( packer )

tmp1075 (0 stars) - Platform-independent Rust driver for TMP1075 digital temperature sensor

pkarr-relay (259 stars) - Pkarr relay (https://pkarr.org/relays)

mnemnk-application (0 stars) - Mnemnk agent for monitoring application usage

capacity (3 stars) - Simple capacity type

hadris-fat (0 stars) - A library for working with FAT32 file systems, a standalone crate included in the hadris project

sqlite-change-stream (2 stars) - A small command-line tool developed that monitors changes in a SQLite database in real-time and outputs change events in JSON format to stdout.

mnemnk-screen (0 stars) - Mnemnk agent for capturing screen

mnemnk-api (0 stars) - Mnemnk agent of API server

solagent-plugin-birdeye (43 stars) - solagent.rs plugin birdeye

elote (0 stars) - Street-food priced logging that doesn't take vendor lock-in for an answer

zsync (0 stars) - A Zero Dependency async net runtime thats truly cross-platform, including Windows, Linux, and MacOS.

http-relay (41 stars) - A Rust implementation of some of Http relay spec.

cherry-svm-schema (6 stars) - SVM schema definitions for cherry

jdescriptor (0 stars) - Java Bytecode Descriptor Parser for Rust

cpr-cli (0 stars) - A simple git-based project manager aimed at C/C++

blog (0 stars) - A CLI tool to manage blog posts

serde_agaby (9433 stars) - A generic serialization/deserialization framework

lonesha256 (0 stars) - Rust bindings for the lonesha256 C library

msb (0 stars) - Build system in Rust

aptmirs (4 stars) - A simple tool for mirroring apt/deb repositories

deboa (1 stars) - A friendly rest client on top of hyper.

macnuf (0 stars) - A #![no_std] Rust library to get the manufacturer of a specific MAC address

cargo-warloc (10 stars) - Smart LOC counter for Rust projects

paas-api (0 stars) - Common API for PAAS server and client

url-preview (3 stars) - High-performance URL preview generator for messaging and social media applications

eserde (14 stars) - Like serde, but it doesn't stop at the first deserialization error

eserde_derive (14 stars) - A derive macro for the eserde crate

robonet (0 stars) - A tool to manage network connectivity and to facilitate remote access to robots

ration (1 stars) - A shared memory library

fire-auth-token (0 stars) - Firebase Auth Token Verification Crate

mikan-rs (0 stars) - A medical image kit for segmentation metrics evaluation, native Rust support, and Python bindings for cross-language performance.

linker-sections (0 stars) - Linker section memory initialization

exo_task (0 stars) - A lightweight async task executor for bare metal (or any) systems

annotated-string (3 stars) - String with ability to annotate (format) its individual fragments

unicode-box-drawing (3 stars) - Unicode box-drawing characters

rquest-util (3 stars) - Common utilities for rquest

fireengine (0 stars) - This program generates a firewall configuration based on a set of specified logfiles.

rocal (0 stars) - Local-first-development driven web application framework

opentelemetry-xray (2 stars) - A library for AWS X‑Ray distributed tracing using OpenTelemetry.

credibil-dwn (1 stars) - Decentralized Web Node (DWN)

bullmq_rust (3 stars) - A tool to search files

pixt (0 stars) - Terminal Based Cross Platform Image Viewer

rocal-cli (0 stars) - CLI tool for local-first-development driven web application framework

range_vec (0 stars) - Fast indexed access to a range of mostly-default values

clighlighter (0 stars) - simple command-line code highlighter

rocal-core (0 stars) - Core for local-first-development driven web application framework

rocal-macro (0 stars) - Macros for local-first-development driven web application framework

altv_internal_resource_before_unload_macro (34 stars) - Proc-macro for defining before_unload callback of alt:V Rust resource. Not intended for direct use.

astd (0 stars) - A drop-in replacement for std in no-std environments, with full abseil backend.

io-uring-fd (3 stars) - io_uring filehandle types

io-uring-owner (3 stars) - io_uring owner type for the ownership management

rs-ml (0 stars) - Simple ML crate including Gaussian Naive Bayesian classifier

io-uring-opcode (3 stars) - io_uring opcode trait contract between bearer and opcodes

io-uring-bearer (3 stars) - io_uring bearer

run_once (0 stars) - Runs code in rust once, from a closure

fuel-streams-subject (15 stars) - Macros for implementing subject functionality in the fuel-streams crate

parameterx (0 stars) - A flexible and type-safe parameter management system for Rust applications. This library provides multiple ways to store and retrieve typed values using a key-value structure, with support for custom types and various initialization patterns.

owo-rs (1 stars) - make your logs more owo

objc2-execution-policy (468 stars) - Reserved crate name for objc2 bindings to the ExecutionPolicy framework

simple-kube-controller (2 stars) - Library to streamline the process of developing custom Kubernetes controllers.

obographs-dev (0 stars) - Load Obographs data files.

clippy-control (0 stars) - Control clippy lints with a configuration file

texoxide (0 stars) - Zoxide but for text files

vlazba (2 stars) - Lojban words generator and analyzer

hermes-five (9 stars) - The Rust Robotics & IoT Platform

pubky-homeserver (41 stars) - Pubky core's homeserver.

colored_text (0 stars) - A simple library for adding colors and styles to terminal text

gl-cli (123 stars) - A command-line interface for running a Greenlight signer and operating a Greenlight node

pubky-testnet (41 stars) - A local test network for Pubky Core development.

stylus-core (273 stars) - Core definitions of Stylus SDK traits and types that are used by multiple crates in the workspace

wgsldoc (0 stars) - Documentation generator for WGSL shaders

termai (0 stars) - AI assistant for the terminal

datefilter (0 stars) - Filter filenames on stdin to exclude filenames for dates which should be kept, and filenames not containing dates.

hermes-five-macros (9 stars) - Macros definitions for hermes-five.

bsqlite_derive (1 stars) - The derive macro's for the bsqlite crate

bsqlite (1 stars) - A simple and minimal Rust SQLite library with an ergonomic API

numcodecs-wasm-host (3 stars) - Import numcodecs-API-like compressors from wasm components

simple-vm (0 stars) - A simple bytecode VM with a custom compiler

zzh (0 stars) - ZZH is a cli tool that wraps SSH. It's not a drop in replacement, just a more enjoyable way of managing connections "

identity-kmers (0 stars) - sequence similarity based on identity kmers

graph-kmers (0 stars) - sequence similarity based on identity kmers

deutsch-geo-env-mapper (0 stars) - geomapper for deutsch code

easee-rs (1 stars) - A client for the Easee API

timeadair (0 stars) - Command line cross-platform pomodoro timer

numcodecs-wasm-host-reproducible (3 stars) - Import numcodecs API reproducible compressors from wasm components

shrimple-telegram-proc-macro (0 stars) - Implementation detail of shrimple-telegram. Do not use directly

shrimple-telegram (0 stars) - A library for shrimply running a Telegram bot

dabuild (0 stars) - Access genome build metadata

magic_string_rain (0 stars) - magic string

wtg (1 stars) - Chat with your program logs

symbol-ty-macro (1 stars) - A procedural macro for generating symbols as type-level strings.

symbol-ty (1 stars) - A library for generating symbols as type-level strings.

spl-token-interface (22 stars) - Instructions and types for interacting with SPL Token program

kona-net (155 stars) - Consensus networking library for the OP Stack

linux_bmi088 (0 stars) - Interface for BMI088 IMU

sql-schema (0 stars) - Declarative SQL schema migrations

powerfx (0 stars) - Embedded PowerFX interpreter.

destination (0 stars) - A library providing types and method for managing physical addresses in a municipality.

eb_bars (0 stars) - Tiny library for creating histograms or bar charts

tytanic-utils (37 stars) - Helper functions, types and traits for the tytanic test runner.

json_partial (1 stars) - Parse Imperfect Json given by LLMs

tytanic-filter (37 stars) - A generic filtlering DSL for the tytanic test runner.

now-proto-pdu (0 stars) - NOW protocol PDU encoding and decoding

aula01 (0 stars) - Biblioteca de funções

rustantic (3 stars) - Rust to Pydantic generator

cargo-regression (1 stars) - Collect test task from input files, execute them and compare results with golden.

ffi-enum-macros (1 stars) - Simply write and use enums like rust native enums, freely passing through ffi

rustantic-macros (3 stars) - Rust to Pydantic generator

ffi-enum (1 stars) - Simply write and use enums like rust native enums, freely passing through ffi

chap_grrs (0 stars) - A simple command line tool for searching files, line-by-line, with a keyword

filerix (0 stars) - Rust bindings for filerix

clap-logflag (0 stars) - This library can be used to add a --log flag to clap based command line applications that allows users to configure logging from the command line. It can log to stderr, files and syslog, powered by the fern logging backend.

unsafe-erased (6 stars) - This crate can be used for unsafe type erasure. caution is advised.

e2k (1 stars) - 英単語から読みを推論するライブラリ（Patchethium/e2kのRust実装）

bark-dev (0 stars) - This a library for the bark(receive notify on IOS devices)

bacdive (0 stars) - bacdive rust analyzer for microbial genomics

bacdive-analyzer (0 stars) - bacdive rust analyzer for microbial genomics

binkget (0 stars) - A simple command line tool for downloading files using HTTP(S) protocol.

absolute_unit (0 stars) - A system of scalars with units.

rust-mempool (2 stars) - A Rust Bindings for the Mempool API

my-rust-app (0 stars) - My Rust application.

alltrailsgpx (0 stars) - Get GPX files from Alltrails

hpt-types (1 stars) - A library define primitive types functions for hpt

hpt-traits (1 stars) - A library defines tensor operator traits for hpt

position_preserving_moodle_question_xml_edit (0 stars) - Diff-friendly Moodle question.xml editor library. For those situations where you only want to touch the contents of one element and leave the rest of the XML as it was.

graphql-normalize (0 stars) - Normalize (format and sort) GraphQL queries

hpt (1 stars) - High Performance Tensor (HPT) - A fast, efficient, and user-friendly tensor computation library for Rust

sea-orm-pro (2 stars) - Helper library for SeaORM Pro (Admin Panel)

rig-fastembed (2965 stars) - Rig vector store index integration for Fastembed. https://github.com/Anush008/fastembed-rs

novum (0 stars) - novum

bisonmq (0 stars) - A Lightweight and Simple Rust Library for Job Queue

aws-smithy-fuzz (528 stars) - Placeholder ahead of the next smithy-rs release

octabot-rust-sdk (1 stars) - The Octabot Rust SDK makes it easy to build plugins in Rust.

sciru (2 stars) - A high-performance library for mathematics, science, and engineering written in Rust.

rust-githubaction-demo (0 stars) - This package is used for test publishing a crate with github actions

edgezone-node (0 stars) - EdgeZone node server for distributed edge computing

shelgon (0 stars) - A robust framework for building interactive REPL applications and custom shells in Rust

snap-buf (0 stars) - A copy on write byte buffer for efficient snapshotting

mdbook-ai-pocket-reference (2 stars) - mdbook preprocessor for the ai-pocket-reference project.

bindex (4 stars) - Bitcoin indexing library in Rust

data_harvest (0 stars) - A library that harvests finance data from the Web.

async-arp (6 stars) - An async ARP client library for probing hosts and sending advanced ARP requests.

kuvpn (5 stars) - A convenient tool for connecting to Koç University's VPN using OpenConnect.

whynot-errors (0 stars) - A basic setup for app errors in axum

tt-toolkit (0 stars) - A collection of macros for rapidly prototyping programming languages

tt-toolkit_derive (0 stars) - Derive macros for tt-toolkit

setter (2 stars) - A simple configurating tool

is_wine (0 stars) - A library to easily check if the current app is running under wine.

windows-events (11005 stars) - async

buddy-up (0 stars) - Buddy up a changing group of people into unique pairs over time.

rat-dialog (11 stars) - stacked dialog windows

icu_time (1422 stars) - Deprecated crate!

yule_log (1 stars) - A streaming parser for PX4 ULOG files.

luigi-rs (0 stars) - Rust bindings for Luigi - a simple C GUI library

tampines-steam-tables (0 stars) - Steam Tables for the TAMPINES Library

packet_parser (0 stars) - A powerful and modular Rust crate for network packet parsing.

oxiblog (0 stars) - A tool to create a sql file to fill a database for your blog

oauth-token-service (0 stars) - A service to request and renew JWTs from an identity service using OAuth

browser-fs (3 stars) - A browser-based filesystem implementation for WebAssembly applications

atem-dots (1 stars) - A (dot)file manager

eserde_axum (14 stars) - axum extractors built on eserde to improve error responses

yotta (1 stars) - A no_std arbitrary-precision integer library

cortex-lang (0 stars) - A simple interpreted language for interfacing with Rust code

leptos-routes-macro (4 stars) - Proc macro deriving route structs for the leptos-routes crate.

adlo (0 stars) - Adaptive LLL algorithm for solving SVP

leptos-routes (4 stars) - Fluent route declarations for the Leptos web framework.

windows-event (11005 stars) - windows

windows-guid (11005 stars) - windows

windows-guids (11005 stars) - windows

time_app_tracker (0 stars) - Count the time you spend on the pc and the desired applications

windows-types (11005 stars) - windows

windows-type (11005 stars) - windows

windows-variants (11005 stars) - windows

dllx (0 stars) - Cross platform dynamic linking libraries

ohos-media-sys (5 stars) - Raw Bindings to the media framework on OpenHarmony

windows-delegate (11005 stars) - windows

tauri-plugin-android-fs (0 stars) - Android file system API for Tauri.

canvas-grading (2 stars) - CLI tool used to fetch submissions and upload grades to and from Canvas LMS

bt_time_utils (0 stars) - Basic time formatting utility

tokio-par-util (0 stars) - Utilities for running computations in parallel on top of Tokio

dxm (6 stars) - A manager for your FXServer builds & resources.

no-op (0 stars) - A minimal no-op Rust binary optimized for fast startup.

trf (0 stars) - Multimodal AI in the terminal

windows-delegates (11005 stars) - windows

playready-macros (6 stars) - Implementation of PlayReady DRM system based on pyplayready (helper macros)

playready (6 stars) - Implementation of PlayReady DRM system based on pyplayready

playready-ffi (6 stars) - Implementation of PlayReady DRM system based on pyplayready (C bindings)

rps_paijo (2 stars) - My first project of a simple Rock, Paper, Scissors game in Rust.

vq (7 stars) - A vector quantization library for Rust

ratatui_simple_logger (0 stars) - Simple logger widget for ratatui

human-time-cli (0 stars) - A command-line tool for converting time durations to human-readable formats, built using the human-time crate.

jagua-rs (58 stars) - A fast and fearless Collision Detection Engine for 2D irregular Cutting and Packing problems

librqbit-utp (0 stars) - uTP (uTorrent Transport Protocol) library, implements BEP 29

derive-mmio-macro (2 stars) - The proc-macro for derive-mmio

derive-mmio (2 stars) - A mechanism for making it easier to access MMIO peripherals

gdep (0 stars) - Git-deploy - Easily deploy & auto-update apps

init4-bin-base (2 stars) - Internal utilities for binaries produced by the init4 team

fuzzy-ls (0 stars) - Fuzzy file search command line utility.

hanconv (0 stars) - Convert between Simplified and Traditional Chinese

dfns-sdk-rs (5 stars) - Modular, extensible, and easy-to-use Rust SDK for the Dfns API

magic_migrate_derive (2 stars) - Derive macros for magic_migrate

bevy_uikit (3 stars) - Direct UIKit backend for Bevy Engine

authenticated-pseudonyms (3 stars) - An implementation of anonymous credentials

windows-future (11005 stars) - Windows

sculpt (0 stars) - Early Development: Rust types for XML, Typescript, and other schemas

waypwr (5 stars) - A power menu for Wayland

sigma_db (1 stars) - rust database library. documentation at https://malawarecreator.github.io/sigmadb-doc

svm_merkle_tree (0 stars) - for PoC purpose Abhishek Singh

godot-classes (3374 stars) - Godot bindings for Rust.

pwsp (1 stars) - A simple soundpad application written in Rust using egui for the GUI, pipewire for audio input/output, and rodio for audio decoding.

slackarc (0 stars) - Utility allowing easily define global Arc objects, lazyly initialized on demand

sweet_server (2 stars) - Cross-platform utilities and dev tools

smolagents-rs (4 stars) - A rust port of the the HuggingFace smolagents library. Build LLM agents with tools and code execution.

rustbam (0 stars) - Rust-powered BAM depth extraction with Python bindings

term-lab (0 stars) - A crate to easily work with terminal styles and get terminal info.

tabler-icon-definer (12 stars) - Macros for fast incremental loading tabler icons

beet_rsx_parser (59 stars) - Tools for developing reactive structures

beet_rsx_macros (59 stars) - Tools for developing reactive structures

beet_rsx (59 stars) - Tools for developing reactive structures

beet_router_parser (59 stars) - Tools for developing reactive structures

rustyray-ffi (0 stars) - Native bindings to Raylib

beet_router (59 stars) - Tools for developing reactive structures

beet_sim (59 stars) - Simulated environments in which behaviors can be run.

ngrams-rs (0 stars) - A Rust library to search the Google Books Ngram Dataset

oxnet (2 stars) - commonly used networking primitives with common traits implemented

df-interchange (4 stars) - Seamless interoperability between Polars and Arrow.

toni-cli (34 stars) - CLI for Toni

lsp-client (0 stars) - A client for the Language Server Protocol

toni (34 stars) - Fast and modular web framework for scalable applications

serde_fast_flatten_derive (0 stars) - A faster flatten implementation for serde

tubetti (1 stars) - Serve &[u8] data at a localhost url with minimal configuration

toni-macros (34 stars) - Macros for Toni

settings_loader (0 stars) - Opinionated configuration settings load mechanism for Rust applications

rustyray-math (0 stars) - Math library for Rustyray

rustyray (0 stars) - Safe bindings for Raylib done in a rust fashion.

portredirect (0 stars) - PortRedirect is a tool that bridges your frontend and backend by redirecting TCP connections through a persistent QUIC connection. It provides both a server (accepting TCP connections and forwarding them via QUIC) and a client (relaying QUIC streams to a TCP destination).

tui-equalizer (12 stars) - An equalizer widget for Ratatui with multiple frequency bands.

gltf-v1 (0 stars) - GLTF Spec 1.0

gltf-v1-json (0 stars) - JSON Package for GLTF Spec 1.0

asset-importer-rs (0 stars) - Assimp, but in Rust

jiff-icu (2023 stars) - Conversion routines between Jiff and ICU4X.

jiff-sqlx (2023 stars) - Integration for Jiff with SQLx.

jiff-diesel (2023 stars) - Integration for Jiff with Diesel.

clair (0 stars) - Command-Line Arithmetic in Rust

clash_rules (0 stars) - a clash yaml rule parser and matching algorithms provider

open-routerer (0 stars) - An unofficial Rust client for the OpenRouter API

scan_json (4 stars) - React to elements in a JSON stream

elastic_hash_rs (3 stars) - Elastic Hashing from Optimal Bounds for Open Addressing without Reordering

daft-derive (2 stars) - Derive macro for daft

daft (2 stars) - Structural diffs of Rust data structures

bnf_syntax_parser (0 stars) - The syntax parser based on BNF rules.

vminer-core (84 stars) - Core library for vminer

vminer (84 stars) - Virtual Machine Introspection library

tkn (0 stars) - A small library to generate tokens.

jwks-rs (0 stars) - jwks client

axdl (6 stars) - Unofficial implementation of Axera SoC image download protocol

axdl-cli (6 stars) - Unofficial CLI image download tool for Axera SoCs

namada_node (2458 stars) - Namada node library code

board_game_range (1 stars) - A set of iterators for target ranges in a square tile based board game.

varma_mycrate (0 stars) - A library for modelling concepts

serde_fast_flatten (0 stars) - A faster flatten implementation for serde

csv2xlsx-line (1 stars) - A rust library to convert csv to multiple xlsx files

runar (4 stars) - Watches for changes in files and RUNs And Restarts a program

sokudo (0 stars) - WIP: high-speed, memory-mapped persistent key-value database.

palcrypto-rs (0 stars) - A crypto lib.

stellar_cli_wallet_lumen (4 stars) - A CLI tool for interacting with Stellar and Soroban networks.

json_preprocessor (8 stars) - JSON PreProcessor

equity-scanner (0 stars) - A stock scanner for the equity market

postel (15 stars) - High level server for hyper and tower.

yiirs-contrib (2 stars) - Rust development utility library

git-biance (1 stars) - A small program that shows and visualizes code contributions in a git repository.

fortran-descriptor-parser-macro (0 stars) - Macro to parse bytes which are formatted according to a fortran format edit descriptor

fortran-descriptor-parser (0 stars) - Parse bytes which are formatted according to a fortran format edit descriptor

atem (1 stars) - A meta package manager

timbal (0 stars) - Instrumentations for functions, and more.

axum_thiserror_tracing (0 stars) - Helpful IntoResponse derive macro for the thiserror crate

assert_tv (0 stars) - De-randomized detereministic tests with test-vectors

gen3_rpc (0 stars) - RFSoC Gen3 MKID Readout RPC Interface

assert_tv_macros (0 stars) - De-randomized detereministic tests with test-vectors

water_uri (0 stars) - easy http Url parser that support http and https schemas

m5dial-bsp (0 stars) - Board support package for the M5 Dial.

shady-cli (12 stars) - A music visualizer in the terminal using shady-audio.

dn-cli (2 stars) - A simple, minimal, and flexible command line utility for organising plaintext files.

seismic-enclave (1 stars) - Tools for building and interfacing with the Seismic enclave

openligadb (0 stars) - Rust library for OpenLigaDB API

measureme-mirror (341 stars) - Support crate for rustc's self-profiling feature

btree-ondisk (0 stars) - A Rust implementation of BTree structure on persistent storage in userspace.

frits (0 stars) - A full-text search engine.

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.