I built a speed-first file deduplication engine using tiered BLAKE3 hashing and CoW reflinks

I recently decided to dive into systems programming, and I just published my very first Rust project to crates.io today. It's a local CLI tool called bdstorage (deduplication engine strictly focused on minimizing disk I/O.)

Before getting into the weeds of how it works, here are the links if you want to jump straight to the code:

GitHub:[https://github.com/Rakshat28/bdstorage](https://github.com/Rakshat28/bdstorage)
Crates.io:https://crates.io/crates/bdstorage

Why I built it & how it works: I wanted a deduplication tool that doesn't blindly read and hash every single byte on the disk, thrashing the drive in the process. To avoid this, bdstorage uses a 3-step pipeline to filter out files as early as possible:

1. Size grouping (Zero I/O): Filters out unique file sizes immediately using parallel directory traversal (jwalk).
2. Sparse hashing (Minimal I/O): Samples a 12KB chunk (start, middle, and end) to quickly eliminate files that share a size but have different contents. On Linux, it leverages fiemap ioctls to intelligently adjust offsets for sparse files.
3. Full hashing: Only files that survive the sparse check get a full BLAKE3 hash using a high-performance 128KB buffer.

Handling the duplicates: Instead of just deleting the duplicate and linking directly to the remaining file, bdstorage moves the first instance (the master copy) into a local Content-Addressable Storage (CAS) vault in your home directory. It tracks file metadata and reference counts using an embedded redb database.

It then replaces the original files with Copy-on-Write (CoW) reflinks pointing to the vault. If your filesystem doesn't support reflinks, it gracefully falls back to standard hard links. There's also a --paranoid flag for byte-for-byte verification before linking to guarantee 100% collision safety and protect against bit rot.

Since this is my very first Rust project, I would absolutely love any feedback on the code, the architecture, or idiomatic practices. Feel free to critique the code, raise issues, or submit PRs if you want to contribute.

If you find the project interesting or useful, a star on the repo would mean the world to me, and feel free to follow me on GitHub if you want to see what I build next.

https://redd.it/1ratfky
@r_rust

Iron-Wolf: A Wolfenstein 3D Source Port in Rust

https://github.com/Ragnaroek/iron-wolf

There are some satellites projects around this also in Rust.
A VGA emulator: https://github.com/Ragnaroek/vga-emu
and a OPL emulator: https://github.com/Ragnaroek/opl-emu (for sound)
and also a player for the web: https://github.com/Ragnaroek/iron-wolf-webplayer (written with eframe, to try eframe out).

You can also play the web version here: https://wolf.ironmule.dev/

Had a lot of fun doing all of this!

https://redd.it/1raux1c
@r_rust

Fibre Cache
https://crates.io/crates/fibre_cache

https://redd.it/1ravffp
@r_rust

I built a fixed-size linear probing hash table to bypass university website blocking

Repo: [https://github.com/dilluti0n/dpibreak](https://github.com/dilluti0n/dpibreak)

Your HTTPS traffic is encrypted, but the very first packet (TLS ClientHello) has to announce the destination domain in plaintext. DPI equipment reads it and drops the connection if it doesn't like where you're going. DPIBreak manipulates this packet in a standards-compliant way so that DPI can no longer read the domain, but the actual server still can.

On Linux:

curl -fsSL https://raw.githubusercontent.com/dilluti0n/dpibreak/master/install.sh | sh 

sudo dpibreak

That's it. Stopping (Ctrl+C) it reverts everything. On Windows, just double-click the exe.

Unlike VPNs, there's no external server involved. On Linux, DPIBreak uses nfqueue to move packets from kernel to userspace for manipulation. To keep overhead minimal, nftables rules ensure only the TLS handshake packets are sent to the queue, everything else (video streaming, downloads, etc.) stays in the kernel path and never triggers a context switch. On Windows, it uses WinDivert with an equivalent filter.

It also supports fake ClientHello injection (--fake-autottl) for more aggressive DPI setups. The idea is to send a decoy packet with a TTL just high enough to pass the DPI equipment but expire before reaching the real server. To ensure the fake packet does not reach to the destination site, DPIBreak infers the hop count from inbound SYN/ACK packets.

The tricky part: between a SYN/ACK arriving and the corresponding ClientHello being sent, SYN/ACKs from other servers can interleave. A simple global variable won't cut it. So I built HopTab, a fixed-size linear probing hash table with stale eviction (I know, it sounds weird, but it fits this usecase perfectly!) that caches (IP, hop) pairs for this specific use case.

I live in South Korea, and Korean ISP-level DPI was bypassable with just fragmentation. But my university's internal DPI was not. Turning on --fake-autottl solved it. So if basic mode doesn't work for you, give that a try.

Feedback, bug reports, or just saying hi: https://github.com/dilluti0n/dpibreak/issues

https://redd.it/1ray40v
@r_rust

strace-tui: a TUI for visualizing strace output
https://redd.it/1razq2z
@r_rust

Stabilize `if let` guards (Rust 1.95)
https://github.com/rust-lang/rust/pull/141295

https://redd.it/1rb5ij8
@r_rust

I'm in love with Rust.

Hi all, r/rust

a few months ago, I ditched Golang and picked Rust based on pure vibe and aesthetic. Coming from a C/C++ background, most of Rust concepts seemed understandable. I found myself slowing down when I stated building a production ready app ( fyi: Modulus , if you're curious it's a desktop app built with tauri ) but on the other hand, there are hardly any bug on production.

I won't call myself an expert on Rust but boy, I get the hype now.

https://redd.it/1rb4n0q
@r_rust

[media] Bet you haven’t seen an Iced app running on Windows XP yet
https://redd.it/1rbf6j4
@r_rust

toml-spanner: Fully compliant, 10x faster TOML parsing with 1/2 the build time

toml-spanner a fork of toml-span, adding
full TOML v1.1.0 compliance including date-time support, reducing build time to half
and improving parsing performance significantly.

See Benchmarks

#### What changed

- Parse directly from bytes into the final value tree, no lexing nor intermediate trees.
- Tables are order-preserving flat arrays with a shared key index for larger tables, replacing toml-span's per-table BTreeMap.
- Compact Value and Span: Items (Span + Value) are now 24 bytes, half of the originals 48 bytes (on 64-bit platforms).
- Arena allocate the tree.

There are a bunch of other smaller optimizations, but I've added stuff like:

table"alpha"0"bravo".asstr()

Null Coalescing Index Operators and other quality of life improvements see, [API Documentation](https://docs.rs/toml-spanner/latest/tomlspanner/) for more examples.

The original toml-span had no unsafe, whereas toml-spanner does need it for the compact data structures
and the arena. But it has comprehensive testing under MIRI, fuzzing with memory sanitizer
and debug asserts, plus really rigorous review. I'm confident it's sound. (Totally not baiting you into auditing the crate.)

The extensive fuzzing found three bugs in the toml crate, issues #1096, #1103 and #1106 in the toml-rs/toml
github repo if your curious, for which epage has done a fabulous job resolving each issue within like 1 business day. After fixing my own bugs, I'm now pretty confident that toml and toml-spanner are pretty aligned.

Also, the maximum supported TOML document size is now 512 MB.
If anyone ever hits that limit, I hope it gives them pause to reconsider their life choices.

Why fork and instead of upstream? The API's are different enough it might as well be a different crate and well
although API surface and code-gen wise toml-spanner simpler in some sense, the actual implementation details
and internal invariants are much more complex.

Well TOML parsing might not be the most exciting, I did go pretty deep on this over the last couple weeks,
balancing compilation time against performance and features, all well trying to shape the API to
my will. This required making lot of decisions and constantly weighing trade offs. Feel free to ask any
questions.

https://redd.it/1rbk4t2
@r_rust

This Week in Rust #640
https://this-week-in-rust.org/blog/2026/02/25/this-week-in-rust-640/

https://redd.it/1rftaij
@r_rust

Hey Rustaceans! Got a question? Ask here (8/2026)!

Mystified about strings? Borrow checker has you in a headlock? Seek help here! There are no stupid questions, only docs that haven't been written yet. Please note that if you include code examples to e.g. show a compiler error or surprising result, linking a playground with the code will improve your chances of getting help quickly.

If you have a StackOverflow account, consider asking it there instead! StackOverflow shows up much higher in search results, so ahaving your question there also helps future Rust users (be sure to give it the "Rust" tag for maximum visibility). Note that this site is very interested in question quality. I've been asked to read a RFC I authored once. If you want your code reviewed or review other's code, there's a codereview stackexchange, too. If you need to test your code, maybe the Rust playground is for you.

Here are some other venues where help may be found:

/r/learnrust is a subreddit to share your questions and epiphanies learning Rust programming.

The official Rust user forums: https://users.rust-lang.org/.

The official Rust Programming Language Discord: https://discord.gg/rust-lang

The unofficial Rust community Discord: https://bit.ly/rust-community

Also check out last week's thread with many good questions and answers. And if you believe your question to be either very complex or worthy of larger dissemination, feel free to create a text post.

Also if you want to be mentored by experienced Rustaceans, tell us the area of expertise that you seek. Finally, if you are looking for Rust jobs, the most recent thread is here.

https://redd.it/1rcdmg4
@r_rust

Searching 1GB JSON on a phone: 44s to 1.8s, a journey through every wrong approach
https://redd.it/1rgzhhl
@r_rust

Servo v0.0.5 released
https://github.com/servo/servo/releases/tag/v0.0.5

https://redd.it/1rh8w41
@r_rust

I built a 1 GiB/s file encryption CLI using iouring, ODIRECT, and a lock-free triple buffer

Hey r/rust,

I got frustrated with how slow standard encryption tools (like GPG or age) get when you throw a massive 50GB database backup or disk image at them. They are incredibly secure, but their core ciphers are largely single-threaded, usually topping out around 200-400 MiB/s.

I wanted to see if I could saturate a Gen4 NVMe drive while encrypting, so I built Concryptor.

GitHub: https://github.com/FrogSnot/Concryptor

I started out just mapping files into memory, but to hit multi-gigabyte/s throughput without locking up the CPU or thrashing the kernel page cache, the architecture evolved into something pretty crazy:

Lock-Free Triple-Buffering: Instead of using async MPSC channels (which introduced severe lock contention on small chunks), I built a 3-stage rotating state machine. While io\_uring writes batch N-2 to disk, Rayon encrypts batch N-1 across all 12 CPU cores, and io\_uring reads batch N.
Zero-Copy O_DIRECT: I wrote a custom 4096-byte aligned memory allocator using std::alloc. This pads the header and chunk slots so the Linux kernel can bypass the page cache entirely and DMA straight to the drive.
Security Architecture: It uses ring for assembly-optimized AES-256-GCM and ChaCha20-Poly1305. To prevent chunk-reordering attacks, it uses a TLS 1.3-style nonce derivation (base\_nonce XOR chunk\_index).
STREAM-style AAD: The full serialized file header (which contains the Argon2id parameters, salt, and base nonce) plus an is_final flag are bound into every single chunk's AAD. This mathematically prevents truncation and append attacks.

It reliably pushes 1+ GiB/s entirely CPU-bound, and scales beautifully with cores.

The README has a massive deep-dive into the binary file format, the memory alignment math, and the threat model. I'd love for the community to tear into the architecture or the code and tell me what I missed.

Let me know what you think!

https://redd.it/1rh9tj5
@r_rust

Life outside Tokio: Success stories with Compio or iouring runtimes

Are io\uring based async runtimes a lost cause?

This is a space to discuss about async solutions outside epoll based design, what you have been doing with compio? How much performing it is compared with tokio? Which is your use case?

https://redd.it/1rh7lfe
@r_rust

Is there any significant performance cost to using array.get(idx).ok_or(Error::Whoops) over array[idx]?

And is `array.get(idx).ok_or(Error::Whoops)` faster than checking against known bounds explicitly with an `if` statement?

I'm doing a lot of indexing that doesn't lend itself nicely to an iterator. I suppose I could do a performance test, but I figured someone probably already knows the answer.

Thanks in advance <3

https://redd.it/1rhb97r
@r_rust

Building a performant editor for Zaku with GPUI
https://redd.it/1rhdp64
@r_rust

Published my first crate - in response to a nasty production bug I'd caused
https://crates.io/crates/axum-socket-backpressure

https://redd.it/1rhc7ac
@r_rust

Another minimal quantity library in rust (mainly for practice, feedback welcome!)

Another quantity library in rust... I know there are many, and they are probably better than mine (i.e. uom). However, I wanted to practice some aspects of Rust including procedural macros. I learned a lot from this project!

Feedback is encouraged and very much welcome!

https://github.com/Audrique/quantity-rs/tree/main

Me rambling:

I only started properly working as a software engineer around half a year ago and have been dabbling in Rust over a year. As I use Python at my current job, my main question for you is if I am doing stuff a 'non-idiomatic' way. For example, I was searching on how I could write interface tests for every struct that implements the 'Quantity' trait in my library. In Python, you can write one set of interface tests and let implementation tests inherit it, thus running the interface tests for each implementation. I guess it is not needed in Rust since you can't override traits?

https://redd.it/1rhcaxs
@r_rust

I used Tauri and Rust to build a native Windows Git context menu that replaces heavy Electron GUI clients. (OpenSource)

Hey r/rust,

I wanted to share a desktop utility I recently built called GitPop. It’s a Windows File Explorer extension that brings a Git UI directly to your right-click context menu.

https://github.com/vinzify/gitpop

# Why Rust and Tauri?

A context menu popup needs to open instantly. I initially looked at Electron, but shipping a 100MB+ Chromium instance just to show a tiny Git status window felt unacceptable. Using Tauri v2 let me keep the binary size small and the startup time nearly instantaneous.

# A few fun implementation details

# OS integration (registry binding)

I used the winreg crate to dynamically find the app’s executable and bind it to the Directory\\Background\\shell registry keys during setup.

# Headless Git (no libgit2)

Instead of linking libgit2 (which can be a headache and often ignores the user’s global .gitconfig), the Rust backend spawns child processes to run native Git CLI binaries.

To prevent Windows CMD boxes from flashing on the screen, I had to use CommandExt plus the CREATE_NO_WINDOW flag.

# Local LLMs for commit messages

I implemented a feature that pipes git diff output to a local Ollama instance (via reqwest) to auto-generate commit messages entirely on-device, keeping source code private.

# UI quirks

Building a transparent, glassmorphism UI on Windows 11 WebView2 had a few quirky panics, but the Tauri v2 APIs handled it cleanly once configured.

The source code is fully open-source if anyone wants to see how the context-menu registry binding or hidden child processes were implemented!

https://redd.it/1rhjsat
@r_rust

How much did Rust help you in your work?

After years of obsessed learning for Rust along with its practices and semantics, it is really helping in my career, so much so that I would not shy away from admitting that Rust has been the prime factory in making me a hireable profile.

I basically have to thank Rust for making me able to write code that can go in production and not break even under unconventional circumstances.

I was wondering how much is Rust helping with careers and whatnot over here.

I wanna clarify, I did not simply "land a Rust job", I adopted Rust in my habits and it made me capable to subscribe to good contracts and deliver.

https://redd.it/1rhts1u
@r_rust