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

114 sources
masklinn·Dec 31, 2015
> Rewrite the Swift compiler in Swift: This would be a lot of fun someday, but (unless you include rewriting all of LLVM) requires the ability to import C++ APIs into Swift. Or write thin bindings exposing a C API to the bits of LLVM you need to invoke to drive the backend. I believe that's what Rust does[0], because you definitely can't import C++ in Rust, rustc is written in Rust, and yet it uses LLVM. [0] might be in https://github.com/rust-lang/rust/tree/master/src/rustllvm though I'm not quite sure
In Swift: Commonly Rejected Changes
pcwalton·Dec 24, 2015
> But why can't it just produce something different on each system? It could. That is indeed how Rust, for example, defines it. But in C "unspecified values" have a way of turning into undefined behavior really quickly. Here's an actual bug we have in Rust [1]: let index = 1.04E+17 as u8; let array = vec![1, 2, 3, 4, 5]; println!("{}", array[index as usize]); // segfault Why does that segfault instead of emitting a safe panic? Because the IR looks something roughly like this (in C notation): double tmp = 1.04e+17; uint8_t index = (uint8_t)tmp; vector *array = make_a_vector(); if (index >= array->length) panic(); printf("%d\n", array->ptr[index]); The optimizer correctly determines that the cast from double to uint8_t results in an undefined value. In LLVM terminology, undefined values can arbitrar
Read the rest
ily change value over their live range, and this is allowed per the C specification. So LLVM is allowed to replace the conditional "index >= array->length" with "false", and this is indeed what it does, leading to this code: double tmp = 1.04e+17; uint8_t index = (uint8_t)tmp; vector *array = make_a_vector(); printf("%d\n", array->ptr[index]); And with that, LLVM optimizes out our bounds check, and safe code is able to perform arbitrary memory reads and writes. Note that all we needed was an unspecified value resulting from a floating point cast! The fix is probably going to be to stop using LLVM's floating point conversion instructions and to instead use some "safe conversion" intrinsics that we'll define. > What compilers do today should be the recourse of absolute last resort, and the sort of thing that makes its authors feel bad. But it seems to be treated as a matter of course. I don't know what to say. You might think that I would think this way too after fighting bugs like the above, but I actually don't. I appreciate the performance that undefined behavior brings to C, and I think we'd have much slower programs without it. Undefined behavior resulting from strict aliasing is the reason why a for loop setting an array to zero can optimize to a 10x faster memset, for example. And heavily inlined series of functions, as well as generic libraries like the C++ STL, frequently require these optimizations to get reasonable performance. I think it's not an exaggeration to say that much of the software performance we take for granted—stuff you care about, like codecs, games, browser implementations—is the result of optimizations that are enabled by undefined behavior. [1]: https://github.com/rust-lang/rust/issues/10184
In The Problem with Friendly C
masklinn·Nov 16, 2015
Pretty much all languages with generics will have that kind of declarations, the only question is how many type parameters they'll go up to. In C# Action goes up to 16[0] while Rust's tuple go to 12[1] and GHC goes to 62[2] (intending 100, but a comment notes declaration of a 63-wide tuple constructor segfaults) [0] https://msdn.microsoft.com/en-us/library/dd402872(v=vs.110).... [1] https://github.com/rust-lang/rust/blob/master/src/libcore/tu... [2] https://downloads.haskell.org/~ghc/7.2.2/docs/html/libraries...
In Modern Java – A Guide to Java 8
kibwen·Oct 29, 2015
The MIR is the biggest effort to improve compilation speed, because it's strongly tied in with the effort to make Rust compilation incremental and cacheable in a fine-grained way. It should also hopefully be able to perform some simple semantic-aware optimizations prior to handing off to LLVM, to reduce the amount of effort LLVM has to spend optimizing Rust code. There have still been general compiler improvements this cycle (e.g. https://github.com/rust-lang/rust/pull/27943), but the MIR work is necessary for long-term improvements going forward.
In Announcing Rust 1.4
kibwen·Oct 29, 2015
Lots of great improvements, but as ever I'm looking to the future. :) The effort to overhaul the compiler middle-end is proceeding nicely, and MIR construction should now be turned on in the nightlies (though hopefully turned off in 1.5-beta, since it isn't actually useful yet for anything other than generating heat). Meanwhile, support for driving LLVM IR generation from the MIR is in the pipeline as we speak: https://github.com/rust-lang/rust/pull/29217
In Announcing Rust 1.4
Gankro·Oct 26, 2015
We specifically recommend against providing panicing and non-panicking. This causes horrible combinatoric explosions. There's very few exceptions to this (array indexing being the major exception). We do of course recommend non-panicking, but there's a few cases where the burden of checking for errors is too high (indexing, refcell). We're actually in the midst of arguing whether to violate this convention and do it for RefCell: https://github.com/rust-lang/rust/issues/27733
In Java 8’s new Optional type doesn't solve anything
rhelmer·Oct 5, 2015
I am hoping that Rust will make in-roads into the BSD world, since it interoperates well with C and is much safer by default while not imposing overhead like a managed language+runtime would. It also has very liberal licensing (GCC being GPL has always been a tough pill for some to swallow, FreeBSD at least has already switched to Clang) https://github.com/rust-lang/rust#license The OpenBSD folks have done great work through auditing and writing safer code in C, and I agree that using a language that ameliorated at least some of the common mistakes programmers make would be a net positive. Related - this blog from @tedunangst is worth reading, regarding the limit to which even a language like Rust can protect against specific exploits (the OpenSSL "Heartbleed" vulnerability, in this case) http://www.tedunangst.com/flak/post/heartbleed-in-
Read the rest
rust
In Is OpenSMTPD worthy of OpenBSD inclusion?
steveklabnik·Oct 1, 2015
The relevant search terms are "SEME regions" and "non-lexical borrows". The tracking issue is here: https://github.com/rust-lang/rfcs/issues/811 and https://github.com/rust-lang/rust/issues/6393 is the older issue it superseded, with examples. There hasn't been an RFC yet, because we're in the middle of a large amount of compiler internals work (HIR/MIR), which will make overall analysis easier, including these two features. > (I can't reply there for some reason.) HN limits responses based on the depth of the comment tree and the length of time since the comment was posted, to discourage flamewars, you can always click on a comment link directly to kind of bypass that though.
In Trying Rust for web services
steveklabnik·Oct 1, 2015
Hey there. Thanks! Rustdoc can _certainly_ use way more improvements. Many of the things you've expressed are here: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Ais... I would love to re-write all of Rustdoc, frankly, but haven't been able to. Even just re-doing the HTML/CS/JS would be pretty great, I think. There are never enough hours in the day. As for non-API docs, https://github.com/rust-lang/cargo/issues/739 is the tracking issue. Also great to have, also just needs someone to come along and do it.
In Trying Rust for web services

Showing the 15 most recent of 114 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.