DuckDB hiring a Rust engineer
https://duckdblabs.com/jobs/rust_engineer

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

Learning Rust was the best decision in my life

34F who lives with epilepsy here.

Recently had multiple back to back seizures and had to leave my day job, my hopes of getting hired full-time are very slim.

Apart from my marketing job, my only other skill is this language, which I learned as a hobby back in Uni.

Given the limited options in the same career, I've decided to build some indie apps in rust, try and market them with what I know.

Life's pretty bad but things tend to ease out a bit when we commit to something meaningful for ourselves, given how much time it'd take to learn a new skill in scratch, I feel very grateful as I learned to code in Rust before.

I don't have high hopes, just that there might be some light in the tunnel, and I'm trying to look in the bright side. So thought I'd share it here.

Thanks for reading.

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

You can use Rust to make PCBs now!

I created a bindings library that provides a Rust API to interface with KiCAD using the new KiCAD IPC API

KiCAD is like the VSCode of circuit board design. It's pretty sick! And now, using the IPC API (and the bindings I've made) you can write noscripts, plugins, and extensions, to do things in KiCAD using Rust!

It's super duper new - just released 12 hours ago - but the primary API surface seems to work well!

MIT Licensed and open-source! contributions welcome of course :)

github.com/milind220/kicad-ipc-rs



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

[Media] TrailBase 0.24: Fast, open, single-executable Firebase alternative now with Geospatial
https://redd.it/1ra8lxx
@r_rust

“Claw: It even comes with an established emoji 🦞” anyone else triggered?

https://simonwillison.net/2026/Feb/21/claws/

So the whole openclaw hype where basically some guy just went ahead to throw out all good engineering and security principles to vibe code a piece of unmanageable software that already caused lots of issues for a lot of people gets massively rewarded.

And now THAT is trying to claim our beloved Ferris?

Got to say that’s too much for me. Universe give me a break please.


Update: as pointed out in the comments, Lobster != crab so it’s not as bad as I thought. Still close enough…

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

Survey of organizational ownership and registry namespace designs for Cargo and Crates.io - cargo
https://internals.rust-lang.org/t/survey-of-organizational-ownership-and-registry-namespace-designs-for-cargo-and-crates-io/24027/1

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

Parse, don't Validate and Type-Driven Design in Rust
https://www.harudagondi.space/blog/parse-dont-validate-and-type-driven-design-in-rust

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

Proxelar v0.2.0 — a MITM proxy in Rust with TUI, web GUI, and terminal modes

I just shipped v0.2.0 of Proxelar, my HTTP/HTTPS intercepting proxy.

This release is basically a full rewrite — ditched the old Tauri desktop app and replaced it with a CLI that has three interface modes: an interactive TUI (ratatui), a web GUI (axum + WebSocket), and plain terminal output.

Under the hood it moved to hyper 1.x, rustls 0.23, and got split into a clean 3-crate workspace. It does CONNECT tunneling, HTTPS MITM with auto-generated certs, and has a reverse proxy mode too.

cargo install proxelar
proxelar # TUI
proxelar -i gui # web GUI

Would love feedback and contributions!

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

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