4 months later: update on my journey toward the Rust compiler team

Hi everyone,

some of you might remember my post from a few months ago where I wrote about contributing full-time to the Rust compiler, being close to team membership, but struggling to make it financially sustainable while living in Russia

A lot has happened since then, so here is a short update and a link to a longer blog post with details, numbers and answers to common questions

TLDR

I kept contributing consistently (171 contributions so far)
I could not relocate or take full-time offers
I officially became a member of the Rust compiler team
I returned to my previous job teaching IT to kids - it gives me enough financial stability and time to keep working on the compiler

Full blog post: https://kivooeo.github.io/blog/first/

If you are interested, feel free to ask questions in the comments

I want to collect questions that come up here and add them to the blog over time (feel free to ask in DM as well), especially if they might help others who want to contribute to the open source or find themselves in similar life situations

Thanks again to everyone who supported me back then. Your comments helped more than you probably imagine

Happy holidays and happy New Year to all of you! <3

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

The Algebra of Loans in Rust
https://nadrieril.github.io/blog/2025/12/21/the-algebra-of-loans-in-rust.html

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

Looking for feedback - TUI text editor toy project

I wrote a TUI text editor with regex-based syntax highlighting, basic theming, and some Vim motions. It is very incomplete and not intended to be actually used; it was more a learning experience for getting to know Ratatui and a more OOP approach with mutable state.

I'd like to know what was done right and what is absolutely unidiomatic in the code.

https://github.com/AfkaraLP/sexditor

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

I built an immutable, content-addressed Python environment manager in Rust

px (Python eXact) is an experimental CLI for managing Python dependencies using immutable, content-addressed environment profiles (no venv).

👉 https://github.com/ck-zhang/px

It is now in alpha, feedback is welcome :)



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

I built a simple terminal Snake game in Rust

https://i.redd.it/v6f63de4ll9g1.gif

I wanted to build a simple project while reading the book, so i decided to go for the classic choice
Link to the github repo

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

GitHub - lazywalker/rgrc: rgrc - Rusty Generic Colouriser - just like grc but fast
https://github.com/lazywalker/rgrc

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

Simplifying the build process for vst3-rs
https://micahrj.github.io/posts/vst3/

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

Pow(x, n) leetcode passes rust playground but time line exceeded in leetcode console

Hey guy I have a leetcode here that fails in the leetcode console but passes in rust playground. I have provided two links below.

I'm doing a recursive / exhaustive algorithm ... honestly as I write this I do not know my time complexity ... will probably think about that after I press save here.

Could anyone lend a hand?


rust play ground

leet code

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

My Rust Rewriting Journey

I replaced my C++ only Coding Journey with Rust

Like for example i have so far 2 Programs in C++ that i have both finished (well the second is still getting maintained so technically not finished yet lol)

but man does Rust feel so much better!

For my Non Game Dev Projects ive basically decided to switch from C++ to Rust and since its made such a Huge Jump in recent Years im very Proud to be Part of the Rust Community now!

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

What is the current recommended way to install Emacs with Rust?

I searched for Rust and Emacs, and I found something that recommended installing rustic. When I tried installing rustic, Emacs told me that "rustic is unavailable". Now I find a post somewhere that tells me that rustic is obsolete and no longer maintained.

So, how do I get Emacs to work with Rust these days (and presumably with Rust Analyzer). I'm looking for something hands-on, like some lines to paste into my ~/.emacs, please.

No doubt, I'm not the first person to ask this, but I cannot find anything recent and actionable.

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

pdfium-bind: easiest way to add PDF rendering in your Rust app

I got frustrated trying to figure out a way to ship Kiorg with PDFium embedded so its PDF preview feature can just work out of the box in all environments.

That experience resulted in **pdfium-bind**. A high-level pdfium binding that embeds a pre-built PDFium library into your application directly when static library is not available.

I hope some of you would find this useful as well.

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

Small wordle project I made!

So I just started learning rust, and am just about to get to tests, but to consolidate everything that I have learnt so far, I decided to write a wordle clone! It includes colored text for each letter, accurate letter position guides (Green if correct, yellow if its in the word, with correct number of letters although there may be an issue with guessing something with letter pattern xxllx when the word has the pattern xxxlx (replace x with anything) as it checks in order, and would wrap the u8 I use round. There are of course solutions, but I can't think of one), both lowercse an upper case support, validation of it being in the alphabet and 5 letters long!
```rust
use std::{collections::HashMap, io};
use colored::*;

struct Guess {
word: String,
guess_info: ([char;5],HashMap<char,u8>)
}

impl Guess{
fn new() -> Guess{
let mut input = loop{
let mut input= String::new();
io::stdin().read_line(&mut input).expect("FAILED TO READ LINE!");
input = String::from(input.trim());
println!("{}",input);
if ! input.chars().all(char::is_alphabetic){
println!("Please only use letters in the english alphabet!");
continue;
}
if input.len() != 5{
println!("Please only use words of length 5!");
continue;
}
break input;
};
input = input.to_uppercase();
let guess_info = get_word_info(&input);
Guess { word: input, guess_info}
}

fn compare(&self, word:&str) -> [i32; 5]{
let word_info = get_word_info(&word);
let mut result = [0,0,0,0,0];
let mut word_char_count = word_info.1.clone();
if word_info.0 == self.guess_info.0{
result = [2,2,2,2,2];
}
else {
for i in 0..5{
let remaining_ref = word_char_count.get(&self.guess_info.0[i]);
let mut remaining: u8;
match remaining_ref{
Some(_t) => {
remaining = *remaining_ref.unwrap() as u8;
if remaining > 0{
if word_info.0[i] == self.guess_info.0[i]{
result[i] = 2;
} else{ result[i] = 1;}

remaining -= 1;
word_char_count.insert(self.guess_info.0[i], remaining);
} else{ result[i] = 0; }
},
None => {
result[i] = 0;
}
}
}
}

result

}

fn display(&self, result: [i32; 5]){
let mut display = ["".red(),"".red(),"".red(),"".red(),"".red()];
for i in 0..5{
let letter: &str = &self.word[i..i+1];
match result[i]{
2 => {display[i] = letter.green()},
1 => {display[i] = letter.yellow()},
_ => {display[i] = letter.red()}
}
}
println!("{}{}{}{}{}", display[0], display[1], display[2], display[3], display[4])
}
}
fn main() {
// init
const WORDS: [&str; 7] = ["HELLO","WORKS","TESTS","ADIEU","AUDIO","CRANE","PLANE"];
let word = WORDS[rand::random_range(0..WORDS.len())];

println!("----------WORDLE-----------");
println!("-----Terminal Edition------");

let mut win = false;
for _ in 0..6{
let guess = Guess::new();
let result = guess.compare(word);
guess.display(result);
if result == [2,2,2,2,2,]{
win = true;
break;
}
}

println!("---------GAME OVER---------");
if win{
println!("{}","You Win!".bright_cyan());
} else{
println!("{}","You Lose :(".red());
println!("The Word Was: {}",word.yellow())
}

println!("----------------------------")



}

fn get_word_info(word:&str) -> ([char;5], HashMap<char,u8>){
let mut chars = [' ',' ',' ',' ',' '];
let mut i = 0;
let mut chars_count: HashMap<char, u8> = HashMap::new();
for chara in word.chars(){
chars[i] = chara;
let char_count = chars_count.entry(chara).or_insert(0);
*char_count += 1;
i += 1;
}
(chars, chars_count)
}
```

This is the file and I am very happy with it for a first project with minimal docs usage (I used them to double check hashmaps, and I used SO for checking if its alphabetical). Any way I could improve (other than fixing that one issue, which for now I might just use i8, and just deal with the fact that players might think that there is an extra of a letter)

EDIT: switching to i8 does not change anything, IDK why I thought it would

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

[P] NOMA: a Rust-built compiler where backprop is generated at compile time (LLVM IR), exploring “systems-first” ML
https://github.com/pierridotite/Noma

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

Built my first Rust project offline Markdown renderer for security documentation

I'm a developer who's been wanting to try Rust for ages. Finally got some time off this winter and decided to dive in.

**My learning approach:**

* Rustlings (got halfway through)
* Youtube tutorials and Rust Docs
* Building an actual tool – [Markdown Scribe](https://github.com/DhanushNehru/markdown-scribe)

I've always been a self learner

**Why I built this:**

In cybersec, I'm constantly writing documentation – vulnerability reports, penetration test findings, security advisories. I wanted a fast, offline-first Markdown tool that I could trust wouldn't leak my drafts to some cloud service. Something that runs locally, renders fast, and doesn't need 47 dependencies or an internet connection.

**What I loved about Rust:**

The biggest thing? **How easy it is to express intent in code.** Coming from Javanoscript and Python in the security world, Rust's type system and error handling forced me to think about edge cases I'd normally gloss over.

The strict error modeling taught me concepts I thought I already knew. For example, the distinction between `OsStr` and `str` – something that matters when you're dealing with file paths in security tools where encoding issues can be attack vectors.

**Zero-cost abstractions** are incredible. I built complex features without worrying about performance penalties. The compiler has your back.

**Developer tooling** is top-tier. Cargo makes dependency management painless, which is refreshing when you're used to dealing with security-critical libraries where supply chain attacks are a real concern.

Project is MIT licensed and open for contributions: [Markdown Scribe](https://github.com/DhanushNehru/markdown-scribe)
🌟 Star the repo - your support means a lot!

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

Why is calling my asm function from Rust slower than calling it from C?
https://ohadravid.github.io/posts/2025-12-rav1d-faster-asm/

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

Is Rust the future?

This is like 5th or 6th language I am learning, and I have to say I absolutely love it. It feels like the most complete, very well designed programming language. I love Rust, it is an absolute joy to write code.

However, coding is my side quest, my specialty is within cyber security mostly, and I don't really know much about current state and future. Would you say that Rust has a good future? Worth to learn fully?

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

influxdb-stream: A streaming client for InfluxDB 2.x - feedback welcome!

Hey r/rust!


I built a small crate called influxdb-stream. This is my first time publishing to crates.io, so any feedback would be appreciated.


Problem: Existing InfluxDB clients load entire query results into memory. When dealing with millions of rows (e.g., data migrations), this causes OOM issues.

Solution: This crate streams records one at a time with O(1) memory usage.


---

\- GitHub: https://github.com/almightychang/influxdb-stream
\- crates.io: https://crates.io/crates/influxdb-stream

---

Would love to hear any suggestions on API design, error handling, or anything else I could improve. Thanks!

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

Why won't this match statement compile?

The match statement has every possible combination of the bool match guard for 0 but still expects a 0 in one of the match arms.

See this example here

updated with correct rust playground

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

upcoming Gust - a Rust based package manager that's up to 265x faster than swiftPM

https://preview.redd.it/qx3lkstgxs9g1.png?width=1800&format=png&auto=webp&s=90014391688272621d06e1ceef73c89d8fa636f5

Gust is a rapid, lightweight, open-source, Swift package manager, written in Rust.



It is upto 265x faster than SwiftPM and 10-12x faster than flutter's pub.



Gust uses a linking algorithm that ensures there is never more than 1 instance of the same version of a library on your machine, just like pnpm saving gigabytes of space in the long run.



Why would you be interested in Gust?



1. Massive Disk Space Savings
2. Rapid Package Installations
3. Lower CPU, RAM Usage
4. Significantly Lower Bandwidth Usage
5. Large Cost Savings



When will Gust be released?

I've been working hard to add new features and make Gust robust. Right now, Gust is in a very early stage so it is not ready for use, however, the key mechanisms that make it faster and more efficient have already been put in place and I have used it to rapidly make iOS, and watchOs apps with Claude Code and released them on the app store

The best part? Gust is open source https://github.com/quantbagel/gust! If you would like to support Gust development or find the project interesting, a ⭐ would be hugely appreciated!

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

What are some exciting features that will be stabilized in future rust versions?



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