Crateful 02/25
Transactional actors, CRB 0.0.28 release, presentation of the new Nine framework, and a list of over 300 crates.
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 anAbortHandle
for emergency termination and anAtomicBool
for a softer interruption notification that could be processed at a convenient runtime moment.The agent's
Address
and anInterrupt
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 enum
s like rust native enums, freely passing through ffi
rustantic-macros (3 stars) - Rust to Pydantic generator
ffi-enum (1 stars) - Simply write and use enum
s 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.