Rust Blog

I love this kind of stuff! It's important for source code to be able to handle non-ASCII characters but we need to be mindful of the different ways that an editor will "lie" to you about your code. The most recent example of this in Rust [1].

> As part of their research, Nicholas Boucher and Ross Anderson also uncovered a similar security issue identified as CVE-2021-42694 involving homoglyphs inside identifiers. Rust already includes mitigations for that attack since Rust 1.53.0. Rust 1.0.0 through Rust 1.52.1 is not affected due to the lack of support for non-ASCII identifiers in those releases.

The easy reaction is "Why are we allowing non-ASCII characters at all? Just so we can put emojis in our variable names?"

This project is a good example of why we do it. But as with everything, we need to be careful about it.

[1] https://blog.rust-lang.org/2021/11/01/cve-2021-42574.html

> more social media outrage and religious wars than any other technical project I have been following for the past 20 years.

It is unfortunately wrapped up in larger-scale outrage culture than just within tech/programming circles. Rust as a community is very gay and very trans:

https://blog.rust-lang.org/2024/02/19/2023-Rust-Annual-Survey-2023-results.html#community

https://blog.rust-lang.org/2025/02/13/2024-State-Of-Rust-Survey-results.html#community

To be clear I am 111% down for that as one of the Alphabet People myself lol. We just can't pretend like it isn't a factor.

Disclaimer: I realize these numbers are probably skewed high due to self-selection of people who are willing to take diversity surveys. The actual percentages are probably somewhat lower, but Rust undoubtedly has the highest concentration of any programming-language community. Zero question.

In Rust (I don't know about Go), there's a sharp line between "panic" and other error handling: the unwinding on a "panic" is optional. A program or library might be compiled with "panic=unwind", or it might be compiled with "panic=abort" where a panic kills the whole process instead of trying to unwind. This means "panic" can't be used for normal error handling, only for "can't happen" errors like an out-of-bounds index into a slice.

In your categorization, Rust with "panic=abort" would be at step 2, not 5 (and it's used in production that way, for instance AFAIK Firefox uses "panic=abort"). And interestingly, not unwinding on panic in Rust is newer than unwinding on panic: it was added only on Rust 1.10 (https://blog.rust-lang.org/2016/07/07/Rust-1.10.html). So Rust seems to be following your list of steps somewhat backwards.

> Does cve-rs break any type system rules?

Yes.

> If so, why hasn't it been fixed yet?

Pretty classic software engineering reasons.

The part of the system that it involves was in the process of being re-written already. The re-write fixes the bug. Because it is essentially a theoretical issue, and not an actual problem in any real code, it is not a five alarm fire. Waiting for that re-write to land makes the most sense, instead of putting in a ton of work that will be thrown away.

Other, more serious miscompilations get fixed faster. In fact, a version of the Rust compiler was released today to fix one, even https://blog.rust-lang.org/2026/07/16/Rust-1.97.1/

This one was impacting actual users, and did not require re-writing entire subsystems to fix properly. So the engineering and product tradeoffs are different.

Borrowing from https://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html (linked to from the original post), the following code tries to access a lock-protected vector.

fn use_lock(mutex: &Mutex<Vec<i32>>) {
let vec = {
// acquire the lock
let mut guard = lock(mutex);

// attempt to return a borrow of the data
access(&mut guard)

// guard is destroyed here, releasing the lock
};

// attempt to access the data outside of the lock.
vec.push(3);
}

It doesn't compile because the lock is not held long enough.

error: `guard` does not live long enough
access(&mut guard)
^~~~~

There are several more examples in that article, but you can read them there rather than here!

I love this. We are a rust shop and we use clickhouse a fair bit. We’ve been quite impressed with its speed and flexibility. I’m glad to see this kind of direct, real-world feedback around both the benefits and difficulties of mixing rust and C++, which we have also had to do a bit of (albeit in the opposite direction: a smattering of C++ in a sea of rust).

I’m not sure if the poster here is the post author, but it would be great if the author would consider filling out this survey that was recently released asking for feedback on the future of rust’s vision: https://blog.rust-lang.org/2025/04/04/vision-doc-survey.html

I’d love to see rust become the de facto standard for cross-language portable code by virtue of its ease of use, but as this and our experience highlights, there’s some way to go yet!