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
42 sourcesIncidentally to your incidentalism, I'm looking forward to the day when we can run Rust directly in a browser via Emscripten:
https://github.com/mozilla/rust/issues/2235
In Rust 0.5 released>The Go language and the Rust language. What they have in common, though, is that both Go and Rust are entirely incapable of walking like a duck. Since you cannot call Rust -or Go code from a scripting engine, they are inadvertently positioning themselves as alternatives to the scripting engines themselves.
Before writing all these BS, maybe he should do a little research first?
Here's Rust (which is not even released yet) being capable of being called from C. It's a feature they are actively work on:
https://github.com/mozilla/rust/issues/1732
In The state of low-level system programmingI really hope to see Go and Rust move in the direction of pluggable runtimes that can be embedded into a C host program. Currently, both runtimes require being seated as the main entry-point of the program to function. Both projects also have issues in their bug trackers to rectify this:
Rust issue: https://github.com/mozilla/rust/issues/3608
Go issue: http://code.google.com/p/go/issues/detail?id=2790
I wonder who will get there first.
In The state of low-level system programmingI'm a little rusty but I did read the 0.4 docs before and gave the language a try, I'll dive into 0.5 again this weekend, I am a little confused by something however. What's going on with strings? When I last looked, a lot of the string operations worked with a specific pointer sigil[1]. If I'm using managed boxes, and the methods take and return unique boxes, is it because I'm using the wrong sigil for the job or should I expect to be able to use managed strings?
Is this just me misunderstanding the memory model or is this something that just hasn't been straightened our yet? I'm pretty confused about this in particular, as I thought I understood the point of the different sigils pretty well, but the way the library is written makes me wonder. This applies to things other than strings I guess, but strings seem like a good example.
[1]: h
In Rust 0.5 releasedGithub still seems to show tags on the releases: https://github.com/mozilla/rust/tags
In Rust 0.5 released>Since you cannot call Rust -or Go code from a scripting engine
This is wrong for Rust. It already allows for that, specifically calling Rust from C (and vice versa):
https://github.com/mozilla/rust/issues/1732
Not that is a compelling argument even if it was right. There are lots of ways to make bridges to compiled code, besides using the C ABI.
In Why Rust and Go are both dead-end languages ...Why Rust and Go are both dead-end languages ...
C code is very often called from scripting engines. This phenomenon started almost immediately when the first shell scripts appeared, chaining C programs.
It only became more prevalent with scripting popularity (Javascript, Ruby, Perl, PHP, Lua, and so on) going through the roof.
Therefore, any language that aims to replace C will need to be able to carry its APIs over the C ABI. It must be possible for any contender to be called from C code, because that is what it takes to be called from a modern scripting engine too.
The Go language is pretty much incapable of doing this: http://stackoverflow.com/questions/6125683/call-go-functions-from-c and Rust is also a disaster in this respect: https://github.com/mozilla/rust/issues/1732.
Since you cannot call Rust -or Go code from a scripting engine, they are inadvertently positioning themselves
Read the rest
as alternatives for the scripting engines themselves.
Go and Rust, however, do not stand a chance when trying to position themselves an alternative to scripting too. This explains why neither Go nor Rust, in their current incarnations, will ever take off as replacements for C.
Github's infinite-click-pagination pattern (broken)
2 points · Open discussionJust for utter clarity, the FAQ states:
Q: What will Mozilla use Rust for?
A: Mozilla intends to use Rust as a platform for prototyping experimental browser architectures. Specifically, the hope is to develop a browser that is more amenable to parallelization than existing ones, while also being less prone to common C++ coding errors. The name of that project is Servo.
Q: Are you going to use this to suddenly rewrite the browser and change everything? Is the Mozilla Corporation trying to force the community to use a new language?
A: No. This is a research project. The point is to explore ideas. There is no plan to incorporate any Rust-based technology into Firefox.
https://github.com/mozilla/rust/wiki/Doc-project-FAQ
In A list of systems, applications, and libraries that are written in C++Some of the concurrency mechanisms are built from scratch today. For example, pipes (the new channel communication layer) are entirely written in bare Rust, with no C++ at all. They use atomic operations: https://github.com/mozilla/rust/blob/master/src/libcore/pipe...
Other interesting parts of the runtime that are built using Rust are task spawning (lots of locks): https://github.com/mozilla/rust/blob/master/src/libcore/task...
And implementations of mutexes: https://github.com/mozilla/rust/blob/master/src/libcore/priv...
The current plan is to implement the entire runtime in Rust itself. That includes the userland scheduler. So we will need all the low-level OS primitive mutexes, condition variables, pthread infrastructure, etc. There's no reason we can foresee why this would be particularly difficult; the only reason why it wasn't done
Read the rest
this way from the start is for bootstrapping reasons.
One such discussion in the mailing list: https://mail.mozilla.org/pipermail/rust-dev/2012-July/002094...
An example github issue discussing problems encountered: https://github.com/mozilla/rust/issues/1105
In Rust 0.4 releasedHelp would definitely be appreciated, there's a whole lot to do. See the issue tracker on Github[1] for a starting point. Filter by the "E-easy" tag if you just want to dip your toes. The "A-an-interesting-project" tag is where it gets, er, interesting; those issues represent projects that don't necessarily have a high-enough priority to block 1.0, but that everyone would love to see and that a single motivated, skilled contributor could conceivably produce.
And if you ever need any help, check out the mailing list[2] or #rust on irc.mozilla.org (most active during Californian working hours).
[1] https://github.com/mozilla/rust/issues
[2] https://mail.mozilla.org/listinfo/rust-dev
In Rust 0.4 releasedThe note regarding "preliminary JIT support" buried at the end is one of my favorite new features (and it's a tough call, since there's so damn many new features), since it makes stuff like this possible:
https://github.com/bleibig/rust-repl
I hear that LLVM's JIT support is rather untested, I'd be interested to learn if there are any other major projects besides Rust making use of it.
In general, if you haven't checked out Rust yet I'd still recommend waiting until the implementation of traits is finished off (scheduled as a high priority[1] for 0.5, which is tentatively scheduled for sometime around year's end).
[1] https://github.com/mozilla/rust/wiki/Note-0.5-priorities
EDIT: Oh, and here's a direct link to the detailed release notes rather than the summary presented in the OP:
https://github.com/mozilla/rust/wiki/Doc-detailed-release
Read the rest
Showing the 15 most recent of 42 sources. Enable JavaScript to search and browse every indexed mention.