News for hackers. Stuff that matters.
Re:Announcing Rust 1.100.0 by grommz on Thursday November 12, 2026 @03:41PM (#50473943)
Feels good to have deleted the last traces of rust from my system, and any project that uses it. Looking at you Matrix.
Re:Announcing Rust 1.100.0 by chiffaa on Thursday November 12, 2026 @04:55PM (#50474871)
I hope you're using Devuan or something similarly niche because otherwise you're being silly for no reason, as you are definitely out of standard Linux, Windows, Chromium, Firefox and a fairly high amount of other projects at all levels
Re:Announcing Rust 1.100.0 by wpollock on Thursday November 12, 2026 @04:25PM (#50474514)
This is great news! Well done Rust team!

As this release seems to include breaking changes, shouldn't the major version number have been bumped, as per semver?

Has the Rust book(s) been updated to include the new APIs?

Re:Announcing Rust 1.100.0 by kibwen on Thursday November 12, 2026 @09:00PM (#50477131)
Rust's three stability caveats are as follows:

"We reserve the right to fix compiler bugs, patch safety holes, and change type inference in ways that may occasionally require new type annotations."

https://blog.rust-lang.org/2014/10/30/Stability/#what-are-th...

The breakage in question here falls under changes to type inference, which are allowed within reason when they're relatively minor, when steps have been taken to mitigate any breakage in the broader ecosystem, and when the compiler has emitted warnings regarding the imminent change during a grace period, all of which have been done here.

Re:Announcing Rust 1.100.0 by shevy-java on Thursday November 12, 2026 @04:54PM (#50474862)
> The never type, spelled ! in code

Is that the raven that says Ni?

https://www.youtube.com/watch?v=bLiXjaPqSyY

Re:Announcing Rust 1.100.0 by Sol- on Thursday November 12, 2026 @05:16PM (#50475130)
Do language features still matter except insofar as they make the LLM verification loop better?
Re:Announcing Rust 1.100.0 by yodsanklai on Thursday November 12, 2026 @06:18PM (#50475813)
You're downvoted but it's a very legitimate question. My main language at work is Rust, I had some expertise with the language (and deep interest for functional programming languages and type theory), but I almost don't read the code nowadays, I just skim though the functions and type definitions. I'm genuinely surprised that there are so many comments commenting the release. I thought most programmers wouldn't care anymore.
Re:Announcing Rust 1.100.0 by soon_to_be_sb on Thursday November 12, 2026 @11:57PM (#50478536)
To prompt an LLM, you should understand the existing program.
Re:Announcing Rust 1.100.0 by Sol- on Friday November 13, 2026 @04:20AM (#50480574)
Thanks, it was also a genuine question on my part and something I personally noticed recently with the Python 3.15 release notes - I used to enjoy reading them and cared, but it seems a bit moot to read them nowadays.

So I wonder what programming languages should optimize for nowadays. Probably there's still something to be gained in developing Rust further, because its verifiable structure makes it mesh nicely with LLMs and helps them write code, but less so with more high level languages.

Re:Announcing Rust 1.100.0 by wannabe44 on Friday November 13, 2026 @12:19AM (#50478673)
Some people still read code.
Re:Announcing Rust 1.100.0 by mkl on Thursday November 12, 2026 @05:17PM (#50475141)
> cargo install ignores the minimum publish age, for both the installed crate and its dependencies

Why is that? It seems like that makes min-publish-age much less effective.

Re:Announcing Rust 1.100.0 by GolDDranks on Thursday November 12, 2026 @06:49PM (#50476119)
The fact that install now uses the lockfile by default, mitigates this, I think.
Re:Announcing Rust 1.100.0 by epage on Thursday November 12, 2026 @07:49PM (#50476666)
This comes from usability and consistency.

When we added the MSRV aware resolver, we decided to have it not affect `cargo install` because you could get an old version and not notice (especially with how noisy cargo is) when the right answer might be to upgrade.

Somewhat similar for min-publish-age but also we had defined the parent table for these config fields to not affect install.

The change to `--locked` made us feel a little better with this non-ideal circumstance.

Re:Announcing Rust 1.100.0 by einpoklum on Thursday November 12, 2026 @05:46PM (#50475494)
Would you say that having 100 releases of the language more of a positive thing or a negative thing?

For comparison, C has had, say, 4 versions, and C++ 7 had versions (depending on how you count). But - Java has had 27 main versions and probably more than a 100 if you count minor versions/updates.

Re:Announcing Rust 1.100.0 by tialaramex on Thursday November 12, 2026 @07:19PM (#50476403)
101 stable Rust minor releases, because 1.0 was a stable release, and many more micro releases incorporating merely urgent bug fixes with no other work.

Even ignoring K&R C there is C89, C99, C11, C17, C23 and C2y is in progress. I don't see any way to squint at that and count four.

Re:Announcing Rust 1.100.0 by einpoklum on Friday November 13, 2026 @03:51AM (#50480329)
I forgot about C17, sorry. C2y is not released yet... so, 5 releases of C.
Re:Announcing Rust 1.100.0 by estebank on Thursday November 12, 2026 @08:10PM (#50476800)
They are completely different release processes, for different things. C and C++ are language specifications and Rust is a tool chain. Even comparing against another compiler tool chain like gcc it wouldn't be a 1 to 1 comparison. Rust having 100 minor releases is only a factor of the passage of time.

Last time I checked between a quarter and a third had a patch release, and those are closer to a signal of "a minor release had a problem". When analysing those my conclusion and the time was "for the most part they were needed because some niche feature or platform had a regression that wasn't caught by the suite and a handful of regressions causes by enabling a new feature or updating llvm".

Even Rust Editions are not a good point of comparison because they are also time based and only leveraged by things that would otherwise be breaking changes.

What you could use for direct comparison is accepted Rust RFCs against accepted C++ proposals papers or the equivalent for other languages. Or merged Pull/Merge Request counts for the different tool chains. But that's not perfect either (Rust only supports one language, while GCC several, but it has a package manager, which GCC doesn't).

Re:Announcing Rust 1.100.0 by pornel on Friday November 13, 2026 @01:40PM (#50487858)
GCC, clang and cmake had way more than 100 minor releases.

The version numbers are not comparable, because Rust bundles compiler, package manager, standard library in one release.

Additionally, Rust the language makes incremental changes stabilising individual features when they're ready, instead of bottling them up into rare grand releases. So number of releases doesn't tell you rate of change. It's like slicing pizza into smaller slices doesn't make a bigger pizza.

Re:Announcing Rust 1.100.0 by levkk on Thursday November 12, 2026 @05:50PM (#50475537)
DropGuard is nice. This is basically `defer` in Go I think.
Re:Announcing Rust 1.100.0 by Groxx on Thursday November 12, 2026 @06:09PM (#50475744)
[delayed]
Re:Announcing Rust 1.100.0 by aw1621107 on Thursday November 12, 2026 @06:59PM (#50476218)
Minus Go's defer being function-scoped, of course.

(and what sibling comment mentioned)

Re:Announcing Rust 1.100.0 by uncivilized on Thursday November 12, 2026 @06:53PM (#50476154)
The blog post says min-publish-age depends on the registry recording a pubtime. Why would pubtime not exist in the index?
Re:Announcing Rust 1.100.0 by epage on Thursday November 12, 2026 @07:57PM (#50476715)
It was only added to the registry spec a few releases ago. We can't guarantee that a registry has updated to provide it.
Re:Announcing Rust 1.100.0 by uncivilized on Thursday November 12, 2026 @09:56PM (#50477548)
Ah I see, but that means all new releases on crates.io will have that tag, correct?
Re:Announcing Rust 1.100.0 by epage on Thursday November 12, 2026 @11:20PM (#50478277)
The crates.io index was updated to have pubtime populated for every version of every crate.
Re:Announcing Rust 1.100.0 by uncivilized on Friday November 13, 2026 @11:48AM (#50486145)
Thanks
Re:Announcing Rust 1.100.0 by AndruLuvisi on Thursday November 12, 2026 @07:03PM (#50476265)
I can't find any mention of become. Does rust have proper tail calls now?
Re:Announcing Rust 1.100.0 by aw1621107 on Thursday November 12, 2026 @07:36PM (#50476556)
Looks like it's still being worked on: https://github.com/rust-lang/rfcs/pull/3407

At least from a quick skim of the comments it seems there's still some stuff that needs to be worked on on the LLVM side of things as well.

Re:Announcing Rust 1.100.0 by sawirricardo on Thursday November 12, 2026 @07:47PM (#50476652)
i wish for small storage and short duration compilation times
Re:Announcing Rust 1.100.0 by Alien1Being on Thursday November 12, 2026 @07:48PM (#50476657)
The elephant in the room question is:

Is this good for AI vibecoding ?

Human intelligibility and coherence does not seem to matter any more, for current software development.

Re:Announcing Rust 1.100.0 by soon_to_be_sb on Thursday November 12, 2026 @11:51PM (#50478493)
>Human intelligibility and coherence does not seem to matter any more, for current software development.

Only if your software is throwaway that no one uses.

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.

Re:Announcing Rust 1.100.0 by Panzerschrek on Friday November 13, 2026 @12:21AM (#50478693)
> global-min-publish-age = "3 days"

It's not a proper solution. A malicious crate can just contain a time-based switching mechanism in order to be undetected some time (let's say a couple of months) in order to become widespread.

Re:Announcing Rust 1.100.0 by WillDaSilva on Friday November 13, 2026 @12:32AM (#50478773)
There exist companies who scan newly published crates (especially popular ones) for malicious code. Just because the code isn't active yet doesn't mean it won't be caught within a window like this. These measures provide real, albeit imperfect, security.
Re:Announcing Rust 1.100.0 by Panzerschrek on Friday November 13, 2026 @12:37AM (#50478805)
> There exist companies who scan newly published crates

There is only one logical step left - make such scanning mandatory. Even better would be to perform proper audit with real humans involved. In order to cut down costs of such measures, there should be some limit on how often a package may be updated, let's say, once in a week.

Re:Announcing Rust 1.100.0 by nine_k on Friday November 13, 2026 @12:55AM (#50478908)
Isn't it the time between release for analysis and release for use? I suppose that finding malware only when it's activated isn't the only possible way, especially when the complete source code is available.
Re:Announcing Rust 1.100.0 by hmry on Friday November 13, 2026 @07:24AM (#50482518)
This is something I really appreciate about cargo/crates.io's "source code only" distribution, compared to e.g. npm or pip/PyPI.

You always know that the package contents match the source code, and you can always add a dependency by just downloading its source code and putting it into a subdirectory. You don't have to go and set up a different build system for each library if you want to avoid the pre-built artifacts.

Re:Announcing Rust 1.100.0 by woodruffw on Friday November 13, 2026 @07:55AM (#50482831)
People have shipped binaries inside of crates on crates.io. It’s a strong (and good) community convention not to, but there’s nothing stopping it.
Re:Announcing Rust 1.100.0 by superlupo on Friday November 13, 2026 @02:42AM (#50479746)
Why not finally a 2.0 if there's a breaking change in it? Or is versioning merely covered by "yearly editions"?
Re:Announcing Rust 1.100.0 by looperhacks on Friday November 13, 2026 @03:34AM (#50480204)
Because rust 1.100.0 will still compile older code. To get the breaking changes, a crate has to opt into a newer edition. Older editions will still work fine. Apparently this has the added advantage that crates that use different editions can still work together, because the compiler understands all editions.
Re:Announcing Rust 1.100.0 by Felk on Friday November 13, 2026 @05:47AM (#50481562)
The release explicitly made a breaking change for _old_ editions regarding the `Infallible` type. Though they do explain that they consider the fallout of this to be minimal
Re:Announcing Rust 1.100.0 by IshKebab on Friday November 13, 2026 @07:46AM (#50482741)
It's a very minor breaking change. This happens all the time in large projects. E.g. when C++ or Python remove rarely used features. Python would be at version 10 by now if they followed strict backwards compatibility.
Re:Announcing Rust 1.100.0 by badmonster0 on Friday November 13, 2026 @03:58AM (#50480394)
excited for this
Re:Announcing Rust 1.100.0 by esFran on Friday November 13, 2026 @06:01AM (#50481741)
I've been thinking for a while about learning a programming language other than SQL and Python. I'm weighing three candidates: C, C++ (modern C++, with smart pointers and so on) or Rust, and I can't make up my mind. C is ideal because it would get me into the Linux world and make me 100% portable. But the threat Rust poses on the security front is significant. C++ is a real dark horse: almost all high-performance libraries are written in C++, as are critical pieces of software such as 3D engines, drone controllers and robotics. But the threat from Rust is still felt.

I have to choose: what would you recommend? I think C++ could be the perfect fit, but it keeps me out of Linux kernel development. With LLMs, is the safety advantage of Rust's borrow checker mitigated?

Re:Announcing Rust 1.100.0 by rswail on Friday November 13, 2026 @07:34AM (#50482626)
C is a simple language that is easy to understand but also easy to make classic mistakes like use-after-free and array boundaries.

C++ is an extremely complex language with lots of features and libraries and mountains of code, but it's not necessarily easy to write or debug. Compiler warnings alone can be crazy, considering the templating feature is almost a compile-time turing complete language.

Rust has some (to me) ugly syntax, but it tries to avoid the footguns of C++ while maintaining its commitment to removing the classic C problems in safe code. It also tries to maintain "zero cost abstractions" that are easier to program, but don't impact execution speed, primarily by having a much smarter compiler than C or C++.

I'd learn Rust. C will be easy after that, and C++ may be unnecessary.

Re:Announcing Rust 1.100.0 by esFran on Friday November 13, 2026 @09:09AM (#50483726)
Thanks!
Re:Announcing Rust 1.100.0 by Buttons840 on Friday November 13, 2026 @10:13AM (#50484732)
Learn whichever one makes you most excited right now.

Don't worry, you can change your mind. If you end up learning a little of all 3, that's a good thing.

The time you spend analyzing which you should learn would be better spent learning the worst possible pick of the 3.

But don't feel too bad, I also procrastinate by analysis. Many of us do. :)

Re:Announcing Rust 1.100.0 by close2 on Friday November 13, 2026 @01:34PM (#50487787)
What are your plans? C is a simple language, which brings you closer to assembler. It does allow some unusual syntax, which is why obfuscated C contests exist, but you will be able to program and understand basic C in very little time. rust is different. Even if you are an experienced programmer you will encounter new concepts and patterns.

If you just want to learn a language for the fun of it, I would still start with C.

Learn rust, if you want to create "real" programs.

Re:Announcing Rust 1.100.0 by kstrauser on Saturday November 14, 2026 @10:19AM (#50497719)
I’ve used Python since the 90s. Rust feels very much in the spirit of it to me: a Rust program ends up shaped a lot like the Python equivalent would. Not identical, or it’d just be Python, but similar.
Re:Announcing Rust 1.100.0 by jokoon on Friday November 13, 2026 @09:01AM (#50483623)
is rust actually starting to to gain some territory over C++, or still not?
Re:Announcing Rust 1.100.0 by 129486799 on Friday November 13, 2026 @11:14AM (#50485655)
That is all very nice, but hardly anyone is writing original software in Rust. Most people use c2rust to steal C projects that are than unsafe Rust and 30% slower than the originals.

It is really the most uncreative and morally corrupt community in existence.

Re:Announcing Rust 1.100.0 by ashvardanian on Friday November 13, 2026 @11:24AM (#50485794)
This is by far my most long-awaited Rust release! The kind of “memory safety” I fight with most in Systems Programming isn’t use-after-free, but keeping things running under memory starvation. Having standard containers abort on allocation failure always seemed wrong to me, especially in an ecosystem that got so many other things right!

Huge thanks to everyone making this happen! I’ve only been on the consuming end so far, but hopefully I’ll find something useful to contribute myself. Pointer provenance might be a nice next challenge :)

Re:Announcing Rust 1.100.0 by iknowstuff on Friday November 13, 2026 @11:54AM (#50486228)
try_reserve and and try_with_capacity were stabilized in 1.57 :P of course the crates you consume have to use them though
Re:Announcing Rust 1.100.0 by unvalley on Friday November 13, 2026 @11:27AM (#50485843)
welcome min-publish-age
Re:Announcing Rust 1.100.0 by kinfish on Friday November 13, 2026 @03:00PM (#50488859)
looks g. but not sure if this consists an improvements on compile-time resource like space and time.