News for hackers. Stuff that matters.
Re:11 year old unsoundness bugs found in Rust borrow checker by vrighter on Tuesday October 13, 2026 @07:58AM (#50070268)
so what I take from this is that the rust compiler does not guarantee the stuff it claims to. Because new features of the type system is just being yolod instead of formally proven
Re:11 year old unsoundness bugs found in Rust borrow checker by roblabla on Tuesday October 13, 2026 @08:14AM (#50070456)
There never was formal verification of the entire rust compiler, or even its complete borrow checker/type system. There has been verifications on _subsets_ of them.

Also, a lot of those soundness issues aren't related to new features _at all_, but usually due to poor assumptions made in optimizations.

The soundness bugs _are_ taken seriously though, and are slowly being patched out. A lot of the links in OP are now closed because Rust either changed how it generates code to avoid the issues, or fixed LLVM.

Re:11 year old unsoundness bugs found in Rust borrow checker by meltyness on Tuesday October 13, 2026 @08:49AM (#50070859)
https://github.com/model-checking/verify-rust-std

hm, there's an effort but scoped only to the std

It's terrifically complex: https://doc.rust-lang.org/beta/nightly-rustc/rustc_middle/ty...

Re:11 year old unsoundness bugs found in Rust borrow checker by vrighter on Tuesday October 13, 2026 @08:56AM (#50070949)
not of the implementation. Of the type system. And a verification of subsets, but not a verification of their interactions == the whole system is unverified.
Re:11 year old unsoundness bugs found in Rust borrow checker by afdbcreid on Tuesday October 13, 2026 @09:24AM (#50071344)
The eventual goal is verification of the full system. Not the implementation, yes, that's infeasible. But this will mean all soundness bugs will be either found and fixed or we'll know how to fix them once they're found. In any way they won't be fundamental (which is believed to be the case today, but not proven).
Re:11 year old unsoundness bugs found in Rust borrow checker by vrighter on Tuesday October 13, 2026 @09:55AM (#50071821)
so why put them in before knowing if they work reliably? That's the YOLO part, to me
Re:11 year old unsoundness bugs found in Rust borrow checker by cscheid on Tuesday October 13, 2026 @10:44AM (#50072550)
The same combination of reasons we've been doing these kinds of heuristic implementations forever:

- people still get value off of an incomplete implementation, because we are allowed to be mindful of the issues (see, eg, UB in C++). In other words, many, many more bugs have been prevented by the borrow checker working as intended than have been caused by it working poorly. It's not particularly close.

- theory almost always moves slower than practice

The mutable state situation pointed out by the grandparent poster was a famous issue in typing SML under mutability that required serious changes in the language, see Section 4.2 here: https://smlfamily.github.io/history/SML-history.pdf

These were Turing-award caliber people figuring it out and, according to your definition, "yolo"ed it. This stuff is _hard_, and these driveby comments truly aren't helpful.

Re:11 year old unsoundness bugs found in Rust borrow checker by vlovich123 on Tuesday October 13, 2026 @10:46AM (#50072585)
Because there’s real value delivered even before that? Perfect bring the enemy of good and all that
Re:11 year old unsoundness bugs found in Rust borrow checker by dwattttt on Tuesday October 13, 2026 @10:43AM (#50072547)
You're claiming that this bug that reproduces back to Rust 1.4 (2015) is a sign they're adding too many features to make sure they don't introduce bugs? Or do you have bugs that are due to these recent features?
Re:11 year old unsoundness bugs found in Rust borrow checker by streetfighter64 on Tuesday October 13, 2026 @09:09AM (#50071144)
It holds that ¬(∀subsets: isverified(subset)) but it's not true that ∀subsets: ¬isverified(subset), which it think most people would interpret "the whole system is unverified" as
Re:11 year old unsoundness bugs found in Rust borrow checker by vrighter on Tuesday October 13, 2026 @09:59AM (#50071886)
If I independently verify that subsystem A properly consumes apples, and that subsystem B is properly emitting oranges, but never verify that subsystem A is receiving apples, and just connect subsystem B to it, then yeah, the system is not verified.
Re:11 year old unsoundness bugs found in Rust borrow checker by samus on Tuesday October 13, 2026 @11:42AM (#50073500)
That's not the issue though.
Re:11 year old unsoundness bugs found in Rust borrow checker by cmrx64 on Tuesday October 13, 2026 @11:44AM (#50073534)
you’re deeply confused but the words “validation” and “qualification” may help untangle the web, there’s a lot more to assurance than what your model seems to hold (and you’re drawing batshit deductions from it)
Re:11 year old unsoundness bugs found in Rust borrow checker by jeremyjh on Tuesday October 13, 2026 @08:15AM (#50070458)
There is a massive possibility space between “yolo” and formal proof. Rust has substantial evidence of correctness. For example, unit tests and types.
[dead]
Re:11 year old unsoundness bugs found in Rust borrow checker by _flux on Tuesday October 13, 2026 @08:55AM (#50070927)
I think the difference is here:

- If a compiled C++ program has unsound behavior, the program needs to be fixed

- If a compiled safe Rust program has unsound behavior, the compiler needs to be fixed

Re:11 year old unsoundness bugs found in Rust borrow checker by bonzini on Tuesday October 13, 2026 @10:26AM (#50072300)
> - If a compiled safe Rust program has unsound behavior, the compiler needs to be fixed

Not really: the program still needs to be fixed, but fixing the compiler ensures that this unsound behavior never happens again to anyone. So you have two bugs to solve (vs C++'s one bug) but then you kill an entire class of unsoundness bugs just by recompiling.

Re:11 year old unsoundness bugs found in Rust borrow checker by jooops1 on Tuesday October 13, 2026 @09:32AM (#50071479)
That's not completely correct. If the Rust or C++ compiler has a bug in both cases either the compiler has to be fixed or the program can be adjusted to work around said compiler bug If possible. However, It's fair to argue that the Rust compiler makes more assertions and is more complex, which results in a larger error surface.
Re:11 year old unsoundness bugs found in Rust borrow checker by afavour on Tuesday October 13, 2026 @09:55AM (#50071812)
Which is better, surely? One fix for every program written in Rust vs everyone having to fix it themselves…
Re:11 year old unsoundness bugs found in Rust borrow checker by devmor on Tuesday October 13, 2026 @09:11AM (#50071156)
> If a compiled safe Rust program has unsound behavior, the compiler needs to be fixed

Can you provide an example of such a program that can’t be fixed at the program level like a C++ example?

Re:11 year old unsoundness bugs found in Rust borrow checker by _flux on Tuesday October 13, 2026 @09:13AM (#50071190)
Sure, usually the program can be changed to avoid the issue, but the key here is that the Rust compiler is wrong and needs to be fixed. Once fixed, the actual program fix also falls in place, as it cannot be compiled anymore.
Re:11 year old unsoundness bugs found in Rust borrow checker by samus on Tuesday October 13, 2026 @11:44AM (#50073546)
That's the same kind of issue like a bug in a C++ compiler.
Re:11 year old unsoundness bugs found in Rust borrow checker by remexre on Tuesday October 13, 2026 @12:20PM (#50074201)
The average cause of unsoundness in a C++ program is not a C++ compiler bug
Re:11 year old unsoundness bugs found in Rust borrow checker by samus on Tuesday October 13, 2026 @03:23PM (#50077196)
This is about an issue in the type checker, which would lead to unsoundness also in a C++ program. And also in Rust most causes of runtime failures are actually things that happen in `unsafe` blocks.
Re:11 year old unsoundness bugs found in Rust borrow checker by carlmr on Friday October 16, 2026 @04:51AM (#50115862)
Yes, we're discussing though in safe (non-unsafe/normal) Rust here. There is no safe C++, everything in C++ is unsafe by default. Even more unsafe than Rust unsafe, because Rust unsafe still does a lot of the safety measures of normal Rust, but allows only a handful extra things and doesn't disable the borrow checker:

https://doc.rust-lang.org/book/ch20-01-unsafe-rust.html

But getting back to the point, the C++ compiler doesn't have a borrow checker, so it can't have a bug in it. So it's on you, as the developer, to take care of all unsoundness.

While in Rust an issue is now filed, and with the fix, every future Rust program gets the fix.

Re:11 year old unsoundness bugs found in Rust borrow checker by samus on Tuesday October 20, 2026 @04:14PM (#50172024)
[delayed]
Re:11 year old unsoundness bugs found in Rust borrow checker by devmor on Tuesday October 13, 2026 @11:17PM (#50081971)
That’s not an example, that is you restating your post.
Re:11 year old unsoundness bugs found in Rust borrow checker by _flux on Wednesday October 14, 2026 @03:18AM (#50083652)
I don't find that anyone made a claim that the program could not be fixed. Why are you suggesting to find a proof of this?

The point of course was not that what you can do, but what you should do. All cases of safe Rust compiler producing unsound code should be fixed, but the same argument is more difficult to make for C++.

Sometimes should might be different of what you must. For example, if your program exhibits unsound behavior in safe Rust (or C++) code, it's probably a lot more practical to just change the program so that it doesn't, instead of updating the compiler, unless you happen to be a Rust compiler developer. But, at the same time, you should file an issue about it.

You can of course find C++ compiler bugs as well, although I expect that to be quite rare nowadays. But the typical case is that if a C++ program exhibits unsound behavior, there is no reasonable compiler fix for it.

Then there's of course Fil-C! This improves the situation greatly by converting most interesting cases of unsound behavior into runtime errors. It seems not everyone is happy with the runtime costs of making this happen, though. And you must compile everything with Fil-C. It doesn't work with Windows or MacOS either.

Re:11 year old unsoundness bugs found in Rust borrow checker by devmor on Wednesday October 14, 2026 @07:36AM (#50086056)
Your shoulds and musts are nice and all but you said that in these situations, the rust compiler needs to be fixed when the C++ program can be adjusted.

I simply cannot imagine a situation where you can’t find an alternate solution to a problem with the compiler. Even if the compiler would optimize your intended solution away, you can write an asm! macro.

It sounds to me like you have simply decided that one language cannot do what the other can because you personally would not do it, which is very silly.

If this is not the case then I restate my request for an example, for the third time - an example would prove the point you are not making through explanation.

Re:11 year old unsoundness bugs found in Rust borrow checker by _flux on Wednesday October 14, 2026 @07:51AM (#50086213)
I suggest you point the exact statement where I claimed the corresponding safe Rust program is impossible to fix to avoid unsound behavior.

I hold the argument that if the Rust compiler produces unsound behavior for safe Rust, then the compiler needs to be fixed.

Re:11 year old unsoundness bugs found in Rust borrow checker by devmor on Wednesday October 14, 2026 @01:43PM (#50091756)
The original comment I replied to, in which you claimed that the difference between a safe Rust and C++ program with unsound behavior is that the C++ program needs to be fixed, but for the Rust program, the compiler needs to be fixed.

As I see it, in either case, the program can be fixed, or the compiler can be fixed. The only difference as I see it is that the C++ spec does not expect the compiler to be fixed.

Did I misunderstand your post?

Re:11 year old unsoundness bugs found in Rust borrow checker by _flux on Wednesday October 14, 2026 @03:45PM (#50093938)
I would say as stated there were two ways to read the claim:

- either that the claims are paired as you say (the second one implying that the program cannot be fixed),

- or that the claims are completely distinct, that simply state the desirable state of things.

Using the second interpretation, the corollaries would be:

- there is (typically) no reasonable fix for the C++ compiler that would address the UB. Therefore to fix the UB all C++ programs exhibiting the same need to be fixed, which is hard, as the compiler will keep accepting them.

- once the Rust compiler is fixed, then all safe Rust programs exploiting the bug must now be fixed, or the compiler will reject them.

What I would sign under would be the second interpretation, not the first one. But I intentionally also selected the particular ambiguous form due to the cutesy, albeit misleading, symmetry of the statements.

Re:11 year old unsoundness bugs found in Rust borrow checker by devmor on Wednesday October 14, 2026 @06:15PM (#50096203)
I understand and do agree with you following your intended interpretation. Thank you for the patience and explanation.
Re:11 year old unsoundness bugs found in Rust borrow checker by krona on Tuesday October 13, 2026 @08:58AM (#50070966)
> You can be annoyed by Rust fanboys, sure, but the more annoying are the Rust haters, because the hate always comes from a place of ignorance.

For what it's worth, Rust fanboys also seem just as vulnerable to their ignorance of C/C++ compiler extensions and tooling (e.g. sanitizers, bounds annotations, standard library hardening modes and so on.) which are just normal part of professional C/C++ use today.

Re:11 year old unsoundness bugs found in Rust borrow checker by afdbcreid on Tuesday October 13, 2026 @09:25AM (#50071365)
And are also woefully insufficient as proven in most sanitized & linted & fuzz-tested programs in existence (browsers and operating systems).
Re:11 year old unsoundness bugs found in Rust borrow checker by krona on Tuesday October 13, 2026 @09:31AM (#50071463)
Compared to what? CVE-2025-68260?
Re:11 year old unsoundness bugs found in Rust borrow checker by afdbcreid on Tuesday October 13, 2026 @09:36AM (#50071542)
Compared to, for example, 5 million Rust lines in Android, I'd say.
Re:11 year old unsoundness bugs found in Rust borrow checker by vlovich123 on Tuesday October 13, 2026 @10:59AM (#50072788)
Yeah, the anti-Rust crowd seems to just hate Rust and completely ignore all the empirical evidence that professional C++, even using all the TSAN, ASAN etc still has ~10-100x the memory safety issues of Rust without any of that. I think they think “oh - use after free and out of bounds are trivial to solve” and ignore the enormously meaningful order of magnitude harder thread safety. Not to mention that sanitizers are only effective at validating the code paths exercised within the test suite. Production manages to test all the things your test suite missed. The Rust compiler verifies stricter properties about your program proof being correct in all cases (within the bounds of its own correctness of course, but that’s higher than all other code combined).
Re:11 year old unsoundness bugs found in Rust borrow checker by krona on Tuesday October 13, 2026 @03:05PM (#50076931)
> “oh - use after free and out of bounds are trivial to solve” and ignore the enormously meaningful order of magnitude harder thread safety

This is what advocates of Rust are guilty of and CVE-2025-68260 is an example of it. Ultimately TSAN and KTSAN exist for a reason, and rust devs should learn how to use them effectively.

Re:11 year old unsoundness bugs found in Rust borrow checker by vlovich123 on Tuesday October 13, 2026 @04:55PM (#50078613)
I'm not saying don't use sanitizers. I'm saying that even without sanitizers you're better. Also, this CVE isn't strictly a Rust problem - it's a problem creating safe boundaries around unsafe C code which was difficult even for the Rust standard library to suss out and even harder in kernel land where the rules are often not even documented. It'll take time but I don't see how this is an inditement. I can point to the myriad of CVEs the kernel has in C code regardless of sanitizers being used - what consistent and equal standard are you upholding those lines of code to.
Re:11 year old unsoundness bugs found in Rust borrow checker by vrighter on Tuesday October 13, 2026 @09:01AM (#50071010)
That's verifying the implementation. The type system wasn't verified. It implements stuff perfectly, it has tests that prove it, but nobody formally verified that they perfectly implemented the correct algorithms
Re:11 year old unsoundness bugs found in Rust borrow checker by bluGill on Tuesday October 13, 2026 @09:09AM (#50071137)
Tests are not perfect, but they are a lot better than where we were in 1990.
Re:11 year old unsoundness bugs found in Rust borrow checker by vrighter on Tuesday October 13, 2026 @09:56AM (#50071830)
completely tangential to whether you're testing for the right thing.
Re:11 year old unsoundness bugs found in Rust borrow checker by bluGill on Tuesday October 13, 2026 @11:20AM (#50073134)
We are a lot closer to testing the right thing today than we were in 1990!

There are pros and cons to tests, but they do some things very well. For starters a test is a lot better sign that things work as intended than a formal proof which is often so abstract most people can't be sure how it relates to what was intended. You can prove something correct that is clearly wrong. While a test will only test the one case, at least it is typically easy to understand that case and why that answer is correct. Of course if your requirements are correct your proof will tell you it is correct for all cases while a test is limited to that one case. Again pros and cons, and people speaking against tests are not honest about those.

Re:11 year old unsoundness bugs found in Rust borrow checker by vrighter on Wednesday October 14, 2026 @07:19AM (#50085879)
whether you're testing for the right thing is a binary question. We can't be any closer. To be pedantic, since Rust didn't exist in the 90s then we would be NaN% closer!
Re:11 year old unsoundness bugs found in Rust borrow checker by csande17 on Tuesday October 13, 2026 @08:11AM (#50070420)
Yes. When people describe Rust as "a memory-safe programming language" they are describing an aspirational vision, and not a programming language that has actually been designed with sufficient rigor to guarantee memory safety. Any failure of rustc to actually guarantee this is just a bug in rustc itself, a failure to properly implement the Rust spec, because the closest thing Rust has to a spec is literally just the vague ideal that the compiler should guarantee safety somehow.

Rust cannot fail, it can only be failed.

Re:11 year old unsoundness bugs found in Rust borrow checker by lolakutty on Tuesday October 13, 2026 @08:21AM (#50070534)
>Rust cannot fail, it can only be failed...

Sweet. But why should anyone care..

Re:11 year old unsoundness bugs found in Rust borrow checker by UncleMeat on Tuesday October 13, 2026 @08:29AM (#50070619)
Would you say the same thing about Java? It’s type system is also unsound.
Re:11 year old unsoundness bugs found in Rust borrow checker by csande17 on Tuesday October 13, 2026 @08:36AM (#50070701)
I'm not an expert on the Java specification, but my understanding is that Java as a language is well-defined enough that we can say things like "Java's type system is unsound", independently from any specific implementation of Java.

You can't do that with Rust because "Rust's type system" is literally just the vague concept of "a type system that is safe". The implementation of this ideal in rustc can have flaws, but Rust itself cannot, because Rust itself has no flaws by definition.

Re:11 year old unsoundness bugs found in Rust borrow checker by mcherm on Tuesday October 13, 2026 @10:15AM (#50072136)
It is true that Rust does not have a complete formal specification for its type system which has been analyzed and proven to be sound.

You seem to be implying that because of this, Rust has no definition of its type system (other than whatever happens to be implemented in the current compiler). I would disagree.

As evidence, I would like to point out that not a single person argued that this flaw was not a bug, but was in fact the officially defined behavior. Clearly, the community has a shared understanding of what Rust's type system "ought" to do.

Re:11 year old unsoundness bugs found in Rust borrow checker by csande17 on Tuesday October 13, 2026 @12:29PM (#50074401)
The true specification was inside our hearts all along!
Re:11 year old unsoundness bugs found in Rust borrow checker by Ar-Curunir on Tuesday October 13, 2026 @01:13PM (#50075197)
I mean yes, part of our understanding of systems is a social one!
Re:11 year old unsoundness bugs found in Rust borrow checker by csande17 on Tuesday October 13, 2026 @04:14PM (#50077992)
[delayed]
Re:11 year old unsoundness bugs found in Rust borrow checker by eru on Tuesday October 13, 2026 @01:52PM (#50075799)
Haskell is in a similar boat with regards to a missing formal spec.
Re:11 year old unsoundness bugs found in Rust borrow checker by tome on Tuesday October 13, 2026 @04:41PM (#50078408)
Re:11 year old unsoundness bugs found in Rust borrow checker by vrighter on Tuesday October 13, 2026 @09:04AM (#50071047)
but it isn't claiming to be saving you from things it can't prove it can either.
Re:11 year old unsoundness bugs found in Rust borrow checker by thfuran on Tuesday October 13, 2026 @02:11PM (#50076082)
Memory safety was always a major selling point for java.
Re:11 year old unsoundness bugs found in Rust borrow checker by UncleMeat on Thursday October 15, 2026 @07:24AM (#50102135)
Eh. Java was released in 1995. Smashing the Stack for Fun and Profit was published in 1996. The big selling point for java in the beginning was write-once-run-everywhere. Being a GCed language was also a selling point, but that is distinct from memory safety as a selling point.
Re:11 year old unsoundness bugs found in Rust borrow checker by insanitybit on Tuesday October 13, 2026 @08:33AM (#50070669)
I don't think the definition of "memory safe" has ever required full end to end stack conformance with a proof. Very few languages have achieved that, though some have. Most people call Java memory safe, C#, Python, Typescript, etc - all of those fall short of a formally verified, sound type system with a verified toolchain.
Re:11 year old unsoundness bugs found in Rust borrow checker by afdbcreid on Tuesday October 13, 2026 @08:49AM (#50070865)
Not to talk about Go, which has intentional unchecked-at-runtime UB (data races) yet many argue to consider it memory safe (and I have a feeling that the same people arguing Rust isn't memory safe are also there. Just a feeling though).
Re:11 year old unsoundness bugs found in Rust borrow checker by DriverDaily on Tuesday October 13, 2026 @08:49AM (#50070862)
> Rust cannot fail, it can only be failed.

“Please build the perfect system. Because I specified ‘perfect’ any flaws are due to your incomplete implementation, not my awful brief.”

If the person writing the rust spec was a client I would have to drop them because they would be setting themselves up for dissatisfaction.

Re:11 year old unsoundness bugs found in Rust borrow checker by thfuran on Tuesday October 13, 2026 @08:06AM (#50070367)
No mainstream compiler is formally proven. If you want a verified compiler, you pretty much have to choose between using a subset of standardml or a subset of C and the one proven compiler for each.
Re:11 year old unsoundness bugs found in Rust borrow checker by AnimalMuppet on Tuesday October 13, 2026 @08:34AM (#50070671)
Wait, there's a proven subset of C? Can you point me to some info?
Re:11 year old unsoundness bugs found in Rust borrow checker by xgk on Tuesday October 13, 2026 @08:36AM (#50070698)
Re:11 year old unsoundness bugs found in Rust borrow checker by vrighter on Tuesday October 13, 2026 @08:59AM (#50070980)
You're mistaking the semantics of the type system, from the implementation. I'm not talking about verifying the compiler. There's nothing to verify there.... literally. There is no spec to the language. By definition it is verified because the only verification you can do is tautological: "does this rust compiler do what this rust compiler does?"

But the unsoundness is because the type system itself, abstractly, was not verified. Or the interactions between parts. I.e. If you verified the compiler you'll find that it implements the algorithms perfectly. But tells you nothing about whether those implemented algorithms, however perfectly implemented, actually provided those guarantees.

Re:11 year old unsoundness bugs found in Rust borrow checker by vlovich123 on Tuesday October 13, 2026 @10:51AM (#50072670)
They probably meant things like LLVM and the various optimization passes. None of those are verified, there’s probably all sorts of correctness issues, and yet it’s still ok. Rust’s usage also has issues and bugs emitting the right intermediate form for LLVM to consume and usually also it’s ok.

Would it be nice if we had even higher level of quality? Yes. But what’s neat is we have empirical evidence - Rust code does achieve the memory safety goals over C++ even though there’s bugs in the compiler. That’s why Rust is very quickly eating all things C and C++. A huge amount of value that the industry would just be unable to access for a long time if you waited for everything to be formally proven.

Re:11 year old unsoundness bugs found in Rust borrow checker by thfuran on Tuesday October 13, 2026 @03:29PM (#50077284)
Okay, but verifying a type system and language specification for soundness wouldn't actually give you any of the guarantees you want if the compiler toolchain isn't verified to implement them correctly. And this sort of thing just isn't standard practice in the industry and never has been. Sure it would be nice if more things were verified, and we are somewhat headed in that direction, but it seems weird to say that rust specifically is just a bunch of half-baked yoloing because it doesn't do something that essentially no other language is doing either.
Re:11 year old unsoundness bugs found in Rust borrow checker by UncleMeat on Tuesday October 13, 2026 @08:28AM (#50070612)
The Java type system is also unsound. That’s life. It is hard to do this fully correctly. In practice this never comes up.
Re:11 year old unsoundness bugs found in Rust borrow checker by afdbcreid on Tuesday October 13, 2026 @08:42AM (#50070761)
While true, there are two important differences:

1) Unsoundnesses in Java's type system are checked at runtime.

2) They (or at least some) are intentional or at least won't-fix bugs.

Both are not true for Rust.

Re:11 year old unsoundness bugs found in Rust borrow checker by cowlevel on Tuesday October 13, 2026 @08:49AM (#50070855)
As you can see, this is a true statement, but HN really really really hates it for some reason.
Re:11 year old unsoundness bugs found in Rust borrow checker by itishappy on Tuesday October 13, 2026 @11:16AM (#50073055)
Formal verification of the type system does seem a worthwhile goal, and to my understanding it's something the community has been making progress towards, but I also understand it's still relatively uncommon for most languages.

Is this more an abstract concern over the state of the industry, or is there a specific language you had in mind that you'd prefer Rust was modeled after?

Re:11 year old unsoundness bugs found in Rust borrow checker by thfuran on Tuesday October 13, 2026 @02:10PM (#50076058)
Relatively uncommon as in there is not, as far as I know, a single mainstream language with a formally verified spec.
Re:11 year old unsoundness bugs found in Rust borrow checker by mirashii on Tuesday October 13, 2026 @11:47AM (#50073603)
Important to note that this is is not a bug in the type system itself, it's a bug in the borrow checker not enforcing invariants that the type system says that it should, and formal verification of the type system would not have helped here.
Re:11 year old unsoundness bugs found in Rust borrow checker by steelframe on Tuesday October 13, 2026 @01:00PM (#50074955)
The font color is so close to the background now that I can't even read your edit. Sorry, bud.