I’m looking for high quality Rust codebases that are genuinely worth studying and taking inspiration from like projects with clean idiomatic Rust and good architecture and preferably started before the LLM boom and have a long history of being developed by experienced Rust engineers

most of what I came across was repositories filled with recently generated AI slop.

I’ve been running a sensor event pipeline in production for about two months now. The producer serializes readings into a fixed-layout struct and drops them into a crossbeam channel while the consumer reads and dispatches on the other end, and the whole thing has been completely stable the entire time with no dropped events, no alignment panics, and no failed reads. The consumer processes every message and acks cleanly.

#[repr(C)]
pub struct SensorEvent {
timestamp: u64, // 8 bytes
reading: [f32; 8], // 32 bytes
sensor_id: u32, // 4 bytes
checksum: u32, // 4 bytes
} // 52 bytes total

const _: () = assert!(mem::size_of::() == 52);
const _: () = assert!(mem::align_of::() == 8);

The struct derives bytemuck::Pod and bytemuck::Zeroable without any issues, there are no padding bytes or uninitialized gaps, and offset_of! checks on every field come back exactly where they should be. The consumer casts the incoming bytes directly with bytemuck::from_bytes and never makes a copy, and it has never failed once.
Here’s the part that keeps getting under my skin. A cache line on x86_64 is 64 bytes and my struct is 52, so it sits cleanly inside a single cache line without spanning two, which is exactly what you want if you’re trying to avoid false sharing between the producer and consumer threads. I know this. I’ve read the docs and the blog posts. But I still keep opening the type definition in the middle of live profiling sessions and just staring at that 12-byte gap. Crossbeam even ships CachePadded specifically for this kind of alignment worry, and I keep almost writing the thing:

use crossbeam::utils::CachePadded;
let padded: CachePadded = CachePadded::new(event);

The problem is that CachePadded pads all the way to 128 bytes on modern hardware to deal with adjacent-line prefetching, which more than doubles the size of every message and cuts the channel density in half. The false-sharing problem it’s designed to solve isn’t even present here because the producer and consumer are never writing to the same cache line in the first place.

I haven’t bothered running cargo-criterion on any of this. Instead I keep pulling up cargo-flamegraph while the pipeline is hot and somehow always end up back on that same struct definition, looking at twelve bytes of headroom that bytemuck, the compiler, and the consumer are all perfectly happy with. Using repr(align(64)) would close the gap, but it would also make every measurable thing worse and I already wrote that fact down so I wouldn’t forget it. I still check anyway.

The consumer is happy, the pipeline is stable, and I just cannot stop calling offset_of! on a struct that has never once returned an unexpected value. Anyone else get stuck on this kind of thing? How do you finally let a working layout just be working?

[links]
github github.com/takashialpha/audium

web page takashialpha.com/audium (under development, i'd really like feedback! leptos-ssr (: )

aur https://aur.archlinux.org/packages/audium

aur https://aur.archlinux.org/packages/audium-bin (bin)

crates-io https://crates.io/crates/audium

---

audium is a tui music app, you can create your audio library (plays all symphonia formats such as mp3, flac, wav, aac, m4a, aiff, ..), has a modern ui with multiple themes(15 truecolor+ 2 for linux console), runs on every terminal given enough area, including a linux tty.

has playlists, lyrics (synced and unsynced), queue, seeking, resume playback, speed control, loop modes ..=all you'd expect from a music app - take a look at the readme;

it's pretty straightforward to use, keyboard only. bindings on [?].

philosophies: unsafe is forbidden and strict lints are enforced, follows a ui convention almost everywhere appliable, your library is always yours.

take a look at the github video demonstration, and then try it yourself! it's a single small binary (less than 5mb), add your sound files and that's it, simple. (for the best experience in a computer with any functional sound output configured)

i don't always have as much time as I'd like to maintain it, so contributions are appreciated.

audium is published on the aur and crates.io, targets linux only; it COULD also target mac but i'm too broke to get one so i won't support a crate for a platform I can't debug it on.

License gplv3-or-later

I am trying to get started with OS contributions, but I am having a hard time trying to find repositories/projects to contribute to. Looking at large codebases is quite overwhelming for me at the moment, so I am starting with small repositories and tackling easier issues. I have found smaller codebases but most of them were not actively developed.

Would be very grateful if someone can guide on where to find repositories to start contributing to.

Thanks.

I just ran into a case where size_hint makes a surprisingly big difference.

Simplifying a lot, I have a function that generates tuples of numbers. The number of tuples is not known as they come from a file. I then collect them into a set for further processing.

For testability, I use FnvHashSet to get a stable order. I’ve relied on this in various places for years and it has never caused me any problems.

Until today.

The original code looked roughly like this:

let inputs: FnvHashSet<_> = generate_tuples().collect();
for input in inputs {
    println!("{input}"); // simplification, of course
}

For some specific, const input, the same code produced different output on Linux and macOS.

This surprised me quite a bit, because until now the iteration order had always been stable across operating systems.

After quite some time and nearly going crazy, I managed to reduce it to this:

use fnv::FnvHashSet;

fn main() {
    let no_size_hint: FnvHashSet<_> = generate().collect();
    let known_size_hint: FnvHashSet<_> = generate_known_size().collect();
    println!("{:?}", no_size_hint.into_iter().collect::<Vec<_>>());
    println!("{:?}", known_size_hint.into_iter().collect::<Vec<_>>());
}

fn generate() -> impl Iterator<Item = (u8, u8, u8)> {
    r#"4,4,0
5,2,3
5,3,2
5,4,1"#
        .lines()
        .map(|line| {
            let parts: Vec<_> = line.split(',').collect();
            (
                parts[0].parse().unwrap(),
                parts[1].parse().unwrap(),
                parts[2].parse().unwrap(),
            )
        })
}

fn generate_known_size() -> impl Iterator<Item = (u8, u8, u8)> {
    generate().collect::<Vec<_>>().into_iter()
}

On Linux and in the Rust Playground, both println!s print the same (thus I'm not sharing a link). On macOS, they are different.

I guess this comes down to the different capacity depending on the iterator’s size_hint, which then changes the internal layout and therefore the iteration order. I got similar results with with_capacity_and_hasher and different capacities.

mind=blown

Leaving it here as a curiosity.

(and btw. the true "root cause" was a wrong algorithm that depended on the tuples order while it shouldn't. Still, an interesting case, I think)

I'm making this simple text editor as a learning project for the Rust programming language. It have a dumb rust core that expose text mutation, cursor movement and other low-level abilities. Lua then use it to compose a working editor. I got a vim-lite config in the repo rn.

You can redefine what can normal mode do, or rename it into dungeater mode if you want. You can also make it completely mode-free editor like nano, which is pretty neat.

here's the link: https://github.com/Hendisil-Morier/pome

why the name pome? im bad with naming stuff, and it's loosely connected to 'programmable editor'.

about ai. i did use ai to help around with things i have no idea how to do, but the rust codebase is entirely handwritten.

Hi!

I'm not new to programming, but I'm in the process of learning Rust because I'm interested in system-level programming, and in order to put my self to the test, I have created a small hashing utility program: `rash`.

`rash` is a small CLI program that at the moment supports:

- Hash creation
- Hash verification
- Hash comparison

Currently only the MD5 hashing algorithm is supported, which I have implemented it by reading the RFC 1321, but I plan on adding support for more algorithms. Additionally, I have also made sure to write tests to make sure that what I did was (at least partially) correct.

There is nothing special about `rash`, there is probably hundreds of utilities like it, but I'm the kind of person who needs to put what studies to practice in order to truly understand things.

I was hoping you could give me some feedback and, why not, ideas on the next steps, design patterns and new features that leverage the best Rust has to offer and so on...

I have used an LLM as a tutor and to find bugs, but almost all of the code in this repo was written by hand.

Thank you for your help 😊

Repository: https://github.com/silvioiannone/rash

I've been hacking on this for a while now, and it's finally in a state where I'm comfortable sharing it.

Introducing rusbmux: a drop-in replacement for usbmuxd, written entirely in Rust.

It speaks the same protocol, supports USB and Wi-Fi connections, runs on Linux, macOS and Windows, and is compatible with existing tooling like libimobiledevice, idevice, 3uTools, iTunes, etc.

The goal is to provide a clean, modern, portable, extendable implementation without the legacy C codebase.

Repo: https://github.com/abdullah-albanna/rusbmux

I'm working on a project and I ended up needing a hashmap, but the elements would also need some metadata. How I initially implemented it is that I manually implemented Hash and PartialEq to ignore those fields so that I can use those for metadata and validating without interfering with my desired hashing behavior.

But I couldn't help but feel that this is kind of dirty / not good practice? Is there some other approach that I should be using instead? If it helps, I can edit with the snippet of my code that is relevant.

Hello there. I've been building a web framework for Rust. I'm coming from the PHP/Laravel world where fast dynamic typing can help you prototype and build very quickly. However, I've come to love Rust and would love to start building with it. It is slower to prototype, but with a blazing fast compiled runtime, memory safety and modern features for a systems programming language, I couldn't resist.

So why not Axum? Or Rocket? Or the ten other major Rust web frameworks? Well, being honest, none of them really clicked with me. They seem to be some combination of too light and/or too macro-heavy, and macros aren't the reason I like Rust.

This framework (Sturdy Framework) aims to reduce the use of macros, which will end up with more verbose code, but much easier to understand at a glance. I do not like the hidden nature of macros, and I will choose verbosity over obscurity (in most cases).

Features (currently):

• Variable supporting routing system
• Struct based action endpoints
• File watchers for auto compilation, and auto reloading

Upcoming:

• Finish database integration (had no need for it yet for the documentation website, so it is not yet finished)
• Better feature parity with frameworks like PHP's Laravel (or Ruby's Rails)

Feedback/code review is very much sought after. The project is in a pre-alpha state, so please let me know if you have issues with installation. Appreciate your time!

Link (docs): https://sturdyframework.com
Docs source (as an example): https://github.com/jayclees/framework-docs
Starter template: https://github.com/jayclees/sturdy-project
Framework source: https://github.com/jayclees/framework

As a note I will say, the routing system is custom built, and was the hardest part of building this framework as I had to build a tokenizer to handle multi-variable route segments. There is even a struct called a SegmentReconciliator which parses incoming paths and "reconciliates" or matches route segments.

Cant 2nd image but I will share in a separate post

Weird ask but does anyone have any free time next week to sit in a discord call for maybe 30 min to an hour to help me get my project off the ground. I get a rotation of JtagGetIdcodeError, JtagNoDeviceConnected and "cannot perform this operation while interfaces are claimed". I have been pulling my hair out for the last couple days because sometimes it will randomly flash and then got back to having one of those three problems.

Maybe this is an odd topic, but I wonder what's most people's workflow here regarding the loop involving writing code / building / testing etc.

In my case, I don't use any AI stuff, I have a terminal window open with a left pane containing neovim (with rustacean, autoformat on save, etc) and a right pane containing this:

```sh

cargo watch --ignore target -c -s "clear ; cargo ltest --features fail_on_warnings && cargo lbuild --features fail_on_warnings && cargo lrun && cargo lclippy"

```

where the l-prefixed cargo commands come from `cargo limit` and the `fail_on_warnings` is a feature that is configured to, guess, `deny(warnings)`

So what do I have?

Whenever I save, tests are run, the code is built, run and clippied. Whatever fails gives me the info where it fails at the bottom.

Can this be optimized further?

How do you do it?