News for hackers. Stuff that matters.
Re:Rust 1.100.0 by ComputerGuru on Thursday November 12, 2026 @01:27PM (#50471852)
It would probably be better to wait for the official release blog post for submission to HN, no?
Re:Rust 1.100.0 by qchris on Thursday November 12, 2026 @01:41PM (#50472085)
The official blog post release is now up at https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/
Re:Rust 1.100.0 by NobodyNada on Thursday November 12, 2026 @01:42PM (#50472086)
Yeah, it's live now so the URL should be changed to: https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/
Re:Rust 1.100.0 by nirinor on Thursday November 12, 2026 @01:35PM (#50471989)
Woohoo, that's a release! My personal favorites:

- Stabilize never type

- Stabilize custom allocators

- Introduced minimum publish age configurations, also known as dependency cooldowns. When the relevant config is set, the resolver ignores versions published more recently than that, unless they are already in Cargo.lock. (RFC 3923) docs #17335

- cargo-install: now uses the existing lockfile in the .crate tarball by default. --locked in cargo install becomes a no-op. #17388

Re:Rust 1.100.0 by nixpulvis on Thursday November 12, 2026 @04:01PM (#50474219)
> cargo-install: now uses the existing lockfile in the .crate tarball by default. --locked in cargo install becomes a no-op. #17388

Long time follower of this. Very grateful it's been implemented.

Re:Rust 1.100.0 by epage on Thursday November 12, 2026 @04:07PM (#50474289)
For anyone that wants more context on the decision, see https://github.com/rust-lang/cargo/issues/7169#issuecomment-...
Re:Rust 1.100.0 by p-e-w on Thursday November 12, 2026 @07:58PM (#50476723)
That was one of the biggest gotchas with Rust. It’s unfortunate that it took so long to change this very unintuitive and potentially dangerous behavior.
Re:Rust 1.100.0 by SOLAR_FIELDS on Thursday November 12, 2026 @08:09PM (#50476790)
Dependency cooldowns receiving such a whiplash this year. Earlier everyone was advocating for them because of the supply chain attacks. Now, people are worried because you might miss 0 days if you use them.

Nonetheless, the ability to set and configure it is a welcome feature.

Re:Rust 1.100.0 by saghm on Thursday November 12, 2026 @09:29PM (#50477345)
Some of us were saying they didn't understand the endgame of everyone using cooldowns at the time. We mostly got told we were wrong though.
Re:Rust 1.100.0 by woodruffw on Thursday November 12, 2026 @09:45PM (#50477439)
You should do both: you should let normal updates cool down, and you should immediately patch security advisories.

One of the biggest ergonomic problems with cooldowns is that many tools let the former goal obstruct the latter. Both should be part of the state machine of resolution itself, rather than things that get layered on.

Re:Rust 1.100.0 by PaoloBarbolini on Friday November 13, 2026 @02:31AM (#50479649)
There are many cases in which security advisories aren't published. But I guess an alternative could be to update using the cooldown, and then diff the dependencies that would get a newer version if the cooldown wasn't in place to check if they contain anything relevant for the particular application you're developing.
Re:Rust 1.100.0 by ninkendo on Friday November 13, 2026 @06:56AM (#50482232)
[delayed]
Re:Rust 1.100.0 by woodruffw on Friday November 13, 2026 @07:58AM (#50482871)
> If it’s just a box you check, it only means attackers will say “this is a security update” on the malicious package they upload.

It generally requires additional permissions, per the adjacent respond. And it introduces additional scrutiny on the release, which is the last thing an opportunistic attacker wants (the entire reason “supply chain” attacks are effective is because nobody gives any thought to upgrading their dependencies in the normal case).

Re:Rust 1.100.0 by kragen on Friday November 13, 2026 @07:01AM (#50482295)
Usually people advocate dependency cooldowns as a mitigation for supply-chain attacks, where you're depending on a module with a malicious maintainer, possibly a new one (perhaps one who stole the old maintainer's keys so they can pretend to be the old maintainer).

In that situation, how do you distinguish between "normal updates" (that you should let cool down) and "security advisories"? If all the hypothetical malicious maintainer has to do to get you to update is to publish a security advisory for their own package, wouldn't they just do that? It might even be a real advisory about a real security hole that they introduced, but claiming more versions are affected than actually are affected.

Re:Rust 1.100.0 by woodruffw on Friday November 13, 2026 @07:48AM (#50482755)
It takes additional permissions, in general, to issue an advisory. And “supply chain” attacks in general tend to be used by smash-and-grab attackers, who don’t have time on their side. It’s not like a browser 0day where the attacker’s goal is to preserve their underlying exploit primitive for as long as possible.
Re:Rust 1.100.0 by kragen on Friday November 13, 2026 @09:57AM (#50484477)
Additional permissions?
Re:Rust 1.100.0 by woodruffw on Friday November 13, 2026 @01:08PM (#50487370)
I’m talking about things like GHSAs. You can’t issue one just by compromising a push credential to a repository, which is how most of these supply chain attacks start.
Re:Rust 1.100.0 by jmvoodoo on Friday November 13, 2026 @07:38AM (#50482674)
Waiting for someone to hold back a vulnerability until they can compromise a package, then release vuln publicly for maximum impact.

It’s only a matter of time.

Re:Rust 1.100.0 by derefr on Saturday November 14, 2026 @01:29PM (#50499464)
Why wouldn't a supply-chain attacker simply use a security advisory to push their attack through?
Re:Rust 1.100.0 by zarzavat on Thursday November 12, 2026 @10:42PM (#50477955)
You should use a cooldown. The effects of a supply chain attack are significantly worse than the effects of a 0 day. You can always make exceptions on a case-by-case basis.
Re:Rust 1.100.0 by dns_snek on Friday November 13, 2026 @04:40AM (#50480794)
[delayed]
Re:Rust 1.100.0 by karavelov on Thursday November 12, 2026 @01:36PM (#50471997)
Finally, "never" happened
Re:Rust 1.100.0 by jmyeet on Thursday November 12, 2026 @02:02PM (#50472441)
One might call this the moment when nothing never occurs [1].

[1]: https://www.youtube.com/watch?v=RFm9ClqlGuo

Re:Rust 1.100.0 by JoshTriplett on Thursday November 12, 2026 @02:30PM (#50472881)
And the running joke that the type is named after its stabilization date can finally be put to rest. :)
Re:Rust 1.100.0 by hbn on Thursday November 12, 2026 @02:49PM (#50473161)
We got "never" in Rust before GTA6

Two jokes that are expiring this month

Re:Rust 1.100.0 by pmichaud on Thursday November 12, 2026 @01:41PM (#50472075)
Nice work... but I still yearn for a stable ABI!
Re:Rust 1.100.0 by orlp on Thursday November 12, 2026 @01:48PM (#50472190)
We have it: unsafe extern "C" { }.

An actual stable native Rust ABI sounds like a forward compatibility nightmare.

Re:Rust 1.100.0 by Xirdus on Thursday November 12, 2026 @01:52PM (#50472263)
An actual stable native Rust ABI is a prerequisite for distributing libraries as anything other than source code.
Re:Rust 1.100.0 by redox99 on Thursday November 12, 2026 @02:09PM (#50472559)
Why would you want libraries in any other format?
Re:Rust 1.100.0 by eviks on Thursday November 12, 2026 @02:17PM (#50472680)
Not to waste time and space?
Re:Rust 1.100.0 by wahern on Thursday November 12, 2026 @02:10PM (#50472562)
Another year or three of insane memory and disk prices and people will come around.

A stable Rust ABI would be nice for not just Rust, especially if they refine or extend (formally or de facto) the SysV ABI to optimize passing and returning of discriminants. That could then smooth the way for developing these features in C and C++, such as a primitive error-result type that saw some brief attention in both C and C++ WGs a couple of years ago.

Re:Rust 1.100.0 by SkiFire13 on Thursday November 12, 2026 @02:15PM (#50472653)
It's not a strict prerequisite, you can just require the library being distributed to use extern "C".
Re:Rust 1.100.0 by gspr on Thursday November 12, 2026 @02:25PM (#50472790)
Well yes, but then your interface is a C ABI. That's fantastic if the side using my library is any language where C is the only common ground. When the application side is Rust though, it leaves a lot to be desired. It would be delicious to actually interface in a way that respects Rust!

Hell, even if all exposed functions and types would need to be fully monomorphized at the interface, it would be a lot nicer to pass a `&'a [i64]` rather than a `*const int64_t` together with a `size_t n` and have to marshall the slice on both sides.

Re:Rust 1.100.0 by Xirdus on Thursday November 12, 2026 @03:13PM (#50473476)
Or to put it another way, it is a strict prerequisite and Rust already meets it via extern "C".
Re:Rust 1.100.0 by afdbcreid on Thursday November 12, 2026 @02:34PM (#50472944)
Rust will almost certainly never have a stable ABI by default, and libraries will continue to be compiled from source by default. It might one day have an opt-in stable ABI.
Re:Rust 1.100.0 by fallingbananna on Thursday November 12, 2026 @02:39PM (#50473028)
If you can drop the "native" requirement, then Wasm is also a way.
Re:Rust 1.100.0 by ChadNauseam on Thursday November 12, 2026 @02:43PM (#50473069)
[delayed]
Re:Rust 1.100.0 by cogman10 on Thursday November 12, 2026 @03:50PM (#50474074)
Operating systems.

If there's a CVE in tokio, the OS could theoretically publish a patched version of tokio and all apps that depend on that end up using the fixed code.

As it stands now, the OS needs to publish updated versions of all rust apps that depend on tokio.

Re:Rust 1.100.0 by afdbcreid on Thursday November 12, 2026 @04:17PM (#50474411)
That's not how it works basically anywhere except in C/C++ apps on Linux.
Re:Rust 1.100.0 by Xirdus on Thursday November 12, 2026 @04:29PM (#50474558)
Because only C/C++ apps have stable ABI. Everyone else would love to do it too but they're S.O.L.
Re:Rust 1.100.0 by afdbcreid on Thursday November 12, 2026 @05:38PM (#50475411)
That's not true. Scripting languages of course need no ABI. Managed languages like C# and Java often keep compatibility of the bytecode. Only AOT languages like Go and Rust cannot.
Re:Rust 1.100.0 by cogman10 on Thursday November 12, 2026 @04:29PM (#50474565)
Yes and no.

Yes, in that it's primarily a linux thing as MS has gone the route of saving off basically all dlls for all their OSes for backwards compatibility (though they still backpatch).

No, in that other than Rust and Go (and maybe a few others that emit single binaries, zig?) this is how it works with OS distributed programming language packages. Python, ruby, java, perl, C#, the OS will for all of them control distribute and update the libs independent of the apps that use them.

Also, C/C++ still make up a huge percentage of all apps in pretty much any OS.

Re:Rust 1.100.0 by afdbcreid on Thursday November 12, 2026 @05:37PM (#50475389)
> No, in that other than Rust and Go (and maybe a few others that emit single binaries, zig?) this is how it works with OS distributed programming language packages.

Uhmm... No? E.g.:

- Python has long strongly recommended virtual environments.

- Not to talk about JavaScript which of course manage things per project by default.

- I don't remember what was the state of things in .NET Framework, but in modern .NET NuGet packages are distributed as DLLs with your app.

I don't know other ecosystems well but I believe they aren't different.

Re:Rust 1.100.0 by cogman10 on Thursday November 12, 2026 @06:19PM (#50475822)
> Uhmm... No?

Ummm... yes.

How software is maintained by an OS is different from how software is maintained by 3rd party developers.

- Python has long strongly recommended virtual environments.

Yes, if you are developing a private application. But if that application gets adopted by the OS then you can expect all it's dependencies to be sent to a place like `/usr/lib/python3/dist-packages`.

> Not to talk about JavaScript which of course manage things per project by default.

I didn't bring it up because it's one I'm not familiar with. I expect OS maintainers will do similar things with it that they do with python but I'm not 100% on that.

> I don't remember what was the state of things in .NET Framework, but in modern .NET NuGet packages are distributed as DLLs with your app.

And if your .net application ends up installed as an OS package you can expect those dlls to be stored in /usr/lib.

If you are doing C/C++, as a 3rd party app, you aren't putting the .so files or the .dll files in /usr/lib or C:\Windows\System32. You are storing them in the same directory as your application. But if the OS decides to distribute your app, you can expect your .so files to get put into /usr/lib and even System32 (very very rare for MS to do that, but it does happen when, for example, we are talking about drivers).

Re:Rust 1.100.0 by afdbcreid on Thursday November 12, 2026 @07:38PM (#50476582)
But that's the thing: almost nobody ships software via the OS today. Even on Linux software is often managed in other ways.
Re:Rust 1.100.0 by cogman10 on Thursday November 12, 2026 @07:51PM (#50476683)
Let me rewind this to the top of the thread.

> What is the advantage of doing so?

To which I responded

> Operating systems.

To which you said

> That's not how it works basically anywhere

I think we have reached the point in the thread where you concede that yes, there is somewhere where it's how it works and yes it does apply to languages that aren't C/C++.

So now you're shifting the goalposts and topic to

> almost nobody ships software via the OS today.

That was never something I was trying to debate. The topic was "why would you want ABI stability". And the answer is that if I wanted to rewrite coreutils in rust, then it'd be really useful to have synchronized crates with a stable ABI so I could potentially update those crates independent of the apps that depend on them.

Re:Rust 1.100.0 by afdbcreid on Thursday November 12, 2026 @08:07PM (#50476777)
I agree that sometimes other languages are packaged this way as well, and maybe I was moving the goalposts. My original meaning was that only for C/C++ (on Linux) the recommended method of distribution is via the OS, while other languages have their own mediums (not requiring stable ABIs). So when they are packaged like that that's mostly because the OS itself or its services need them.
Re:Rust 1.100.0 by the8472 on Thursday November 12, 2026 @07:49PM (#50476668)
[delayed]
Re:Rust 1.100.0 by cogman10 on Friday November 13, 2026 @10:27AM (#50484939)
> so they're distributed in source or intermediate form, not as fixed-ABI-shared-libraries.

I agree. These languages all have the benefit of what an ABI provides due to their nature. Go and Rust are outliers because they don't send out intermediate versions.

My point was more that the effect of being able to hot-patch applications on a system is what makes an ABI desirable, not that an ABI is necessary for that. For a language like rust, it's pretty necessary. Though it would be interesting if you could send out an intermediate compiled form of rust and do a JIT on that. WASM is pretty close to doing that, but rust doesn't support dynamic linking of modules (AFAIK).

> Even C++ has wrinkles.

Yeah, I somewhat hesitate to say C/C++ as being ABI stable as it's really just C and C++ uses that. Once you use any C++ features you quickly get into realms where things are ill defined. You end up needing gross things like COM in order to properly use C++ shared libs.

Re:Rust 1.100.0 by gspr on Thursday November 12, 2026 @05:09PM (#50475030)
Well yes exactly, because essentially nothing else has a stable ABI.
Re:Rust 1.100.0 by xtajv on Thursday November 12, 2026 @05:04PM (#50474983)
There is another thread complaining about compile times and tmp dir sizes.

Stable ABI dramatically improves the problem space there (without necessarily having anything to do with business model).

Re:Rust 1.100.0 by xigoi on Thursday November 12, 2026 @05:47PM (#50475506)
Interoperating witt other languages without having to use C as a middleman?
Re:Rust 1.100.0 by Xirdus on Thursday November 12, 2026 @06:57PM (#50476196)
An unstable ABI is entirely sufficient for that, as long as you update both sides in tandem.
Re:Rust 1.100.0 by saghm on Thursday November 12, 2026 @09:51PM (#50477491)
I agree that using the C ABI for interop between arbitrary non-C languages feels weird, but it's not like that wasn't a thing long before Rust ever existed. If you truly want a modern ABI for languages that are not C, something like the WASM component model is probably the closest thing that exists today.
Re:Rust 1.100.0 by flykespice on Thursday November 12, 2026 @08:17PM (#50476855)
Yep, and it also imposes a big security risk relying on a closed binary blob that could be injected anytime with a backdoor.

Afaik, odin seems to get it right requiring libraries to be distributed source only.

Re:Rust 1.100.0 by Svoka on Thursday November 12, 2026 @01:51PM (#50472250)
Why the yearning for prebuilt Rust libraries? Seems like a nightmare which does not need to happen.
Re:Rust 1.100.0 by silon42 on Thursday November 12, 2026 @02:28PM (#50472850)
So, all Linux will be Gentoo?
Re:Rust 1.100.0 by Svoka on Thursday November 12, 2026 @09:34PM (#50477377)
what? There is stable ABI. It's C's stable ABI. If you are reimplementing existing libraries like most of rust rewrites are, you already have ABI you have to follow.
Re:Rust 1.100.0 by gspr on Thursday November 12, 2026 @02:52PM (#50473202)
Dynamic linking is useful. Not to everyone and not always, but it is.
Re:Rust 1.100.0 by kibwen on Thursday November 12, 2026 @04:18PM (#50474431)
Rust supports dynamic linking. What a stable ABI provides is cross-toolchain dynamic linking.
Re:Rust 1.100.0 by iknowstuff on Thursday November 12, 2026 @01:51PM (#50472256)
Follow or contribute to efforts on a minimal crABI:

https://github.com/joshtriplett/rfcs/blob/crabi-v1/text/3470...

Re:Rust 1.100.0 by aitchnyu on Thursday November 12, 2026 @01:57PM (#50472348)
Couldnt Google. Is it pronounced crabby?
Re:Rust 1.100.0 by iknowstuff on Thursday November 12, 2026 @02:03PM (#50472446)
Sure is :)
Re:Rust 1.100.0 by stillpointlab on Thursday November 12, 2026 @02:16PM (#50472666)
stable ABI sounds great, but anything/everything that reduces build times is what I really want
Re:Rust 1.100.0 by Narishma on Thursday November 12, 2026 @05:33PM (#50475342)
A stable ABI would help with that.
Re:Rust 1.100.0 by JoshTriplett on Thursday November 12, 2026 @02:38PM (#50473008)
The primary challenge in having a stable ABI is that we have generics. So, even if we never changed the calling conventions, an ABI is not as simple as exporting a symbol with the right name. We implement generics by providing MIR (our main intermediate representation) that gets compiled by the linking program for each instantiation of a generic.

Swift handles this through the equivalent of Rust's `dyn`. We could have a stable ABI that's based entirely on `dyn`. Such an ABI would have some limitations, since there are traits `dyn` can't represent (anything that's generic over something other than the type that implements the trait, which is quite common), though we're working on some of those.

Essentially, you wouldn't be able to have a `Vec<T>` in your ABI without either pinning down T or using something like `Vec<Box<dyn Trait>>`. Which is possible, but kind of awful.

We're still planning to ship a stable ABI at some point, but that gives a flavor for some of the kinds of problems we'd need to solve in order for that stable ABI to be useful.

(C++ typically handles generics by having types defined in header files, and those get compiled with the program consuming the library, which is effectively the same situation Rust is in. You could export symbols from a shared library for specific instantiation of a template, but people rarely do that.)

Re:Rust 1.100.0 by mamcx on Thursday November 12, 2026 @03:40PM (#50473933)
I wonder why not make the ABI contract explicit, instead of do what C do that froze the lang.

Similar to :

    #[rust_abi]
    struct MustConform
    fn must_conform
So the user must write the shims instead of rust magically build it. This also mean that ABI changes become visible, and changes to rust not mean worries about ABI.
Re:Rust 1.100.0 by chiffaa on Thursday November 12, 2026 @04:37PM (#50474657)
To my knowledge this is what crABI is all about
Re:Rust 1.100.0 by pjmlp on Thursday November 12, 2026 @04:33PM (#50474611)
You are forgetting C++ has modules now, and extern templates, as implementations for common type parameters.
Re:Rust 1.100.0 by yrjrjjrjjtjjr on Thursday November 12, 2026 @04:41PM (#50474710)
From an abi perspective, a generic is a pure (in the functional sense) program that is run at link time that takes various type information as input and outputs an implementation.

Llm code that writes llm code seems a logical choice.

Re:Rust 1.100.0 by gspr on Thursday November 12, 2026 @05:06PM (#50474995)
Thank you for your work, it's always interesting to read your take.

Forgive the naive question on something that's probably been discussed many times over, but could there be a middle ground when it comes to a stable ABI and generics? Something where the person building the library for dynamic linking chooses which explicit monomorphizations they'd like to provide for each public generic function (and type), and the compiler stamps out all combinations of those concrete instances? Could the way these are named and stamped out be standardized so that this could be treated as a stable ABI for non-generics?

It seems to me that it would at least cover distros: they could make a pass over all their Rust code and determine which monomorphizations are needed throughout the distro.

Re:Rust 1.100.0 by IshKebab on Thursday November 12, 2026 @05:12PM (#50475075)
I would be happy with something better than the C ABI even if it doesn't support everything in Rust on day one.
Re:Rust 1.100.0 by JoshTriplett on Thursday November 12, 2026 @05:14PM (#50475109)
Same.
Re:Rust 1.100.0 by barchar on Thursday November 12, 2026 @05:19PM (#50475162)
I think there's some work on that, getting at least slice and trait object ABIs that you can use in DSO interfaces.
Re:Rust 1.100.0 by vaylian on Friday November 13, 2026 @05:14AM (#50481149)
Would it be possible to provide a first version of the ABI that deliberately excludes support for generics?
Re:Rust 1.100.0 by danhor on Thursday November 12, 2026 @03:24PM (#50473661)
I don't think a stable ABI has enough advantages to be worth it. C++, IMHO, is a great examples of the downsides of a stable-enough ABI, where stability was never guaranteed, but is now so entrenched that it'll likely never be broken again (limiting the language & the usability in a bunch of ways).

It might make sense to have a subset Swift-style stable ABI, but that's a huge engineering effort, has lots of overhead and is also likely not worth it IMHO.

Re:Rust 1.100.0 by fallingmeat on Thursday November 12, 2026 @01:42PM (#50472091)
wait other things not named jensen happened today? whoa
Re:Rust 1.100.0 by nazgulsenpai on Thursday November 12, 2026 @01:47PM (#50472171)
once outlook broke we can't even share jensen memes
Re:Rust 1.100.0 by lukax on Thursday November 12, 2026 @01:47PM (#50472184)
Awesome timing.

I just spent last few days fixing arena leaks (Bumpalo doesn't call drop) and had to use allocator-api2 for Vec::new_in which is now available in stable Rust.

https://github.com/bancek/rust-sass/pull/1

Re:Rust 1.100.0 by weinzierl on Thursday November 12, 2026 @02:12PM (#50472596)
"Awesome timing."

Wait for the timing of the next release. It will be a Christmas present.

Re:Rust 1.100.0 by iknowstuff on Thursday November 12, 2026 @01:50PM (#50472228)
Re:Rust 1.100.0 by entropicdrifter on Thursday November 12, 2026 @01:56PM (#50472335)
You are the hero we needed, today. Thank you
Re:Rust 1.100.0 by Kinrany on Thursday November 12, 2026 @02:03PM (#50472454)
@dang
Re:Rust 1.100.0 by dwb on Thursday November 12, 2026 @02:10PM (#50472567)
This doesn’t do anything.
Re:Rust 1.100.0 by lukax on Thursday November 12, 2026 @02:40PM (#50473045)
Yes, it does. It triggers some people who then post a reply to write an email to [email protected]
Re:Rust 1.100.0 by arcanemachiner on Thursday November 12, 2026 @02:51PM (#50473188)
This site doesn't even fully support Markdown or Unicode and people think for some reason that Twitter-style username tagging will actually work. U+1F923
Re:Rust 1.100.0 by Kinrany on Thursday November 12, 2026 @06:13PM (#50475774)
I don't know, the comments did get moved ¯\_(ツ)_/¯
Re:Rust 1.100.0 by orthecreedence on Thursday November 12, 2026 @03:55PM (#50474136)
Yes, you need to use all caps @DANG
Re:Rust 1.100.0 by n_u on Thursday November 12, 2026 @02:10PM (#50472574)
> Cargo now reports unused dependencies to users, e.g.

> warning: unused dependency `tracing-subscriber` --> Cargo.toml:23:1 | 23 | tracing-subscriber.workspace = true | ^^^^^^^^^^^^^^^^^^ | = note: `cargo::unused_dependencies` is set to `warn` by default help: consider removing the dependency on `tracing-subscriber`

Heck yes

Re:Rust 1.100.0 by minimaxir on Thursday November 12, 2026 @03:02PM (#50473354)
I updated to 1.100 during a Claude session and it complained about new warnings, so I told it to fix them. It removed a large number of unused dependencies without issue.
Re:Rust 1.100.0 by minimaxir on Thursday November 12, 2026 @09:21PM (#50477270)
I am legitimately confused why my parent comment is being mass downvoted: the point I was making is that this is change is more a perk for agent use with Rust since agents typically will resolve warnings by solving the issue (and therefore proactively remove redundant dependencies)
Re:Rust 1.100.0 by yuriks on Thursday November 12, 2026 @09:49PM (#50477478)
fwiw my immediate reaction (I didn't downvote) to your comment was "no one asked".
Re:Rust 1.100.0 by minimaxir on Thursday November 12, 2026 @09:55PM (#50477532)
My intent was to share a fun anecdote of an practical, unexpected impact of the change but I now see that agents + fun is still a tough sell on HN.
Re:Rust 1.100.0 by epage on Thursday November 12, 2026 @11:23PM (#50478301)
I shared your anecdote with another Cargo team member who helped work on this feature. We appreciate seeing how what we made helped people!
Re:Rust 1.100.0 by minitech on Thursday November 12, 2026 @11:40PM (#50478426)
There’s nothing fun about that anecdote, and nothing technically interesting about agents being able to do sed-level tasks. (I’m sorry for the negative comment, but it didn’t seem ideal for you to come away from this experience with the impression that “I now see that agents + fun is a tough sell on HN” suggests.)
Re:Rust 1.100.0 by MindSpunk on Thursday November 12, 2026 @10:11PM (#50477677)
Confuses me too. Maybe they just stopped reading after the first sentence and assumed you were complaining about new warnings?
Re:Rust 1.100.0 by psnehanshu on Friday November 13, 2026 @02:09AM (#50479488)
How do you guys know when your comment is downvoted? I seem to be missing something in Hacker News.
Re:Rust 1.100.0 by nexawave-ai on Friday November 13, 2026 @03:05AM (#50479952)
You must have a certain amount of Karma, then you'll be able to downvote comments. I dont know what that amount is though, I'm on 50 karma points and I dont have that feature enabled
Re:Rust 1.100.0 by latexr on Friday November 13, 2026 @06:13AM (#50481871)
> You must have a certain amount of Karma, then you'll be able to downvote comments

That’s not what they’re asking, they want to know how people know their own comments were downvoted. The answer is that you can look at your own points in your own comments.

> I dont know what that amount is though

501.

Re:Rust 1.100.0 by exographicskip on Friday November 13, 2026 @01:20PM (#50487550)
[delayed]
Re:Rust 1.100.0 by latexr on Sunday November 15, 2026 @05:46AM (#50505863)
Your account, like your comments, starts at 1 karma (not 0). In that sense, 501 is once you earn 500 karma, which is a round number.
Re:Rust 1.100.0 by m-s-y on Saturday November 14, 2026 @11:05AM (#50498110)
close to 250 here and same. no downvote option.
Re:Rust 1.100.0 by dns_snek on Friday November 13, 2026 @04:46AM (#50480847)
[delayed]
Re:Rust 1.100.0 by steveklabnik on Friday November 13, 2026 @11:15AM (#50485675)
Comments that go below one karma are made an increasingly light shade of grey.
Re:Rust 1.100.0 by nightpool on Friday November 13, 2026 @02:32AM (#50479656)
I think most people (rightly or not) feel pretty negatively about the concept of a project having hundreds of unused dependencies. If you've lost track of your codebase to such an extent as that, you should probably expect a little bit of social pushback from people who pride themselves on understanding their code and being responsible for it. It's just a fundamentally different and in some ways upsetting mindset to the average programmer.
Re:Rust 1.100.0 by saghm on Thursday November 12, 2026 @09:33PM (#50477372)
My semi-controversial take is that the best way to use agents for Rust is to literally turn every possible lint and warning on in clippy and require that they're treated as blocking for the agent to fix before ever saying things are done. While a few of them might be overzealous and feel tedious to work around manually, there's no need to care about it being tedious for an agent!
Re:Rust 1.100.0 by skavi on Friday November 13, 2026 @02:59AM (#50479903)
clippy lints are not universally good to follow. and with the pedantic set enabled, you quickly have bad clippy advice forcing a bunch of ugly expects in your code.

the default set plus a selection of whatever you like from the rest works better.

Re:Rust 1.100.0 by saghm on Friday November 13, 2026 @01:20PM (#50487549)
I was pretty explicitly talking about LLM-generated code. At the end of the day, you're either reviewing the code it outputs or you're not. If you are, I'd argue that you're going to be getting a bunch of ugly things in your code that you're going to want to clean up anyhow, and the tradeoff of having everything enabled is well worth it compared to what an LLM will generate with more relaxed lints. If you're not, I don't think you particularly need to care about "ugly" code.
Re:Rust 1.100.0 by derefr on Saturday November 14, 2026 @01:38PM (#50499543)
Yeah, but the point about boxing large variants still stands. That's not about aesthetics/readability, that's about micro-perf (e.g. cache-coherence), and potentially safety / atomicity. (And it can even be about compatibility, if you're doing it across an ABI boundary.)
Re:Rust 1.100.0 by jtwaleson on Thursday November 12, 2026 @03:39PM (#50473921)
Does this remove the need for machete or shear?
Re:Rust 1.100.0 by epage on Thursday November 12, 2026 @04:11PM (#50474333)
I believe so. The maintaner of cargo-udeps did most of the work as an effort to upstream it.

The main limitation is in dev-dep detection since there isn't a way to exhaustively run everything that uses dev-deps yet. You can look at logging statements to get an approximation though.

Re:Rust 1.100.0 by ustad on Thursday November 12, 2026 @02:23PM (#50472771)
“Never type” - Feel like I’m stupid for not having a clue what that means.
Re:Rust 1.100.0 by pkulak on Thursday November 12, 2026 @02:26PM (#50472814)
A few other langs have it too. It's just something to return when no return is actually possible. And then it can propagate, so it makes some nice things possible that weren't before.
Re:Rust 1.100.0 by igravious on Thursday November 12, 2026 @02:59PM (#50473307)
Without looking up the Rust implementation I would hazard a guess that it is loose language to say "something to return when no return is actually possible" because if it is anything like the Bottom Type then there is no something that is being returned which is what this function signature indicates. Generally used for exception handling or intentional infinite loops (in both cases the function does not return from whence it came) … please correct me if I'm wrong here …
Re:Rust 1.100.0 by kibwen on Thursday November 12, 2026 @04:11PM (#50474336)
Basic use cases like that have always been possible in Rust, either via defining your own enum with zero variants (`enum Foo {}`), or by using a function return type of `!` which was hardcoded to work for certain things, e.g. infinite loops. What this release does is generalizes it so that `!` can participate in types in general, and the coolest part is that pattern matching is aware of this, so for example if you have a `Result<u8, !>` where the error variant is impossible, a `match` over this would allow you to omit the impossible error arm, and furthermore because this enum now effectively only has a single variant, it would allow you to use the pleasant irrefutable destructuring assignment syntax `let Ok(foo) = blah();`.
Re:Rust 1.100.0 by afdbcreid on Thursday November 12, 2026 @04:21PM (#50474464)
It has existed as a real type for a very long time (I believe in the beginning it really wasn't a real type but that's a long time ago), you just weren't allowed to name it. There was also an (unsupported) hack that allowed you to use it on stable.
Re:Rust 1.100.0 by anamexis on Thursday November 12, 2026 @02:26PM (#50472818)
Re:Rust 1.100.0 by LoganDark on Thursday November 12, 2026 @02:49PM (#50473171)
It's the type called "!", or the return value of diverging control flow, such as infinite loops, returns or function calls that panic or abort. It's an uninhabited type, meaning no values can actually exist, and that any code that would encounter such a value is unreachable.
Re:Rust 1.100.0 by Xirdus on Thursday November 12, 2026 @03:04PM (#50473385)
Mathematically, types are sets of possible values.

Any type (like in TypeScript; Rust doesn't have one) is a set of every possible value; a supertype of all types. Every expression regardless of type can be assigned to a variable of type any.

The opposite is the never type, which is an empty set; no value is of type never. Per set theory, an empty set is a subset of every set, which makes the never type a subtype of all types. An expression of type never can be assigned to every variable regardless of type.

If never type has no values, then how can an expression have never type? Easy: it must never evaluate. Infinite loops, unconditional panics/exceptions, process exit/abort, etc. Also, generics - you can have Vec<!> that's always empty, Result<T,!> that can never be an error, etc.

Re:Rust 1.100.0 by boston_clone on Thursday November 12, 2026 @03:29PM (#50473739)
[delayed]
Re:Rust 1.100.0 by rcxdude on Thursday November 12, 2026 @04:15PM (#50474393)
Rust does have https://doc.rust-lang.org/std/any/trait.Any.html but it's not quite the same thing (for one thing, it's not actually all types).
Re:Rust 1.100.0 by afdbcreid on Thursday November 12, 2026 @04:19PM (#50474437)
Also called top and bottom types, for this reason.
Re:Rust 1.100.0 by steveklabnik on Thursday November 12, 2026 @04:31PM (#50474591)
Any is not a top type and ! is not a bottom type, actually. They are sort of similar from a lay perspective if you squint, though.
Re:Rust 1.100.0 by afdbcreid on Thursday November 12, 2026 @05:00PM (#50474931)
Why not? I mean if you refer to Rust specifically, yes, because there is no subtyping except for lifetimes, only coercion (and `Any` also cannot contain any type). But in general, why not?
Re:Rust 1.100.0 by steveklabnik on Thursday November 12, 2026 @05:14PM (#50475106)
I am speaking about Rust specifically, yes.
Re:Rust 1.100.0 by NooneAtAll5 on Thursday November 12, 2026 @03:26PM (#50473700)
noreturn, basically
Re:Rust 1.100.0 by sixthDot on Friday November 13, 2026 @07:03AM (#50482311)
yeah aka the bottom type , but "never return" is inisde the type system (a bit like D handles that) while "noreturn" is an attribute. That's basically the two known possible ways of expressing that a call will never return.
Re:Rust 1.100.0 by yccs27 on Thursday November 12, 2026 @04:07PM (#50474283)
As in, values of this type can never actually exist.
Re:Rust 1.100.0 by saghm on Thursday November 12, 2026 @09:56PM (#50477553)
It's the type of what you get back from a `panic!` (a value you never actually get back).
Re:Rust 1.100.0 by dang on Thursday November 12, 2026 @03:22PM (#50473642)
Ok, we've moved the comments to https://news.ycombinator.com/item?id=50472038, which has that URL. Thanks!
Re:Rust 1.100.0 by steveklabnik on Thursday November 12, 2026 @01:51PM (#50472246)
A monumental release. Thanks to everyone who worked so hard on all of these long-term features that are finally landing.
Re:Rust 1.100.0 by caaqil on Thursday November 12, 2026 @07:24PM (#50476459)
Plaudits to all involved, as the sermon goes.
Re:Rust 1.100.0 by steveklabnik on Thursday November 12, 2026 @10:58PM (#50478091)
I know that's a meme but this actually is a really huge release.
Re:Rust 1.100.0 by hobofan on Thursday November 12, 2026 @02:00PM (#50472397)
Thanks to all the maintainers and contributors! That's one of the biggest releases in a long time!
Re:Rust 1.100.0 by fock on Thursday November 12, 2026 @02:27PM (#50472825)
also humans contributing! Very cool!
Re:Rust 1.100.0 by fluffiac on Thursday November 12, 2026 @02:03PM (#50472449)
yay never type!!

when can we expect `Result::into_ok` and `Result::into_err` to land? the blog post includes the `infallible_unwrap` demo which is the exact functionality these two functions implement. i wonder why they didn't release these at the same time as never?

Re:Rust 1.100.0 by NobodyNada on Thursday November 12, 2026 @02:07PM (#50472524)
Those were stabilized in https://github.com/rust-lang/rust/pull/161712, which just barely missed the cutoff date for 1.100 and is on the 1.101 release train.
Re:Rust 1.100.0 by saghm on Thursday November 12, 2026 @09:58PM (#50477572)
The six week release cadence means that stuff like this is not a huge deal, and it's honestly kind of insane how consistent it's been over what's now 100 minor releases over 11 years!
Re:Rust 1.100.0 by Surac on Thursday November 12, 2026 @02:16PM (#50472661)
Still non ABI. Why is ist so hard? what is holding them back. Andy why does it need a unsave keyword? can't they marshal types like other languages?
Re:Rust 1.100.0 by adamch on Thursday November 12, 2026 @02:18PM (#50472696)
because they change the binary layout sometimes, and the benefits have not yet been judged to be worth freezing it.
Re:Rust 1.100.0 by vablings on Thursday November 12, 2026 @05:25PM (#50475233)
I mean they could also have a stable ABI for 2.0 and then and changes are breaking herein. Its kind of a choice problem
Re:Rust 1.100.0 by galangalalgol on Thursday November 12, 2026 @03:30PM (#50473765)
It is explained elsewhere, but a summary is that any language with generics is going to have any stable abi as a subset of the language. There is already a subset of the language that is a stable abi, it is the c abi. Expanding that subset has to be worth it in terms of what people actually want to export from a library. As I use generics fairly heavily I don't think I would use that expanded abi for anything.
Re:Rust 1.100.0 by kbolino on Thursday November 12, 2026 @04:02PM (#50474227)
You can marshal values, but you can't marshal lifetimes, ownership, (lack of) thread-safety, (lack of) side-effects, etc. The ABI carries far less information than the Rust compiler relies on. Thus, any FFI call is inherently unsafe. It takes you, the programmer, with knowledge the compiler doesn't have and the architecture doesn't provide, to determine whether the code as you use it actually is safe or not.
Re:Rust 1.100.0 by ammar_az on Thursday November 12, 2026 @02:22PM (#50472758)
This release is so big that multiple useful stabilized API aren't event mentioned in the blog post like:

- bool::toggle() https://doc.rust-lang.org/stable/std/primitive.bool.html#met...

- Box::map() https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#m...

- str::trim_prefix(), str::trim_suffix, Path::trim_prefix()

Re:Rust 1.100.0 by afdbcreid on Thursday November 12, 2026 @02:32PM (#50472917)
They are mentioned in the blog post, under "Stabilized APIs".
Re:Rust 1.100.0 by jacksontheel on Thursday November 12, 2026 @04:58PM (#50474903)
I'm at a loss with the bool toggle method. Why would x = !x not be good enough?
Re:Rust 1.100.0 by stusmall on Thursday November 12, 2026 @05:01PM (#50474949)
You can. Something like toggle is nice because it is very clear at a glance. That's a subjective style call.

But under the hood it's all the same https://doc.rust-lang.org/stable/src/core/bool.rs.html#157-1...

Re:Rust 1.100.0 by rauli_ on Thursday November 12, 2026 @05:34PM (#50475354)
For someone who has decades of experience from other programming languages this does not look clear to me at all but rather confusing. Calling an method can change value of variable of primitive type?
Re:Rust 1.100.0 by ninkendo on Thursday November 12, 2026 @06:01PM (#50475651)
[delayed]
Re:Rust 1.100.0 by Groxx on Thursday November 12, 2026 @06:13PM (#50475769)
[delayed]
Re:Rust 1.100.0 by pjmlp on Friday November 13, 2026 @12:58AM (#50478928)
Eiffel or Smalltalk are two languages, among others I could chose from, where primitives and others types are differently implemented, yet unless you dive into the nitty gritty details, they look exactly the same to the developer as the compiler handles them exactly the same, and there are no extension methods to be seen.
Re:Rust 1.100.0 by kragen on Friday November 13, 2026 @07:07AM (#50482354)
However, it would be impossible to implement a #toggle method in Smalltalk that behaves like this, because you're calling it on the singleton True (or False) object; Smalltalk local variables, like Lisp variables, are references to objects rather than objects themselves.

(You obviously know this, but it might be a surprise to many people reading this thread.)

Re:Rust 1.100.0 by pjmlp on Friday November 13, 2026 @08:45AM (#50483394)
Yes, but that is orthogonal how primitives and reference types get exposed to the developer.

Something like toggle is also impossible in languages that favour immutability and forward progress requires creating new variables, like several functional and logic languages.

Re:Rust 1.100.0 by kragen on Saturday November 14, 2026 @07:15AM (#50496432)
Agreed.
Re:Rust 1.100.0 by zdimension on Thursday November 12, 2026 @06:04PM (#50475695)
When you call a method on something in Rust, the method gets passed that something (as a parameter called self). But the method gets to choose whether it's by move/copy or by reference. Here, toggle gets the bool passed by mutable reference.

In effect, if x is a bool, doing x.toggle() is rewritten by the compiler as bool::toggle(&mut x), which can of course modify x.

Re:Rust 1.100.0 by scott_w on Thursday November 12, 2026 @06:05PM (#50475702)
Why wouldn’t it be possible? The distinction in modern languages between primitive and not is an arbitrary one when it comes to stuff like this.
Re:Rust 1.100.0 by stusmall on Thursday November 12, 2026 @07:07PM (#50476306)
The big clue that'll jump out to any rust dev is the type signature:

pub const fn toggle(&mut self)

The "&mut" says that toggle takes a mutable reference to the instance it is called off of. This is also called a mutable borrow. You might thing that would get buried in the program because you don't always check the type signature of every method you call, but there are a few reasons that muts really jump out in rust. The languages immutable by default nature is one and the other is that several IDE have features to specifically draw attention to mutable instances/references. It's a fairly common pattern in rust to have helper methods on a type that take a mutable reference or ownership of self.

TL;DR: Rust's ownership model is very unique. Once it clicks its the cat's pajamas, but experience in other languages don't map well to this part of the language.

Re:Rust 1.100.0 by throwaway2037 on Thursday November 12, 2026 @07:26PM (#50476466)

    > decades of experience from other programming languages
What languages?
Re:Rust 1.100.0 by adastra22 on Thursday November 12, 2026 @08:54PM (#50477092)
Most (not all) static & ahead-of-time compiled languages. C++ and Java come to mind. Method calls on built-in primitive types is more of a dynamic language thing (think: ruby, python) that got extended into compiled languages in recent memory.
Re:Rust 1.100.0 by rtpg on Thursday November 12, 2026 @07:39PM (#50476592)
C++ lets you do this kind of stuff as well.

Primitive types and composite types having the same capabilities is a bit of a value statement for C++ and Rust IMO, and it's missing in a lot of languages downstream (IMO) of the "every variable is a reference to a slot/pointer" philosophy taken by most every managed language

Re:Rust 1.100.0 by tialaramex on Thursday November 12, 2026 @09:02PM (#50477141)
C++ doesn't have methods/ "member functions" on the primitive types.

One reason is that C++ doesn't know where to put them, for user defined class, struct or union types these "member functions" as their name suggests live inside the class/ struct/ union definition but for a primitive where would these live?

In Rust they're just impl blocks, for example the method we're discussing here is:

    impl bool {    
        pub const fn toggle(&mut self) {
            *self = !*self;
        }
    }
Re:Rust 1.100.0 by pjmlp on Friday November 13, 2026 @01:02AM (#50478960)
Only because Unified Call Syntax is yet to land into the language, after several failed attempts.
Re:Rust 1.100.0 by aw1621107 on Friday November 13, 2026 @01:37AM (#50479252)
And I think there's a decent chance that it never will, at least in the form it has been proposed in in the past (i.e., member function syntax being effectively turned into free function calls). P3027 "UFCS is a breaking change, of the absolutely worst kind" [0] argues quite strongly that that particular form of UFCS is basically completely broken.

[0]: https://isocpp.org/files/papers/P3027R0.html

Re:Rust 1.100.0 by pjmlp on Friday November 13, 2026 @01:57AM (#50479399)
As WG21 goes, it is a matter of advocacy, persistency, and getting the required votes in the room, at least if the process doesn't change even with how C++26 contracts turned out to be.
Re:Rust 1.100.0 by aw1621107 on Friday November 13, 2026 @03:27AM (#50480137)
I mean, sure, but that's basically a tautology since that's how everything made it into the standard into the first place. Those are necessary but not sufficient conditions.
Re:Rust 1.100.0 by pjmlp on Friday November 13, 2026 @03:51AM (#50480326)
Not really, in first place it was basically CFront 2.0, alongside C++ARM akin to the K&R C book, with last minute addition of HP STL implementation.

The only piece that wasn't really available and was made in a waterfall design approach was export templates, with the known outcome that no one other than EDG has even bothered implementing it.

Post C++98 is when we got into the "advocacy, persistency, and votes" strategy.

Re:Rust 1.100.0 by aw1621107 on Friday November 13, 2026 @02:14PM (#50488330)
You still needed "advocacy, persistency, and votes" to get stuff into C++98. It's just that some things need a lot more of the former to get the latter than others.
Re:Rust 1.100.0 by tialaramex on Friday November 13, 2026 @04:23AM (#50480606)
I'm with you on this and would point at std::hive as an example of the results.
Re:Rust 1.100.0 by kibwen on Thursday November 12, 2026 @07:45PM (#50476631)
In addition to what the sibling commenters have written, in order for this to compile, the variable would need to be declared as mutable.
Re:Rust 1.100.0 by worik on Thursday November 12, 2026 @08:00PM (#50476742)
> Calling an method can change value of variable of primitive type?

So long as the variable is mutable it's value can be changed

Re:Rust 1.100.0 by crabmusket on Thursday November 12, 2026 @08:11PM (#50476812)
I guess you're experiencing the feeling a mathematician gets when seeing a line like

x = x + 1

Re:Rust 1.100.0 by nicoburns on Thursday November 12, 2026 @08:47PM (#50477051)
What may be surprising to you coming from other languages, is that primitive types in Rust have their own methods! So methods applying to primitives is not unusual at all in Rust.
Re:Rust 1.100.0 by jason_oster on Thursday November 12, 2026 @09:06PM (#50477170)
Think of having the method for AtomicBool, where you are forced to call methods for all value accesses. `atomic_bool.toggle(Ordering::SeqCst)` would read much better than `atomic_bool.fetch_xor(true, Ordering::SeqCst)`.
Re:Rust 1.100.0 by saghm on Thursday November 12, 2026 @09:40PM (#50477417)
Not quite; the method uses `&mut self`, so it actually operates on a mutable reference to the value that happens to be a primitive. If you declare a boolean without specifying the binding as mutable, you'd get a compiler error from trying to call this method. Moreover, if anything else had a reference to it at the same time, it would also cause a compiler error to call this method.

This is definitely something that Rust does a bit different than most other languages, but it's not anything specific to this method, booleans, or particularly new to the language. Most people will learn about the common different ways of defining a method (via ownership, shared reference, or mutable reference) fairly early on in programming Rust.

Re:Rust 1.100.0 by torginus on Friday November 13, 2026 @09:00AM (#50483601)
I think a major issue in all OOP languages is determining which operation mutates and which does not, and often having both operations, or even worse, if there's a third, static method. This is redundant and creates opportunity for code style divergence.

An example would be having both `Vector3.Add` and `Vector3.AddToSelf` instance methods as well as third `Vector3::Add` which takes two Vector3s.

Re:Rust 1.100.0 by dxxvi on Thursday November 12, 2026 @07:15PM (#50476386)
Is x = !x faster than x.toggle() because from my naked eyes no function is called? Or does the compiler know that the function toggle should be replace with `!=`? If the compiler does know that, how is that knowledge implemented? Is there a table of special functions that should be replaced with something else? Or some more clever way?
Re:Rust 1.100.0 by lern_too_spel on Thursday November 12, 2026 @07:24PM (#50476454)
Re:Rust 1.100.0 by kibwen on Friday November 13, 2026 @08:28AM (#50483199)
In this case the inline attribute probably isn't strictly necessary, because rustc heuristically inlines any functions that it deems trivial enough.
Re:Rust 1.100.0 by tialaramex on Thursday November 12, 2026 @08:53PM (#50477088)
Thanks to Matt Godbolt, we can ask Compiler Explorer!

https://rust.godbolt.org/z/dPn3Y4r59

The optimizer gives the exact same machine code for both functions, and so it just outputs a single function and gives it an alias.

The compiler has a technique called "inlining" https://en.wikipedia.org/wiki/Inline_expansion

The LLVM backend used by Rust is jokingly said to have a inlining heuristic of "yes" ie it will always try to inline everything because that's usually faster.

Re:Rust 1.100.0 by xiej on Thursday November 12, 2026 @09:13PM (#50477207)
Unfortunately it's not inlined in debug/no optimization mode so that's rough.
Re:Rust 1.100.0 by saghm on Thursday November 12, 2026 @09:43PM (#50477428)
I'll go out on a limb and hypothesize that there are going to be much larger difference between debug and release mode for any non-trivial code that the overhead of `toggle` in debug mode will quite literally never end up mattering to anyone in practice.
Re:Rust 1.100.0 by lanyard-textile on Friday November 13, 2026 @03:45AM (#50480291)
Why should it be? That's a feature of debug.
Re:Rust 1.100.0 by brabel on Friday November 13, 2026 @02:44AM (#50479763)
My first thought was that this is useful when you need a lambda that does this, now you can use ::toggle
Re:Rust 1.100.0 by masklinn on Friday November 13, 2026 @05:25AM (#50481307)
Now I just need the integer types to gain in-place inc() and dec()

I don’t know how to feel about toggle returning neither old nor new value tho.

Re:Rust 1.100.0 by SkiFire13 on Friday November 13, 2026 @07:30AM (#50482584)
You could do `bool::not` before, but this is clearer and doesn't require imports.
Re:Rust 1.100.0 by CUViper on Friday November 13, 2026 @01:58PM (#50488096)
`bool::not` returns the value, while `bool::toggle` is more like a `not_assign`.
Re:Rust 1.100.0 by kragen on Friday November 13, 2026 @07:03AM (#50482322)
I feel like `x = !x;` is clearer than `x.toggle();` because I know the definition of `!` and until two minutes ago I didn't know the definition of `.toggle()`. The lambda answer below is a lot more convincing.
Re:Rust 1.100.0 by IshKebab on Thursday November 12, 2026 @05:06PM (#50474996)
If you access the bool through a long path maybe.

  foo.bar().baz[expensive()].qux.toggle();
Re:Rust 1.100.0 by jacksontheel on Thursday November 12, 2026 @05:33PM (#50475337)
Alright, I'm convinced, that makes a lot of sense.
Re:Rust 1.100.0 by Sharlin on Friday November 13, 2026 @02:46AM (#50479791)
You can of course also do

  long_path_bool ^= true;
but that’s less obvious.
Re:Rust 1.100.0 by ammar_az on Thursday November 12, 2026 @05:38PM (#50475403)
That's the main reason for me as well
Re:Rust 1.100.0 by crabmusket on Thursday November 12, 2026 @08:59PM (#50477118)
This gives me the same feeling as when I saw Rust's map Entry API

https://doc.rust-lang.org/std/collections/hash_map/enum.Entr...

    let mut map: HashMap<&str, u32> = HashMap::new();
    map.entry("poneyland").or_insert(3);
    assert_eq!(map["poneyland"], 3);
It's very ergonomic.
Re:Rust 1.100.0 by voxelghost on Friday November 13, 2026 @02:50AM (#50479827)
cant you just do

    foo.bar().baz[expensive()].qux ^= true;
Re:Rust 1.100.0 by IshKebab on Friday November 13, 2026 @03:43AM (#50480275)
Sure, but should you?
Re:Rust 1.100.0 by voxelghost on Sunday November 15, 2026 @11:52PM (#50514174)
[delayed]
Re:Rust 1.100.0 by kibwen on Thursday November 12, 2026 @05:06PM (#50475001)
Proposal here: https://github.com/rust-lang/libs-team/issues/820

Looks like part of the motivation was for things with long names like `some_struct_a.some_field_b.some_subfield_c`, where needing to name the field twice would have pushed people to using `^= true` instead, which is a bit more roundabout to decipher and risks people forgetting the idiom and writing `^= false` by accident. Not necessarily the most useful API, but not unmotivated and harmless to add.

Re:Rust 1.100.0 by ammar_az on Thursday November 12, 2026 @05:40PM (#50475432)
I think `toggle()` is also much better for readability as `^=true`
Re:Rust 1.100.0 by thayne on Thursday November 12, 2026 @09:26PM (#50477313)
If you have a (&must) reference it would actually be x = !x. Also toggle is a function that can be passed to higher order functions without needing a lambda. For example, if you have a boolean in an option you can do opt.iter_mut().for_each(book::toggle). Or similar if you had a collection of booleans.
Re:Rust 1.100.0 by saghm on Thursday November 12, 2026 @09:36PM (#50477387)
If you're dealing with something like an `Option<bool>` or `Vec<bool>`, it might be nice to avoid needing to do a more verbose dereference and assign:

    let mut vec = vec![false, false, false, false];
    vec[2].toggle();
    *vec[2] = !vec[2];
"Good enough" is subjective, but I personally prefer the new way
Re:Rust 1.100.0 by pasteleft on Thursday November 12, 2026 @09:55PM (#50477539)
I think they made it to reduce closure usage.

  vec.map(|x| !x);

  vec.map(bool::toggle);
Re:Rust 1.100.0 by adwn on Friday November 13, 2026 @01:59AM (#50479414)
No, these aren't equivalent: the second line mutates the iterated-over values, while the first doesn't. And the first line returns an iterator over bool, while the second returns an iterator over ().
Re:Rust 1.100.0 by viktorcode on Friday November 13, 2026 @04:36AM (#50480755)
When a similar thing was introduced to Swift it too raised a lot of heated discussions. Somehow, people became extremely passionate about this little extension.

Fast forward to today. After years of using it I find it very good for readability. It became the default in codebases. Nobody complains anymore and absolutely no one is confused.

Re:Rust 1.100.0 by pasteleft on Thursday November 12, 2026 @10:08PM (#50477648)
Wow even slices support trim_prefix and trim_suffix
Re:Rust 1.100.0 by nialv7 on Friday November 13, 2026 @10:25AM (#50484918)
Box::map is cool, there are a bunch of crates filling this gap, guess I can ditch those now.
Re:Rust 1.100.0 by unstruktured on Friday November 13, 2026 @01:46PM (#50487939)
Mildly surprised that Box::map wasn't there on day one.
Re:Rust 1.100.0 by KolmogorovComp on Thursday November 12, 2026 @02:40PM (#50473038)
I haven’t seen any blog on the topic but I fully believe in the age of coding agents and LLM backward compatibility is a bit less important than it has been in the past and should be relaxed in some cases to allow language to move faster.
Re:Rust 1.100.0 by raphlinus on Thursday November 12, 2026 @03:15PM (#50473513)
I get your point but disagree strongly. One topic that's been on my mind a lot is durability. The culture of LLMs is that everything is transitory. Why bother keeping a vibe coded codebase around for more than a few weeks, when the next big model iteration will be able to vibe code it better?

By contrast, free software in general, and Rust very much in particular, has cultural norms that things should last a while, rather than immediately being thrown away. I think that's worth preserving.

Re:Rust 1.100.0 by jadbox on Thursday November 12, 2026 @02:48PM (#50473144)
Is the compiler any faster now? Compiling takes forever. I'm also tired of always having to do "cargo clean" everyday to clear out 90gb of temp files.
Re:Rust 1.100.0 by vlovich123 on Thursday November 12, 2026 @02:53PM (#50473219)
Any faster vs what baseline? They’ve constantly made improvements and Rust today is pretty darn quick, especially for incremental. There’s work to parallelize the front end which will help a little bit and you can always use the cranelift backend for debugging which is substantially faster than LLVM.

They’re also doing work to reduce the amount of disk space usage (by clearing out unused articacts) and make it easier to maintain.

Re:Rust 1.100.0 by jtwaleson on Thursday November 12, 2026 @03:42PM (#50473963)
Best to do some benchmarks for cranelift on your codebases and system. It used to be quite a lot faster, but for me the advantage has disappeared over the last year of Rust improvements.
Re:Rust 1.100.0 by steveklabnik on Thursday November 12, 2026 @02:53PM (#50473220)
Compiler speed is continually being worked on https://nnethercote.github.io/2026/11/04/how-to-speed-up-the...

And the large target directories is also being worked on as well.

Re:Rust 1.100.0 by throwaway27448 on Thursday November 12, 2026 @03:00PM (#50473330)
I don't understand why people complain about this non-stop. If compilation time is such an issue use a different language. I can't say I've been bottlenecked by compilation in a very long time.
Re:Rust 1.100.0 by IshKebab on Thursday November 12, 2026 @05:10PM (#50475055)
I don't think you can tell people not to complain about it - it is clearly very desirable to have faster compilation, like Zig or Go.

But that said I do agree it is pretty fast these days. Significantly faster than C++ and people have tolerated that for decades.

Re:Rust 1.100.0 by throwaway27448 on Thursday November 12, 2026 @07:13PM (#50476364)
[delayed]
Re:Rust 1.100.0 by epage on Thursday November 12, 2026 @03:03PM (#50473366)
Faster compile and smaller build-dir can be at odds with each other.

That said, this release doesn't include anything more than incremental improvements.

Some changes that have been or are about to be merged for upcoming releases

- We will be reducing the debug info generated for the `dev` profile which reduces build-dir size and speeds up builds. We've split off a `debug` profile for when that is needed.

- Cargo will be deleting the directory rustc writes before each invocation, avoiding the leaking of debug files when split-debug is enabled (default on Mac)

- rlibs for workspace members will no longer be copied from build-dir to target-dir which takes up extra space on systems without hardlinking or where we skip it (like Mac)

- redundant information in rlibs and rmeta's is going to be de-duplicated

Examples of further out changes

- This release includes the foundational work to add a build-dir GC

- Cross-workspace de-duplicating of build-dirs

- Cross-workspace build-dir cache

- Early cut off

Re:Rust 1.100.0 by iknowstuff on Thursday November 12, 2026 @03:58PM (#50474178)
Also

“Relink, don't rebuild” #790

https://github.com/rust-lang/compiler-team/issues/790

Re:Rust 1.100.0 by mohamedkoubaa on Thursday November 12, 2026 @04:50PM (#50474818)
Ive always wondered why this wasn't an option from the beginning
Re:Rust 1.100.0 by epage on Thursday November 12, 2026 @07:41PM (#50476603)
To do it right you need

- stable id's even when the source changes

- a separate output file dedicated to it so you hash that

Those aren't free, taking extra work to implement and possibly slow down the compiler

Re:Rust 1.100.0 by epage on Thursday November 12, 2026 @07:42PM (#50476610)
Note that this is a special form of early cut off (which was listed) where you are hashing a more specialized output file, rather than a broader one.
Re:Rust 1.100.0 by pjmlp on Thursday November 12, 2026 @04:31PM (#50474587)
Thanks for the list, looking forward to those improvements.
Re:Rust 1.100.0 by small_model on Thursday November 12, 2026 @03:34PM (#50473821)
Yes this is why I switched to Go for backend, much faster compiling and performance isn't an issue for the application yes using 100GB+ is just bad tooling.
Re:Rust 1.100.0 by arl79 on Friday November 13, 2026 @04:46AM (#50480858)
Not only is the compiler very slow, but maintaining the code is slower too. No single tool is right for everything. To me, Rust is definitely not a general-purpose language. It only makes sense for workloads where the ratio of execution time to dev/compile time is heavily skewed toward running the code.
Re:Rust 1.100.0 by kibwen on Friday November 13, 2026 @08:39AM (#50483318)
Nah, compared to other languages, the strictness of Rust makes maintaining codebases a joy. Like, I love Python, but maintaining a large Python codebase is a source of constant anxiety. The Rust compiler actually feels like it has your back.
Re:Rust 1.100.0 by amelius on Thursday November 12, 2026 @03:36PM (#50473866)
There's really a paradox here. Rust claims to be a fast language, but compiling, even without optimizations on, takes ages ...
Re:Rust 1.100.0 by kibwen on Thursday November 12, 2026 @04:15PM (#50474395)
There's no paradox here. You can use any benchmark you like to prove that Rust is a fast language. The work that the compiler does is irrespective of the language that rustc is written in.
Re:Rust 1.100.0 by amelius on Thursday November 12, 2026 @04:20PM (#50474456)
Yes, the benchmark is compiler compiling itself. From scratch and incrementally.
Re:Rust 1.100.0 by kibwen on Thursday November 12, 2026 @05:14PM (#50475110)
Unfortunately, that isn't how any of this works.
Re:Rust 1.100.0 by IshKebab on Thursday November 12, 2026 @05:08PM (#50475022)
That's not a paradox, that's how it always works. Compiling to fast machine code requires more work and takes longer.

Is Python a fast language because it barely takes any time to compile the code? No obviously not.

Re:Rust 1.100.0 by amelius on Thursday November 12, 2026 @05:13PM (#50475088)
You missed "without optimizations on".

This is important, because most often during development you want fast compilation times more than you want fast code.

Re:Rust 1.100.0 by afdbcreid on Thursday November 12, 2026 @05:48PM (#50475517)
That still isn't a paradox. Furthermore it still makes sense: a language designed to generate the fastest code has constructs that cannot be compiled quickly, even without optimizations.

But some of it is implementation problems.

Re:Rust 1.100.0 by adastra22 on Thursday November 12, 2026 @09:25PM (#50477296)
Rust's compilation speed issues are not due to optimizations. There is some intrinsic slowness, but also some boneheaded decisions that are now baked in. E.g. the unit of compilation being the crate, not file/module, makes it so you hit some bad scaling laws. And the borrow checker is SLOW, and unavoidably so, but borrow checking could have been avoided with different lifetime rules. Etc.

I say this as a full-time rust developer btw.

Re:Rust 1.100.0 by aw1621107 on Thursday November 12, 2026 @09:53PM (#50477513)
> And the borrow checker is SLOW, and unavoidably so

IIRC for most codebases borrowck actually makes up a pretty small proportion of compilation time (e.g., see [0] for some admittedly rough estimates).

> but borrow checking could have been avoided with different lifetime rules.

I'm not sure you could entirely avoid borrow checking without a pretty significant change to what you're allowed to do with references.

[0]: https://kobzol.github.io/rust/rustc/2024/03/15/rustc-what-ta...

Re:Rust 1.100.0 by afdbcreid on Friday November 13, 2026 @09:07AM (#50483699)
Rust is indeed not designed for quick compilation. Furthermore and unlike what you said, what makes it memory safe has pretty little to do with that. But what makes it fast definitely has to do with that, which is what I said.
Re:Rust 1.100.0 by Matrixik on Thursday November 12, 2026 @06:34PM (#50475965)
Looks like people extending rust never really focused on compile speed when designing features (from [1]):

> If you could reinvent/change any aspect of Rust, what would you do alternatively?

> A lot happened because we wanted to ship a useful thing with only so much time in the day, so some things were less deliberate than others. There’s an alternate version of Rust with significantly faster compiler times, because while we cared about compile times when designing we always prioritized other values more. We never asked ourselves how this feature or implementation impacted compiler analysis time and there are several spots where something slightly different would have much faster compiler times, which people do care about. But had we spent time on that, we would have neglected other things and not been any more successful.

[1]: https://alexalejandre.com/interviews/interview-with-steve-kl...

Re:Rust 1.100.0 by barchar on Thursday November 12, 2026 @05:09PM (#50475038)
Rust encourages a kind of generic programming that can result in generating too much code.

The compilation model is vastly, vastly, vastly better than languages like C++ and C, though, and it does compile much faster than an equivalent C++ build (doesn't count if you download precompiled binaries of your c++ dependencies)

Re:Rust 1.100.0 by cozzyd on Thursday November 12, 2026 @07:37PM (#50476562)
But the lack of ABI stability means that's not a choice anyway, doesn't it?
Re:Rust 1.100.0 by SAI_Peregrinus on Thursday November 12, 2026 @08:08PM (#50476788)
Rust can compile to dynamic libraries. If you don't use the C abi you have to compile anything that loads them with the same Rust compiler version and target triple. So you need to have some way to guarantee the correct compiler is being used, e.g. Nix or Bazel.
Re:Rust 1.100.0 by cozzyd on Thursday November 12, 2026 @09:32PM (#50477358)
And possibly compilation options?
Re:Rust 1.100.0 by saghm on Thursday November 12, 2026 @09:45PM (#50477444)
Have you been similarly confused by how slow compiling can be for massive C++ projects for decades? I have trouble believing that you genuinely think that's what anyone means by saying Rut is fast.
Re:Rust 1.100.0 by pjmlp on Friday November 13, 2026 @01:11AM (#50479043)
In C++ case usually is the outcome of compiling everything from source, not using binary libraries for dependencies, binary caching, pre-compiled headers, incremental compilation and linking.

Some of the items tend to be rather sub-optimal in UNIX based C++ compilers.

Using Visual C++ or C++ Builder with pre-compiled headers, or modules nowadays, working only on the main application, with everything else compiled as DLLs, COM, or packages (C++ Builder specific), incremental compiler, incremental linking, hot code reloading, is rather fast for the typical compile-debug-fix workflow.

Re:Rust 1.100.0 by saghm on Friday November 13, 2026 @01:18PM (#50487516)
The comment I responded to said "Rust claims to be a fast language, but compiling, even without optimizations on, takes ages". I agree that if you skip compiling and just reuse stuff that was already compiled, then the time it takes to compile C++ is fast, but that's not really what was being discussed.
Re:Rust 1.100.0 by aw1621107 on Thursday November 12, 2026 @09:59PM (#50477583)
> Rust claims to be a fast language, but compiling, even without optimizations on, takes ages ...

As usual, this begs the question of "compared to what"? "Fast" languages obviously don't have some magical ability to guarantee that every program written in them is Blazing Fast(tm); without further inspection one can come to any number of other equally plausible conclusions (e.g., the program is fast for what it does).

Re:Rust 1.100.0 by 0o777 on Thursday November 12, 2026 @03:44PM (#50473997)
All the big AI companies use Rust so this is probably something they should focus on improving.
Re:Rust 1.100.0 by panstromek on Thursday November 12, 2026 @03:56PM (#50474157)
They do fund some of these efforts, yes.
Re:Rust 1.100.0 by eptcyka on Thursday November 12, 2026 @03:58PM (#50474184)
On macOS there is a known bug where some temp files are always created anew, not reused, which slows down compilation and wastes more space than other platforms.
Re:Rust 1.100.0 by epage on Thursday November 12, 2026 @04:12PM (#50474348)
Fixed on nightly.
Re:Rust 1.100.0 by adastra22 on Thursday November 12, 2026 @09:19PM (#50477253)
Do you have details? I think I'm running into this.
Re:Rust 1.100.0 by epage on Thursday November 12, 2026 @11:29PM (#50478341)
Re:Rust 1.100.0 by kennykartman on Thursday November 12, 2026 @04:25PM (#50474512)
You might be interested in this: https://news.ycombinator.com/item?id=50458849 - I didn't try it yet, though.
Re:Rust 1.100.0 by shevy-java on Thursday November 12, 2026 @04:55PM (#50474869)
Well, the AI that slops out Rust code won't mind having to wait!
Re:Rust 1.100.0 by jodrellblank on Thursday November 12, 2026 @10:48PM (#50478000)
I dunno why you think your constant comments like this are good quality or interesting reading but can you stop with the one liner “slop slop slop XD XD XD” shitposting please?
Re:Rust 1.100.0 by barchar on Thursday November 12, 2026 @05:05PM (#50474991)
try disabling at least some debug-info for your dependencies.

use cargo's --timings option to identify the slow crates, then use measureme to figure where rustc is spending time.

try fiddling with detached debug-info, dwp files can be smaller than their constituent dwo files.

ensure really small "template wrappers" are inlined.

lower the number of compilation-units you use.

For incremental builds I have found it can _sometimes_ be effective to split out larger dependencies into a dynlib. You create a dylib crate that re-exports said dependencies and your executable depends on that. Ofc things like generics from the offending libraries will still end up in your executables; Though I think there is a way to mitigate this a little.

This mostly helps with link-time, and saving space if you have a bunch of executables (using the argv[0] trick will help more, though).

Re:Rust 1.100.0 by benjiro29 on Thursday November 12, 2026 @05:45PM (#50475488)
Is the compiler any faster now?

If your codebase is not some small project, its excruciating slow. Even if you try different linkers, and other compilers, nothing really make incremental compiles eat so much of your system. Even more so if you have multiple AI agents doing security and other checks.

Switched to Go for several months, and the difference was very noticeable. Until you started to get there also 50k+ files that are interlinked. And let us not talk about Go and Rust their issues with insane amount of debug/cache buildup.

Imaging if you have 4 to 6 agents running that, with each seeing the cache grow from 20, 30, 40 ... To the point that a 100/1000GB SSD grows to 800, 900GB usage. Often in barely a day.

Seen my NVME drive its lifespan drop from 98% to 91% in barely a few month time. I dread looking at it again lol

What was the solution? Going back to C ... Despite right now working on a 800k lines project, it compiles way faster the Go, and well, Rust will have pegged all 16 cores for a minute, for EACH agent trying to recompile on a small change.

Memory safety? Instead of checking at compile time, and wasting my time, this has simply been moved to AI agents checking, making tools, checking, at night. So it does not disturb my own work.

Its ironic, how both modern projects, end up being worse off. Best of all, the C project is way faster then the same project in Go and Rust. Yea, it was "fun" having AI transcompile them twice but the difference on actual large codebase, and not some micro benchmarks is not a joke. To the point that now all my projects have gone back to C...

And yea, i expect some fast downvotes by our Rust friends because saying something negative about Rust always gets people downvoted here. No offence but Rust being linked to LLM and the whole checker was a benefit before AI came around. But now you can offload a lot of safety checks to the backend/offhours, instead of paying for it with every compile.

Re:Rust 1.100.0 by benjiro29 on Friday November 13, 2026 @08:46AM (#50483407)
Thanks for proving my point. Every time there is some criticism of Rust, some people can not help downvoting because they associate their being with a programming language. Such odd behavior...
Re:Rust 1.100.0 by amenhotep on Friday November 13, 2026 @12:09PM (#50486476)
I downvoted this post for complaining about downvotes, and, after you called attention to it, went back and downvoted the previous post for preemptively complaining about downvotes. Hope that helps.
Re:Rust 1.100.0 by pdimitar on Saturday November 14, 2026 @12:53AM (#50494407)
IME you're optimizing for the wrong thing and are taking myopic and short-term-pleasure measures.

I too grind my teeth when programs are slow, especially compilers, but Rust has saved my hide enough times that I accept the slowness of the compiler / linker stack as a necessary price for the peace of mind once the program runs in production.

Plus, they're working on it all the time. Too slow for my taste? Definitely. But it's still okay.

...And stop blaming downvotes on Rust criticisms. You're 10x more likely to get downvoted for attacking an imaginary group or generally sounding like you're flaming.

I found your comment interesting almost until the end, and then I rolled my eyes hard at the final part. Just don't. Keep criticisms informed and you'll get much more interesting replies and reactions.

Seriously. Try it.

(And don't double down on a victim complex either; i.e. your smaller comment under the bigger one.)

Re:Rust 1.100.0 by flykespice on Thursday November 12, 2026 @08:06PM (#50476771)
What the hell are you doing to produce 90gb of temp files? Is that normal on rust land?
Re:Rust 1.100.0 by kstrauser on Thursday November 12, 2026 @09:13PM (#50477211)
No. My target directory is 329GB at the moment. I wish mine were just 90GB.

(And yet I’m perfectly happy running `cargo clean` periodically in exchange for all the Rust loveliness. Sure, I wish I didn’t need to. Sure, I hope it’ll get better. I can live with the temporary inconvenience though.

Also, I’m developing in a tight auto-build-on-commit loop so I have a gazillion builds.)

Re:Rust 1.100.0 by soon_to_be_sb on Thursday November 12, 2026 @11:41PM (#50478432)
Yea, I was thinking the same. 90gb is not that big. Last week I cleared 130gb out of the target dir.
Re:Rust 1.100.0 by simonask on Friday November 13, 2026 @03:44AM (#50480284)
These numbers are totally insane. I've never seen a Rust project with a build cache this large.

Do you have 10 different versions of Tokio included in your project or something?

The project I'm currently working on is quite large, and it's locally cross-compiled to 5 different arch/OS combinations, plus a debug build for the local machine. The build dir is 9.1 GB. I've seen it grow to somewhere around 20 GB, but only after a significant number of dependencies were updated, or the compiler version changed.

A clean debug build of Bevy (a game engine, one of the largest Rust projects around) produces a target dir of around 13 GB. By the way, rebuilding Bevy on my machine takes about 1 minute.

Now, these numbers are still much bigger than I would have preferred, but 329 GB? Get out of here.

Re:Rust 1.100.0 by slopinthebag on Sunday November 15, 2026 @05:29AM (#50505755)
i had a bevy project with a +500gb build folder. i occasionally get out-of-memory warnings and that reminds me to run cargo clean

but i think this is a macos-specific bug that is getting fixed

Re:Rust 1.100.0 by flykespice on Friday November 13, 2026 @07:47AM (#50482749)
329gb?? That is larger than my entire SSD storage.

It would be more believable if you told me you were making your own GTA VI

Re:Rust 1.100.0 by adastra22 on Thursday November 12, 2026 @09:18PM (#50477248)
It's large but not insane. I've got 20gb in a not-too-large repo.
Re:Rust 1.100.0 by a96 on Friday November 13, 2026 @04:49AM (#50480891)
That is frankly insane IMO. 20 MB would be insane unless there's massive libraries or something. 20 GB is the size of a very fat graphical operating system.
Re:Rust 1.100.0 by flykespice on Friday November 13, 2026 @10:10AM (#50484688)
I think even Gradle produce much less cache files...
Re:Rust 1.100.0 by p2detar on Friday November 13, 2026 @12:23PM (#50486663)
[delayed]
Re:Rust 1.100.0 by mixmastamyk on Friday November 13, 2026 @03:40PM (#50489343)
It’s Windows 10 install storage requirement.
Re:Rust 1.100.0 by adastra22 on Friday November 13, 2026 @09:58PM (#50493284)
Exactly, yes. My project uses a GUI framework developed as part of a graphical operating system written in rust. Cargo fetches quite a big subset of that graphical OS in order to build this dependency, which is statically compiled into my app.
Re:Rust 1.100.0 by the8472 on Thursday November 12, 2026 @09:04PM (#50477150)
[delayed]
Re:Rust 1.100.0 by dabinat on Friday November 13, 2026 @04:11AM (#50480508)
I think the main reason Rust gets a bad reputation for compile times is that the compiler makes it very easy to shoot yourself in the foot. When I first started using Rust my compile times for release builds were around 7-8 mins. Then I tweaked some settings and split things up into smaller crates and got it to be under a minute, which was fine for me.

cargo check would still take a long time though, until I realized that I had a build script that was triggering more often that it should, causing Rust to throw out a lot of its work and redo it. Once I fixed that, cargo check was near-instant.

So as a Rust developer you can have decent compile times but only if you (and your dependencies) optimize for it. Hopefully at some point we’ll be able to stop having to think about it, but we’re not there yet.

Re:Rust 1.100.0 by mike1o1 on Friday November 13, 2026 @10:34AM (#50485030)
Do you have an example of some of the compiler/setup changes you made, besides just splitting things into smaller crates, or was that all the organizational changes you made?
Re:Rust 1.100.0 by ytxm on Friday November 13, 2026 @10:34AM (#50485026)
Compiler usually isn't the problem, it's the link stage. Try "wild" linker (it's amazing) and try looser release-like build profiles