The discussion highlights significant new features in Rust 1.100, such as the stabilized never type and unused dependency warnings, while sparking a substantive debate over whether the language's lack of a stable ABI is a necessary trade-off for its generic system or an impediment to library distribution. Participants clash between those viewing the current source-only model as sufficient and those arguing that a native stable ABI is essential for practical binary interoperability.
66 readable replies · Supporting reply 1 · Supporting reply 2 · Supporting reply 3 · Supporting reply 4rust-lang
rust
Rust2012–2026
rust-lang / rust
rust
Empowering everyone to build reliable and efficient software.
818Distinct people
1,825Mentions
8Explicit recommenders
121.9KGitHub stars
What to know before exploring
What it is
Empowering everyone to build reliable and efficient software.
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
10 years ago, I commented on the Rust issue for "Incremental recompilation", where it was suggested that Rust could at least adopt Haskell GHC's model of incrementality, which…
nh2 used a recommendation phrase. 11 indexed comments match. This is a phrase match, not a verdict.
Informational Commenters provide technical explanations for Rust's release cadence and design choices, such as the separation of stabilization processes and syntax tradeoffs. The discussion highlights consistent development practices and detailed reasoning behind language features.
What changed this week. Read the supporting reply
Also in these discussions
- rust-lang/rfcs · linked in 55 of the same discussions
- golang/go · linked in 8 of the same discussions
- rust-lang/cargo · linked in 8 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Informational
Commenters provide technical explanations for Rust's release cadence and design choices, such as the separation of stabilization processes and syntax tradeoffs. The discussion highlights consistent development practices and detailed reasoning behind language features.
Supporting reply 1 · Supporting reply 2 · 4 discussions summarized
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 10:02:42 PM UTC.
The discussion centers on Rust 1.100.0, highlighting major stabilizations like the never type and custom allocators while noting that some APIs were omitted from the initial summary. A significant portion of the thread debates the feasibility and necessity of a stable ABI, with technical explanations contrasting against user desires for precompiled libraries.
47 readable replies · Supporting reply 1 · Supporting reply 2 · Supporting reply 3 · Supporting reply 4Read the discussion on HN. A full-thread summary is not available yet.
Showing the three threads with the most distinct people linking this repo, from 51 threads this week.
Mentions over time
HN mentions by year1,825 dated mentions
Observed mentions: 2012-01-20 23:03:27 UTC to 2026-10-22 06:16:46 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2012 | 2012-01-01 00:00:00 UTC | 2013-01-01 00:00:00 UTC | 42 | 6 | 36 |
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 82 | 6 | 76 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 138 | 6 | 132 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 114 | 9 | 105 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 122 | 5 | 117 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 119 | 12 | 107 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 88 | 1 | 87 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 115 | 11 | 104 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 166 | 20 | 146 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 149 | 12 | 137 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 151 | 25 | 126 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 167 | 12 | 155 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 132 | 11 | 121 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 158 | 8 | 150 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 82 | 14 | 68 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Website | Getting started | Learn | Documentation | Contributing
This is the main source code repository for Rust. It contains the compiler,
standard library, and documentation.
Why Rust?
Performance: Fast and memory-efficient, suitable for critical services, embedded devices, and easily integrated with other languages.
Reliability: Our rich type system and ownership model ensure memory and thread safety, reducing bugs at compile-time.
Productivity: Comprehensive documentation, a compiler committed to providing great diagnostics, and advanced tooling including package manager and build tool (Cargo), auto-formatter (rustfmt), linter (Clippy) and editor support (rust-analyzer).
Quick Start
Read "Installation" from The Book.
Installing from Source
If you really want to install from source (though this is not recommended), see
INSTALL.md.
Getting Help
See https://www.rust-lang.org/community for a list of chat platforms and forums.
Contributing
See CONTRIBUTING.md.
For a detailed explanation of the compiler's architecture and how to begin contributing, see the rustc-dev-guide.
License
Rust is primarily distributed under the terms of both the MIT license and the
Apache License (Version 2.0), with portions covered by various BSD-like
licenses.
See LICENSE-APACHE, LICENSE-MIT, and
COPYRIGHT for details.
Trademark
The Rust Foundation owns and protects the Rust and Cargo
trademarks and logos (the "Rust Trademarks").
If you want to use these names or brands, please read the
Rust language trademark policy.
Third-party logos may be subject to third-party copyrights and trademarks. See
Licenses for details.
Read the full README on GitHubWhat Hacker News says
166 sourcesI really enjoy using Rust for personal side projects. It made me a better C++ developer. I'm excited about stabilized const generics to be able to speed up my linear algebra code.
This issue though prevents me from recommending Rust for closed source development to my colleagues: https://github.com/rust-lang/rust/issues/40552
In Rust 1.49.0So yes, that is because it is unsafe, according to Rust's definition of safety. However, there are tools you can use to remove this.
First of all, I find that many people aren't using multiple threads, and therefore, what they want is a thread-local, not a static. For that, you can use https://doc.rust-lang.org/stable/std/macro.thread_local.html
If you do need a static, then there are libraries like https://docs.rs/lazy_static/1.4.0/lazy_static/ and https://crates.io/crates/once_cell to help too. We have talked about adding something like this to the standard library, but it hasn't landed yet. https://github.com/rust-lang/rust/issues/74465 is the tracking issue for when it does. The reason that we don't have this yet is that it is not super urgent, given that the libraries already exist.
Now, both of those give you immutable statics, but
Read the rest
that's where interior mutability comes in. As you can see from the thread_local examples, you can use a RefCell there, and if your type is simple enough, maybe even regular Cell. For lazy_static or once_cell, you may want to use Mutex<T>, or RwLock<T>, or some other type. For simple integers, the various Atomic* types might be better, for example. The reason this isn't built in is exactly because there are so many options; people need all of these specifics, so we have to provide them, so there's no single built-in thing.
I am surprised the blog post doesn't mention the stabilization of binding both by-move and by-ref in patterns [1]. I have personally been waiting on this one for several years. Time to go remove my workarounds. Thanks!
[1]: https://github.com/rust-lang/rust/pull/76119
In Rust 1.49.0Minimal Constant Generics Scheduled for Rust 1.51
2 points · Open discussionYes, absolutely. https://github.com/rust-lang/rust/issues/28728 is probably the most famous bug here, but many I-unsound bugs are similar.
This would be the case even without this. Compilers are programs. Programs have bugs.
In Pointers Are Complicated II, or: We need better language specs> Traits and fixed array bounds do not play well together. This is considered a bug, and it's been a bug since at least 2017. Generic parameters can only be types, not numbers.
FWIW the remedy for this is being stabilized soon: https://github.com/rust-lang/rust/pull/79135
In Monads and GATs in Nightly RustThe one thing I wasn't sure that I liked with rust's dbg! is that I was typically passing the argument by value, but that sometimes works and sometimes fails the borrow checker. But now reading https://github.com/rust-lang/rust/issues/59943 I see that this is a feature -- I hadn't been taking advantage of the fact that you can use dbg! inline; I'd just been adding extra dbg!(foo) lines to the code. So I should probably (a) pass by reference always and (b) look our for where inline dbg! might be useful (probably lots).
In Implementing Rust's dbg! in PythonRust has supported statically linking to MSVC and musl for a while now but also added static glibc support on Linux very recently:
https://github.com/rust-lang/rust/pull/77386
In Deno 1.6 supports compiling TypeScript to a single executableIt seems to be going well so far. I would say it's around 70% of the way there[0].
What's left is a few major runtimes (OpenJDK, golang is waiting for 1.16 to be released). Many of the packages that are not properly supported either require golang [4], rust [2], mono [3] or java to support arm64.
It's impressive the amount of work Apple has done behind the scenes get M1 support in many open source packages, [1] for example.
[0] https://github.com/Homebrew/brew/issues/7857
[1] https://github.com/Unity-Technologies/mono/commit/3f2278e081484e6616ee5892895f9996…
[2] https://github.com/rust-lang/rust/issues/73908
[3] https://github.com/mono/mono/pull/20014
[4] https://github.com/golang/go/issues/38485
In M1 Macs: Truth and Truthiness> Implementing a complete C ABI (with struct arguments and returns) is incredibly tricky, and not really a lot of fun.
This is so true. Rust does it here: https://github.com/rust-lang/rust/tree/master/compiler/rustc... and it's a lot of code for no good reasons.
In QBE vs. LLVMThose subpar diagnostics are a bug. The underlying reasons are that
- The async/await feature is an MVP
- async/await desugars to code you can write yourself that leverages a bunch of relatively advanced features, namely trait bounds and associated types
- It also leverages a nightly only feature (generators)
- Async programming is inherently harder :)
- We've had less time to see how people misuse the features to see where they land in order to clean up those cases and make the errors as user friendly as they can be
Put all of those together and the experience of writing async code in Rust is similar to the experience of writing regular Rust code maybe two or three years ago. When you encounter things like this, please file a ticket at https://github.com/rust-lang/rust/issues so that we can fix them.
In Writing Rust the Elixir Way> Installs of rust itself aren't succeeding yet for me via Homebrew
Ah, yes. Homebrew builds Rust itself and building Rust uses a previous beta release to build the current development code.
Until my recent [pr] bumping the beta bootstrap version, building Rust on aarch64-apple-darwin required specifying a nightly version of Rust because we only had nightly artifacts. I've mentioned that to a homebrew developer, so it should flow through soon. I'd expect that you'd only be able to install the nightly release at first.
> if you have recommendations
I'm a Rust fanboy, so I'd recommend installing Rust via rustup ;-)
[pr]: https://github.com/rust-lang/rust/pull/79219
In Run Homebrew Natively on Apple Silicon Arm M1> Rust is really the main thing in my end-user stack I'm waiting on since fzy, bat, exa,
Can you expand further?
% cargo install bat
Finished release [optimized] target(s) in 2m 21s
Installing ~/.cargo/bin/bat
Installed package `bat v0.16.0` (executable `bat`)
% file $(which bat)
~/.cargo/bin/bat: Mach-O 64-bit executable arm64
% cargo install exa
Finished release [optimized] target(s) in 1m 21s
Installing ~/.cargo/bin/exa
Installed package `exa v0.9.0` (executable `exa`)
% file $(which exa)
~/.cargo/bin/exa: Mach-O 64-bit executable arm64
I don't know what you mean by [fzy], as it appears to be a C program, not Rust.
See also:
• The tracking issue for tier 1 support [tracking]
• My intermediate README with instructions [readme]
[fzy]: https://github
Read the rest
> Most likely Go and Rust aren't ported simply because porting languages is hard and time consuming.
So, to be clear, Rust is ported. It's not a tier 1 target yet, but it does work. Time is not the only issue here, as elaborated downthread. For the gory details, see https://github.com/rust-lang/rust/issues/73908
In Is Apple Silicon Ready?Showing the 15 most recent of 166 sources. Enable JavaScript to search and browse every indexed mention.