New week, new Rust! What are you folks up to?
I am reimplementing a egui color picker to be fully generic over color space (3-component, of course, as is provided by color crate).
Progress: texture for any base color (i.e. sample to read fixed lightness from) and color space, the core rectangle for color selection.
1 Like
I’m building a decentralized P2P swarm stack in Rust for autonomous agents (drones, rovers, etc.) to talk to each other without a central server and without flooding the network.
Key idea: Wireless comms are naturally volumetric — broadcasts radiate spherically, not like laser beams. TCP/UDP pretends otherwise by faking unicast with multiple redundant packets per neighbor. This stack does it physics-first: one real broadcast, a target list, and everyone nearby hears it. If they’re on the list, they handle it. If not, they ignore it. One emit = many receivers, no fake unicast.
There’s no routing table. Instead, each drone runs its own tiny brain that starts empty — as messages flow, it learns who’s nearby, who’s useful, and what’s out there. So the network self-organizes its own topology on the fly, growing smarter with every message.
On top of that, there’s an Election Kernel — not an API, but an internal swarm process. Drones form groups dynamically, elect an M1 leader (and a vice-M1 fallback) to handle local group-level coordination. The M1 has no extra powers — it’s just a temporary role to steer local tasks and keep things tidy, with instant failover if needed.
The whole thing is meant to work like a walkie-talkie for drones. Humans don’t care how walkie-talkies coordinate channels — same here: the swarm comms just handle themselves under the hood.
I’m ~80% through, pure Rust for now, with a no_std version next. The goal is to be the “TCP/UDP for autonomous swarms” — or like WebRTC for machines. It’s more a dev tool than a product. Whole thing will be open-sourced when v1 is ready.
I'm working on a mock server based on a file system structure to build the endpoints: GitHub - lvendrame/rs-mock-server: Simple Rust mock server
It is quite simple but solves a lot of issues, at least for me. If you want to test: cargo install rs-mock-server
1 Like
I am currently implementing API bindings to interact with a Mender server.
Doing so, I found that RPITs are quite useful to disambiguate methods across traits:
impl Session {
<SNIP>
/// Return an opaque type to proxy deployment-related operations.
#[must_use]
pub fn deployments(&self) -> impl Deployments {
self
}
/// Return an opaque type to proxy devices-related operations.
#[must_use]
pub fn devices(&self) -> impl Devices {
self
}
/// Return an opaque type to proxy groups-related operations.
#[must_use]
pub fn groups(&self) -> impl Groups {
self
}
/// Return an opaque type to proxy releases-related operations.
#[must_use]
pub fn releases(&self) -> impl Releases {
self
}
}
All traits have a function to list() the respective DTOs, so by now I can use
let devices = session.devices().list();
let groups = session.groups().list();
Instead of
let devices = Devices::list(&session);
let groups = Groups::list(&session);
Which I personally find nicer to read (Yes, that’s an opinion 
)
2 Likes
I have just published two crates, MOMA and MOMA_simulation_engine.
MOMA is a Rust framework for exploring number theory, cryptography, and bioinformatics through the lens of Moving Origin Modular Arithmetic.
The crate is designed for researchers and developers who are interested in a novel, relational framework for analyzing complex sequences.
The Core Idea: A Barycenter for Numbers
The inspiration for this crate comes from the concept of a barycenter in astrophysics. Just as the Earth and Moon orbit a common center of mass that is not the exact center of the Earth, MOMA treats modular arithmetic as a system where the "zero point" or "origin" is not fixed.
This origin shifts dynamically based on a contextual value—typically a prime number p—and the chosen OriginStrategy. This provides a novel relational framework for analyzing complex systems.
The MOMA_Simulation_Engine is a library for creating and running dynamic systems, such as cellular automata, using the MOMA framework as the core update rule.
This crate provides the tools to build simulations where the evolution of the system is governed by the complex, non-linear, and deterministic patterns generated by MOMA.
there are some examples in each crate, I would be interested to see what people think.
1 Like
A few little things:
- A terminal ui for locally tracking job postings
- Trying out dylint to lint against some code patterns which have caused bugs in an existing project
- Playing around with an idea for building a crates.io alternative which would combines many features of docs.rs, github, and other sites into one.
For me, it's the end of the work week, which means I'll be spending some time on my side project RustEditorKit to solve some issues with highlighting and positioning mouse cursors.
1 Like
I've published a cargo plugin to add dependencies to Cargo.toml and ros2 related package.xml files simultanously. Today I've added some tests and updated the readme. The tool is called ros_add
Rust Job Board.
(built with the web framework rocket.rs)
Implemented a minesweeper clone - inspired by señor @conqp / @Schard.
It is a terminal app that follows the "classic" Windows 3.1/95 rules. I used crossterm so that the user can "cursor over" the grid when they flag/uncover cells - rather than having to type the xy-coordinates each time...That is the main advantage crossterm brings in this case, you can do almost the same UI by just printing to stdout with an ANSI code to reposition the cursor when refeshing the display...
There is a surprising number of academic publications about minesweeper. Turns out the game is NP hard (solving it).
1 Like
Nice! Are you able to add job posts sent to you or are you only scraping for roles? I'm struggling to find good Rust job boards for posting roles to. 
Note that we're currently in week 42 of 2025, not 32 
3 Likes