HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
rust-lang
rust
Rust2012–2026
rust-lang / rust

rust

Empowering everyone to build reliable and efficient software.

Languages & Compilers
Explore on GitHubRead Hacker News discussions
818Distinct people
1,825Mentions
8Explicit recommenders
121.9KGitHub stars
REPOSITORY AT A GLANCE

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

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.

Rust 1.100 direct repository linkDebated

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 4
Rust 1.100 direct repository linkDebated

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 4
Systemd Loves Rust direct repository link

Read 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.

0501001502012-01-01 00:00:00 UTC to 2013-01-01 00:00:00 UTC (exclusive): 42 mentions; 6 submissions, 36 comments20122013-01-01 00:00:00 UTC to 2014-01-01 00:00:00 UTC (exclusive): 82 mentions; 6 submissions, 76 comments2014-01-01 00:00:00 UTC to 2015-01-01 00:00:00 UTC (exclusive): 138 mentions; 6 submissions, 132 comments2015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 114 mentions; 9 submissions, 105 comments2016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 122 mentions; 5 submissions, 117 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 119 mentions; 12 submissions, 107 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 88 mentions; 1 submissions, 87 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 115 mentions; 11 submissions, 104 comments20192020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 166 mentions; 20 submissions, 146 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 149 mentions; 12 submissions, 137 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 151 mentions; 25 submissions, 126 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 167 mentions; 12 submissions, 155 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 132 mentions; 11 submissions, 121 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 158 mentions; 8 submissions, 150 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 82 mentions; 14 submissions, 68 comments. Incomplete calendar period.2026*

* 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
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20122012-01-01 00:00:00 UTC2013-01-01 00:00:00 UTC42636
20132013-01-01 00:00:00 UTC2014-01-01 00:00:00 UTC82676
20142014-01-01 00:00:00 UTC2015-01-01 00:00:00 UTC1386132
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC1149105
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC1225117
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC11912107
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC88187
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC11511104
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC16620146
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC14912137
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC15125126
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC16712155
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC13211121
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC1588150
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC821468

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 GitHub

What Hacker News says

119 sources
mikebenfield·Dec 21, 2017
LLDB works well enough to sometimes be useful. I've used it with the VS Code native debugger extension [1]. I've encountered a couple annoyances: A. Using rustc to link somehow removes debugging information from static libraries I wrote in assembly [2]. This is extremely annoying, but I haven't had time to really look into it and it seems others can't reproduce it. B. There seem to be some occasional oddball problems when stepping through code. Like it'll skip lines, or stay on the same line for many steps. And also an annoyance regarding how that VS Code extension handles "Step Into" for functions you don't have the source for: you can easily get into an infinite popup situation and have to restart the debugger. IMO the sad truth is that if a great debugger is a prerequisite to use a language, then you're limited to about 5 total languag
Read the rest
es. [1] https://marketplace.visualstudio.com/items?itemName=webfreak... [2] https://github.com/rust-lang/rust/issues/45218
In Rust in 2017: what we achieved
steveklabnik·Dec 6, 2017
Macros in Rust are global, insta-stable, and have no namespacing. This means any macro we put in std means you cannot define a macro in any Rust program with that same name. This is one of the reasons we've been working on a new macro system, to fix these kinds of issues. "Just leave it in" isn't a good justification for a feature. We'd then require that every implementation of Rust ever, forever, implements this too. Being in std is a high bar. Beyond that, there are a host of other reasons: https://github.com/rust-lang/rust/commit/454882dcb7fdb03867d...
In Why I love Go
MageSlayer·Dec 4, 2017
Agree. Moreover, Rust compiler contains some dark areas which nobody wants to deal with. See https://github.com/rust-lang/rust/issues/38528 for example. Basically it means that Rust compiler can suddenly take exponential time and space for compilation. That bug really bites hard any code heavy on iterators (Rust often praised feature!). It has reliable reproduce test-case, but still it's already year old and was down-prioritized! Hard to believe anybody uses Rust for real large project given so little attention to crucial details.
In Integrating “safe” languages into OpenBSD?
TheDong·Nov 29, 2017Recommendation phrase
> Every struct (or at least every useful struct!) refers to data Not true, zero-sized structs are quite useful too. They can be used to fulfill traits, indicate certain errors (often in enums), etc. A couple quick examples from the stdlib: https://github.com/rust-lang/rust/blob/1.22.1/src/libstd/syn... https://github.com/rust-lang/rust/blob/1.22.1/src/libstd/col... I recommend watching this excellent rustconf 2017 talk for more information; it heavily features information on how zero-sized types can be used: https://www.youtube.com/watch?v=wxPehGkoNOw
In What's a reference in Rust?
steveklabnik·Nov 28, 2017
> most benchmarks Which benchmarks are you talking about? It depends on what those benchmarks measure. For example, a lot of the Quantum work was in user-percieved UI latency; unless the benchmark is measuring that, and I imagine that's a hard thing to measure, it's not going to show up. > Does Rust have a runtime penalty as Golang does? Rust has the same amount of runtime as C does: very very little. https://github.com/rust-lang/rust/blob/master/src/libstd/rt....
In How Stylo Brought Rust and Servo to Firefox
topspin·Nov 26, 2017
Myopic rant. "If your C++ code is not good enough or Java code is painfully slow, it's not because the technology is bad - it's because you haven't learned how to use it right." More 'program better and you don't need Rust.' This was said of C++ by C programmers and it regresses until we're programming punch cards in octal. At one point the argument is (indirectly) made that Rust is on the "innovative yet too idealistic" side of the ledger. This is bogus; Rust is pragmatic. Otherwise release code would pay the cost of detecting integer overflows and unsafe wouldn't exist. Rust just doesn't cop out on all the stuff that _can_ be dealt with in a reasonable manner. "static and dynamic analyzers [exist for C++]" Dismissing the obvious value of providing one uniform and precise analyzer integrated into the compiler
Read the rest
is just bad thinking. "But these are actually two dialects of one language" Unsafe changes a small and finite set of rules. It is an outrageous exaggeration to claim a new 'dialect' is created by unsafe. At one point the following construct rears it's ugly head again. It's become a favorite for Rust haters: Vec<Rc<RefCell<Box<Trait>>>> The cause of this somewhat unergonomic construct was dealt with over two years ago[1], and a workable alternative using Cell<> existed at the time. Also, how does a C++ advocate look at that type and somehow imagine it to be worse that the utterly incomprehensible line noise that C++ templates routinely devolve into? Hell, almost any given pointer to function in C is that bad or worse. "it doesn't have a decent inheritance and exceptions" C++ doesn't have 'decent' inheritance either; most C++ programmers don't even understand how inheritance in C++ actually works. Arguing that the lack of exceptions in Rust is somehow a problem is deeply wrong; better and well defined alternatives are provided. C++ exceptions are a failed language feature and an enormous fount of UB. In all likelihood you're reading this using a browser written by developers that have banned C++ exceptions from their code bases (Google and Mozilla.) "Rust is safe indeed but, unfortunately, far from fast" The one Computer Language Benchmarks Game benchmark cited here is cherry picked. Rust does very well against C++ in that set of benchmarks, winning 6 of 10 at the moment and only a little less well against C. And we all know the sort of issues inherent to those benchmarks; citing them without qualification is either poor thinking or an insult to your intelligence. Two terrible alternatives. "Macros used as a crutch to make up for the excessive verbosity caused by the absence of normal exceptions" That doesn't make sense. mic drop [1]https://github.com/rust-lang/rust/pull/24619
In Criticizing the Rust Language, and Why C/C++ Will Never Die
DSMan195276·Nov 25, 2017
Sorry for not responding sooner, but I agree with you completely that the right thing to do is not to focus on "how many" `unsafe` lines you have, but how well encapsulated they are into a module that can't be broken by outside input. And I'm glad we both see this. My "problem" is less that `unsafe` doesn't do the things I mentioned, but that whenever Rust and `unsafe` come-up there tends to be lots of people who don't understand what it is, or how it works, and I think that is a very dangerous mindset because it leads to completely pointless (and dangerous, from a safety perspective) stuff like how that paper literally measured how many lines were `unsafe` and displayed it as a percentage to prove their code was good. With all that said, while this is a separate topic, I think that the complete lack of a spec for lots of details surround
Read the rest
ing `unsafe` makes it still basically impossible to do correctly. I think Rust really needs some type of language spec, but it doesn't look like any work is being done on that front [0]. [0] https://github.com/rust-lang/rust/issues/30500 - I apologize for this link being a bit of a rabbit-hole, but I think the whole thing is a very interesting read. It continues on here (https://github.com/rust-lang/rfcs/issues/1447), and then to a repo for a Rust Memory Model specification here (https://github.com/nikomatsakis/rust-memory-model). Unfortunately, as you can probably tell, those conversions started in Dec 2015, and any real work on this front seems to have stalled almost a year ago.
In Announcing Rust 1.22
killercup·Nov 23, 2017
Yes, once [1] lands, you can add it with `rustup target add wasm32-unknown-unknown` and then you can `cargo build --target=wasm32-unknown-unknown`. You should note that it's not as simple as that, though. Depending on the context you want to run WASM you might need to do additional steps. E.g., when running this in a browser, you might not be able to use the std lib to spawn threads just yet. [1]: https://github.com/rust-lang/rust/pull/46115
In Announcing Rust 1.22
DSMan195276·Nov 23, 2017
> Considering pointer arithmetic is unsafe I just wanted to point out that this is largely a misconception. Rust, or the Rust creators, do not consider pointer arithmetic to be fundamentally `unsafe`, and the only reason `.offset()` is `unsafe` to begin with is due to optimization concerns[0]. `.wrapping_offset()` exists and is marked safe, despite achieving the exactly same thing as `.offset()` for the majority of scenarios[1], and more-over you can cast any pointer to an integer using only safe code, at which point you can perform all of your arithmetic on the integer and then cast it back also using only safe code[2]. The bottom line is that things like pointer arithmetic are generally not considered unsafe because the operation has defined semantics for what happens. It is only the point where you attempt to use the value, the derefer
Read the rest
ence, that is `unsafe`, as that may blow-up if the value is an invalid memory location. [0] https://github.com/rust-lang/rust/issues/33813 [1] https://play.rust-lang.org/?gist=c9c11545fac3a45550e6810cb57... An example that uses `.wrapping_offset` without `unsafe` to produce a segfault. [2] https://doc.rust-lang.org/book/first-edition/casting-between...
In Announcing Rust 1.22

Showing the 15 most recent of 119 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.