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, 6:01:08 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
138 sourcesAs source I cite this PR that just landed today:
https://github.com/rust-lang/rust/pull/20218
"It's quite possible that small programs don't use all of jemalloc, and building with -ffunction-sections and -fdata-sections allows the linker (via --gc-sections) to strip out all unused code at link time. This decreases the size of a "hello world" executable for me from 716K to 482K with no measurable impact on link time. After this patch jemalloc is still the largest portion of our hello world executables, but this helps cut down on the size at least somewhat!"
In Experimental C++11 multi-platform 3D engineTake a look at this PR:
https://github.com/rust-lang/rust/pull/19405/files
In Rust, an Anti-Sloppy Programming Languagehttps://github.com/rust-lang/rust/wiki/Note-research
(There is also at least one recent paper on Rust which is t linked here.)
In Rust, an Anti-Sloppy Programming Language> any embedded work or kernels
Perhaps not, but in a kernel you'd have plenty of your own unsafe code.
SEL4 doesn't.
There are, of course, people thinking about bridging the worlds of formally provable correctness and Rust, e.g. https://github.com/rust-lang/rust/issues/18496 though extraction based is likely to not produce the most elegant or efficient code... and I assume the along-the-side proofs like SEL4 uses would be harder for Rust because the language is more complex than C.
In Rust, an Anti-Sloppy Programming Language"Gladly" isn't quite accurate: https://github.com/rust-lang/rust/pull/4146#issuecomment-114...
This is exactly how I'd expect to see `unsafe` used: as an additional optimization in situations where you can't get better in any other way, and with a big-'ol comment explaining exactly why. Well, one of the ways, at least.
In Rust, an Anti-Sloppy Programming Languagehttps://github.com/rust-lang/rust/wiki/Rust-for-CXX-programm...
There's also
http://featherweightmusings.blogspot.com/2014/04/rust-for-c-...
which is longer, but not as useful.
Rust has roughly the feature set and memory model of C++. The difference is that in Rust, the safety issues C++ sweeps under the rug are addressed. As I point out occasionally, the three big problems in C/C++ are "who owns it", "how big it it", and "who locks it". C fails to deal with any of those issues. C++ sometimes deals with "how big is it". Rust deals with all of them.
In Rust you have to deal with most of the memory management headaches you have in C++, but they're detected at compile time, not after the product ships.
In Rust, an Anti-Sloppy Programming Languagehttps://github.com/rust-lang/rust/issues/6393-
They want to make this better.
In Rust, an Anti-Sloppy Programming LanguageSupport for green threads (and hence any manual CPU dispatching) were actually removed a month ago[18967] along with much of the generic infrastructure for mediating between 1:1 and M:N threads, the patch linked here just completes the removal of that infrastructure and switches things to be much closer to the raw OS in implementation and semantics.
[18967]: https://github.com/rust-lang/rust/pull/18967
In Narrowing the notion of a runtime in RustIn ancient Rust, the standard library attempted to provide an abstraction over the underlying threading model. The purpose of this abstraction, called a "task", was to allow libraries to make use of the standard concurrency constructs while allowing the consumers of those libraries to determine whether or not to use 1:1 threading (the typical platform thread model) or M:N threading (green threads), and it would all Just Work with no effort required.
This was quite an exciting idea at the time. However, in practice, it just didn't pan out: the compromises required to paper over the differences between 1:1 threading and M:N threading managed to almost entirely obliterate the respective advantages of both models.
As a result, Rust is in the process of removing the "tasks" abstraction and replacing it with a bog-standard 1:1 threading model (
Read the rest
though it still benefits from all the typical memory-safe and concurrency-safe abstractions that Rust otherwise provides). All users of concurrency in the stdlib will now be using native threads, and it will be left to outside implementors to experiment with green threading libraries (see https://github.com/carllerche/mio for one example of such).
One of the consequences of this change is that the `std::task` module has been replaced with `std::thread`. Formerly, every Rust program imported the function `std::task::spawn` to use for spawning tasks. With the removal of `std::task`, the newly analogous function from `std::thread` has not been added to the prelude, and is therefore not imported by default in every Rust program. It could be added if such a thing were desired (you can see remarks to this effect in the comments on the PR itself (https://github.com/rust-lang/rust/pull/19654#issuecomment-66... and https://github.com/rust-lang/rust/pull/19654#issuecomment-66... )).
And in your Rust binaries, though this is a bug long since acknowledged :) https://github.com/rust-lang/rust/issues/13871
(And one of those isn't a Lovecraft quote, it's a Majora's Mask quote.)
In Narrowing the notion of a runtime in RustI'm more surprised to find Lovecraft quotes in Rust's source code:
https://github.com/rust-lang/rust/blob/6bdce25e155d846bb9252...
In Narrowing the notion of a runtime in RustLink to the PR: https://github.com/rust-lang/rust/pull/19654
In Narrowing the notion of a runtime in RustNarrowing the notion of a runtime in Rust
208 points · Open discussion0. It has nothing to do with TDD
1. It's a tooling artefact, testing systems certainly don't have to mandate split code and tests. Rust's test framework allows tests in the same file as the tested code, the testing guide recommends that unit test live alongside the code they test[0] and the standard library follows this practice[1]. I'm reasonably sure you can also do so in e.g. py.test[2]
2. I'm not convinced editing two files slows you down, most editors and window managers will let you put both files side-by-side and trivially jump between them. Are java developers slowed down by having to jump between files?
[0] http://doc.rust-lang.org/guide-testing.html#the-test-module
[1] https://github.com/rust-lang/rust/blob/4deb27e/src/libcollec...
[2] by marking all python files as "test modules"
In Evolutionary couplings between files reveal poor software design choicesShowing the 15 most recent of 138 sources. Enable JavaScript to search and browse every indexed mention.