News for hackers. Stuff that matters.
Re:Announcing Rust 1.100.0 by nbardy on Thursday November 12, 2026 @10:32PM (#50477873)
Can anyone who knows Rust well explain why its so good for AI?

It seems like the AI can really write safe types and fast, efficient code in rust that beats anything else.

I've moved basically all my projects over to it. And I don't really know how it compares to other fast languages. My personal langue preference was always for readable languages like Clojure or Ruby, but at this point I'm not reading any code and just want performance.

Re:Announcing Rust 1.100.0 by adamnemecek on Thursday November 12, 2026 @10:33PM (#50477888)
Types and zero cost avstractions.
Re:Announcing Rust 1.100.0 by hannofcart on Thursday November 12, 2026 @11:21PM (#50478292)
Most of the reasons previously not to use Rust came down to the i) non-trivial learning curve, especially the ownership model, and ii) the (allegedly) overbearingly strict compiler that forces you to think through potential errors and solve them.

With agentic programming, (i) is a non-issue since LLMs have a very good grasp of the language, and it's no skin of your back, the agent is sweating it out with the compiler, not you, and (ii) is likely something you actually want.

I suspect it comes down to which other ecosystem you are coming from:

Python -> Rust: massive performance gains, type safety, much better concurrency

C++ -> Rust: much much better memory safety, much nicer compiler errors and warnings

Java -> Rust: better memory utilisation, non-null-able types (though I think recent Java versions facilitate this), better performance

But there are other language ecosystems where the gains become more subjective.

For eg. Golang -> Rust, I'd argue better "correctness", especially when concurrency is involved, but it's less pronounced than some of the other paths I mentioned above.

Re:Announcing Rust 1.100.0 by heresie-dabord on Friday November 13, 2026 @02:12AM (#50479511)
> Golang -> Rust, I'd argue better "correctness", especially when concurrency is involved, but it's less pronounced than some of the other paths

Tractable correctness is an underrated win at the scale of building enterprise solutions. But Rust also is a systems language, something that people had hoped from golang.

Re:Announcing Rust 1.100.0 by fluffiac on Thursday November 12, 2026 @11:31PM (#50478353)
a well designed Rust project can leverage the type system to represent "weird states" in your program. what would otherwise be unstated rules or assumptions can be laid out cleanly as type invariants. a common example is `div(a, b) -> Option` where None is returned when b is zero. you can get really fancy with this, the blog post talks about a token struct that represents holding the GIL. doing this kind of thing can make certain logic errors more difficult to write and makes code self-documenting in some sense. going against the type system is flagged during compilation, which broadly contributes to rust code feeling like it "just works" when it compiles.

if code fails to compile, rustc will produce a very high quality error message 90% of the time (they can get pretty gnarly when you're doing something super tricky, but they're still very workable for agents). tests are a first class feature, so agents are able to spot check new features on the same turn you ask it to implement something new. documentation is also first class, and lots of libraries have excellent docs (read https://docs.rs/pyo3/0.30.1/pyo3/marker/struct.Python.html). the whole toolchain gives agents a lot to work with.

Re:Announcing Rust 1.100.0 by estebank on Friday November 13, 2026 @12:41AM (#50478835)
> they can get pretty gnarly when you're doing something super tricky

When that happens, please file a ticket. That's how the errors get good: we hear about when they aren't and then we fix them.

Re:Announcing Rust 1.100.0 by oconnor663 on Friday November 13, 2026 @02:29AM (#50479637)
> It seems like the AI can really write safe types and fast, efficient code in rust that beats anything else.

This is also true for humans! Rust/C/C++ are all about equally fast, but Rust is more productive for most people. The downside for humans is that Rust's learning curve is pretty steep, but that doesn't bother the LLMs.

Re:Announcing Rust 1.100.0 by Sharlin on Friday November 13, 2026 @02:49AM (#50479815)
To be fair, as far as I know even bleeding edge LLMs have problems with the borrow checker and resort to similar workarounds as newbie human Rust coders.
Re:Announcing Rust 1.100.0 by simonask on Friday November 13, 2026 @03:59AM (#50480398)
You stumbled upon my pet peeve.

Both C and C++ have a much steeper learning curve than many realize, just because the compilers let you get away with doing things that are fundamentally invalid (Undefined Behavior). Rust isn't actually much stricter, it just catches these problems at compile time.

Anyone capable of writing actually correct, standard-conforming C and C++ is mostly able to first-try the equivalent Rust code in almost all cases, because they are already thinking the same way that Rust requires you to think.

However, a significant portion of people who write both C and C++ don't realize that their code is full of UB - or worse, they don't care.

From a language perspective, the only new restriction in Rust compared to C++ is that mutable borrows (references) cannot overlap. Good C++ programmers are already avoiding this at all cost, because it's a mess to keep track of. When you actually do need it, Rust gives you the tools to build a safe abstraction.

Re:Announcing Rust 1.100.0 by joevandyk on Friday November 13, 2026 @09:58AM (#50484499)
Any recommendations on good skills/rules/plugins for LLM rust projects?
Re:Announcing Rust 1.100.0 by IshKebab on Friday November 13, 2026 @10:03AM (#50484590)
Same reasons why it's so good for humans:

* Very strong type system which helps catch bugs at compile time.

* The type system lets you enforce invariants, e.g. see the type state pattern and "make invalid states unrepresentable"

* The borrow checker encourages tree ownership which tends to be a less buggy structure than "anything can own anything" spaghetti you get in GC'd languages.

These give it an "if it compiles it works" character, that some other languages also have (e.g. Haskell), but most don't.

This was all well known before AI. I guess it's just more obvious to people that never tried Rust themselves.