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

rfcs

RFCs for changes to Rust

Explore on GitHubRead Hacker News discussions
352Distinct people
685Mentions
5Explicit recommenders
6.6KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

RFCs for changes to Rust

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

It is completely the answer to your question. Note that Rust does not have green threads (RFC 230: https://github.com/rust-lang/rfcs/blob/master/text/0230-remo...), so without…

halostatue used a recommendation phrase. 5 indexed comments match. This is a phrase match, not a verdict.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 12:54:37 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
*sshole, or when are we going to get rid of C? direct repository linkDebated

The discussion centers on whether the *sshole vulnerability in musl was a failure of C language design or poor engineering norms, with some arguing that Rust's community standards prevent such logic errors while others contend it is merely a programmer mistake. Critics of the original article argue that blaming C for this specific issue ignores the role of individual developer responsibility and existing safety features in other languages.

42 readable replies · Supporting reply 1 · Supporting reply 2 · Supporting reply 3 · Supporting reply 4

Mentions over time

HN mentions by year685 dated mentions

Observed mentions: 2014-04-09 12:17:16 UTC to 2026-08-22 09:34:08 UTC.

02550751002014-01-01 00:00:00 UTC to 2015-01-01 00:00:00 UTC (exclusive): 50 mentions; 5 submissions, 45 comments20142015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 87 mentions; 1 submissions, 86 comments2016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 105 mentions; 5 submissions, 100 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 81 mentions; 5 submissions, 76 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 64 mentions; 6 submissions, 58 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 41 mentions; 3 submissions, 38 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 63 mentions; 11 submissions, 52 comments20202021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 46 mentions; 3 submissions, 43 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 38 mentions; 2 submissions, 36 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 44 mentions; 2 submissions, 42 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 31 mentions; 1 submissions, 30 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 22 mentions; 2 submissions, 20 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 13 mentions; 0 submissions, 13 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
20142014-01-01 00:00:00 UTC2015-01-01 00:00:00 UTC50545
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC87186
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC1055100
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC81576
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC64658
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC41338
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC631152
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC46343
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC38236
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC44242
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC31130
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC22220
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC13013

From the project README

An excerpt from the repository, fetched Nov 12, 2026.

Read the project’s introduction
Rust RFCs - RFC Book - Active RFC List The "RFC" (request for comments) process is intended to provide a consistent and controlled path for changes to Rust (such as new features) so that all stakeholders can be confident about the direction of the project. Many changes, including bug fixes and documentation improvements can be implemented and reviewed via the normal GitHub pull request workflow. Some changes though are "substantial", and we ask that these be put through a bit of a design process and produce a consensus among the Rust community and the sub-teams. Table of Contents Opening Table of Contents When you need to follow this process Sub-team specific guidelines Before creating an RFC What the process is The RFC life-cycle Reviewing RFCs Implementing an RFC RFC Postponement Help this is all too informal! License Contributions When you need to follow this process You need to follow this process if you intend to make "substantial" changes to Rust, Cargo, Crates.io, or the RFC process itself. What constitutes a "substantial" change is evolving based on community norms and varies depending on what part of the ecosystem you are proposing to change, but may include the following. Any semantic or syntactic change to the language that is not a bugfix. Removing language features, including those that are feature-gated. Large additions to std. Some changes do not require an RFC: Rephrasing, reorganizing, refactoring, or otherwise "changing shape does not change meaning". Additions that strictly improve objective, numerical quality criteria (warning removal, speedup, better platform coverage, more parallelism, trap more errors, etc.) Additions only likely to be noticed by other developers-of-rust, invisible to users-of-rust. Minor additions to std: these only require an ACP. If you submit a pull request to implement a new feature without going through the RFC process, it may be closed with a polite request to submit an RFC first. Sub-team specific guidelines For more details on when an RFC is required for the following areas, please see the Rust community's sub-team specific guidelines for: language changes, library changes, compiler changes. Before creating an RFC A hastily-proposed RFC can hurt its chances of acceptance. Low quality proposals, proposals for previously-rejected features, or those that don't fit into the near-term roadmap, may be quickly rejected, which can be demotivating for the unprepared contributor. Laying some groundwork ahead of the RFC can make the process smoother. Although there is no single way to prepare for submitting an RFC, it is generally a good idea to pursue feedback from other project developers beforehand, to ascertain that the RFC may be desirable; having a consistent impact on the project requires concerted effort toward consensus-building. The most common preparations for writing and submitting an RFC include talking the idea over on our official Zulip server, discussing the topic on our developer discussion forum, and occasionally posting "pre-RFCs" on the developer forum. You may file issues on this repo for discussion, but these are not actively looked at by the teams. As a rule of thumb, receiving encouraging feedback from long-standing project developers, and particularly members of the relevant sub-team is a good indication that the RFC is worth pursuing. What the process is In short, to get a major feature added to Rust, one must first get the RFC merged into the RFC repository as a markdown file. At that point the RFC is "active" and may be implemented with the goal of eventual inclusion into Rust. Fork the RFC repo RFC repository Copy 0000-template.md to text/0000-my-feature.md (where "my-feature" is descriptive). Don't assign an RFC number yet; This is going to be the PR number and we'll rename the file accordingly if the RFC is accepted. Fill in the RFC. Put care into the details: RFCs that do not present convincing motivation, demonstrate lack of understanding of the design's impact, or are disingenuous about the drawbacks or alternatives tend to be poorly-received. Submit a pull request. As a pull request the RFC will receive design feedback from the larger community, and the author should be prepared to revise it in response. Now that your RFC has an open pull request, use the issue number of the PR to rename the file: update your 0000- prefix to that number. Also update the "RFC PR" link at the top of the file. Each pull request will be labeled with the most relevant sub-team, which will lead to its being triaged by that team in a future meeting and assigned to a member of the subteam. Build consensus and integrate feedback. RFCs that have broad support are much more likely to make progress than those that don't receive any comments. Feel free to reach out to the RFC assignee in particular to get help identifying stakeholders and obstacles. The sub-team will discuss the RFC pull request, as much as possible in the comment thread of the pull request itself. Offline discussion will be summarized on the pull request comment thread. RFCs rarely go through this process unchanged, especially as alternatives and drawbacks are shown. You can make edits, big and small, to the RFC to clarify or change the design, but make changes as new commits to the pull request, and leave a comment on the pull request explaining your changes. Specifically, do not squash or rebase commits after they are visible on the pull request. At some point, a member of the subteam will propose a "motion for final comment period" (FCP), along with a disposition for the RFC (merge, close, or postpone). This step is taken when enough of the tradeoffs have been discussed that the subteam is in a position to make a decision. That does not require consensus amongst all participants in the RFC thread (which is usually impossible). However, the argument supporting the disposition on the RFC needs to have already been clearly articulated, and there should not be a strong
Read the full README on GitHub

What Hacker News says

685 sources
matklad·Aug 22, 2026
I can shed some light here! This is going to be longish comment, but hopefully by the end of it you should understand _why_ we decided to avoid using the disk initially, even if you don't agree with that decision. Historically, the decision to not use disk traces back to this comment https://github.com/rust-lang/rfcs/pull/1317#issuecomment-150..., which is perhaps the single GitHub comment that influenced my life most. Very high impact, thanks dgrunwald! Specifically, >Don't store anything to disk. It's likely the oracle can be fast enough without doing this; and unnecessary complexity creates bugs. "Have you tried deleting the .ncb file?" (I remember having to do this a couple times per day when using VS, ca. 2005) >Use lazy evaluation. The IDE is only interested in very specific bits of information, almost always restricted to a couple
Read the rest
of lines around the cursor. Avoid calculating stuff that might never get used before it gets invalidated by the next code change. >At least for C#, laziness saves so much time that incremental compilation is unnecessary for IDE purposes The other part of historical context was that the motivation for creating rust-analyzer was that I didn't want to write a second Rust compiler (having been doing that for a couple of years at JetBrains). So it was explicitly an experimental project to prototype the right architecture for an IDE, to ultimately change how rustc works internally, so that, down the line, an IDE and a command-line compiler could use the same core. Given that rust-analyzer is now effectively a separate rust compiler, it's safe to say I am not good at achieving my life's goals! In that context, I believe that avoiding disk was the _right_ decision: * It's not really germane to the problem space, if all you need is literally a cache, it can always be added later. * Disk is a can of worms of data consistency problems. They can be overcome with engineering effort to ultimately give better user experience, but user experience wasn't the primary goal. And using disk wouldn't actually illuminate the interesting aspects of the architecture, the intended primary goal. * Finally, _not_ using disk would be a forcing function to keep analysis fast enough, to not make startup prohibitive. The last one was a particularly big argument in my mind --- I didn't want to reach out for "easy" solutions prematurely, to avoid avoiding hard problems. And, again, my recollection is probably not 100% correct, but, until we added support for proc macros and build scripts, it was fine-ish from the perspective of startup time (RAM usage is a different story). The problem with proc_macros and build.rs is that they need to run the rust code, so they have to run the real rustc compiler, so all our usual IDE tricks ("information ... restricted to a couple of lines around the cursor") just don't apply. The reason why we didn't add it later was that it seemed a relatively lower priority task than the work to share the parser between rust-analyzer and rustc. So that's what I was focusing on, though, I didn't deliver that. I still think we should do it! There's no _insurmountable_ technical reasons why the parsers can't be shared! It's just (a lot of) engineering work. And, while the parser is the boring part of compiler, it's the interesting part of an IDE. Anyway, that explains how we ended up where we are. That being said, I don't think that "just adding disk cache" is the right approach --- the salsa in-memory data structure is very sparse and pointy. Dumping that to disk would help somewhat, but wouldn't be a great long term solution. What is needed (I also explain this in https://matklad.github.io/2026/08/21/rust-glancer.html) is to design a compact, first class data format for representing analysis information about the crate, and than teaching rust-analyzer to be polymorphic in the source of data. For current workspace, you want to use a lazy incremental in-memory data structure (I do think we sadly need incrementally for Rust, given its compilation unit structure). For dependencies, you want to work off a compact on disk index. And, if the user "goes to definition" and mutates its file in place, we want to transparently switch between the two. The _pre requisite_ for that was to define a backend agnostic analysis API, and that work was always slowly progressing in the background (https://hackmd.io/ytd82QNiT_Ku2XFr1EAtiQ), but it generally took the backseat, while sharing the parser was the main focus.
In Rust Glancer: Rust LSP using 100x less RAM
whytevuhuni·Jul 12, 2026
> honestly thats the biggest problem with rust, they come up with a lot of useful changes but then take ages to stabilize because the core team is overworked On the contrary, that has been one of Rust's biggest strengths. My impression when reading through stdlib was that they got so many things right, and for that to happen, things need to be thought out properly. Case in point, it'd be such a shame if they stabilized the allocator API, only for us to forever regret never getting the storage API [1] instead, or vice-versa, depending on which one turns out to be more pragmatic. > they also have a kind of perfectionist culture as a reaction to all the half baked features shipping in C++. And that's a good thing! Some people really dislike the constant influx of new features due to the overwhelming complexity it leads to. So if we do have n
Read the rest
ew features, they better be worth it. [1] https://github.com/rust-lang/rfcs/pull/3446
In Understanding the Odin programming language
kibwen·May 16, 2026
You appear to have missed that NPM is owned by Microsoft. In addition, crates.io has not flatly refused to support namespaces, there's an entire accepted RFC for it: https://github.com/rust-lang/rfcs/pull/3243 At the same time, note that namespacing does nothing to prevent any sort of problem here. Namespacing is great for package organization and making provenance more deliberately obvious, but beyond that it's not a security measure.
In 'No way to prevent this,' says only package manager where this regularly happens
ViewTrick1002·May 13, 2026
Rust had that, but decided it wasn’t a good enough fit. Which was the motivation to keep exploring and land on the current async implementation which scales from embedded to servers with minimal overhead. History: This RFC proposes to remove the runtime system that is currently part of the standard library, which currently allows the standard library to support both native and green threading. https://github.com/rust-lang/rfcs/blob/master/text/0230-remo...
In The limits of Rust, or why you should probably not follow Amazon and Cloudflare
aw1621107·Apr 6, 2026
> I wonder why they went with a new keyword; I assumed the compiler would opportunistically do TCO when it thinks it's possible, and I figured that the simplest way to require TCO (or else fail compilation) could be done with an attribute. The first RFC for guaranteed tail calls stated an attribute on `return` was a possible alternative "if and when it becomes possible to attach attributes to expressions" [0]. That was from pre-1.0, though; I believe Rust now supports attributes on at least some expressions, but I don't know when that was added. The second RFC [1] doesn't seem to discuss keyword vs. attribute, but it does mention that the proof-of-concept implementation "parses `become` exactly how it parses the `return` keyword. The difference in semantics is handled later", so perhaps a keyword is actually simpler implementation-wise? T
Read the rest
here's some more discussion on attribute vs. keyword starting here [2], though the attribute being discussed there is a function-level attribute rather than something that effectively replaces a `return`. The consensus seems to be that a function-level attribute is not expressive enough to support the desired semantics, at least. There's also a brief mention of `become` vs. `return` (i.e., new keyword because different semantics). [0]: https://github.com/rust-lang/rfcs/pull/81/changes [1]: https://github.com/DemiMarie/rfcs/blob/become/0000-proper-ta... [2]: https://github.com/rust-lang/rfcs/pull/1888#issuecomment-278...
In A tail-call interpreter in (nightly) Rust
burntsushi·Dec 29, 2025
> It may just be a matter of perspective -- if you don't count rust pre 1.0, then yeah it "never" involved backtrace. Yes. I'm only counting what has been part of the stable API since Rust 1.0. I agree that following the stabilization path and future direction of a feature can be difficult. > Because if the only purpose was error chains, it could have been in core on the day of rust 1.0, as it is today. I think what actually happened is `fn backtrace(&self) -> Option<Backtrace>` was removed shortly before 1.0, but there were some misgivings about that and some on the core team wanted to bring that back eventually. And that was the main reason that it could not move to core, because that would make it a breaking change to bring `fn backtrace` back. At least that's what I remember from PRs I followed at the time. (There may have been other
Read the rest
reasons besides this though?) The only purpose is not chaining. Backtraces were definitely a desirable part of it! But we wanted to move `Error` to `core` and having backtraces be tightly coupled to `Error` would not allow that. As far as I remember, that was always the tension. To my memory, it wasn't until Jane wrote down the "generic member access" direction[1] for the `Error` trait that this tension was finally broken. [1]: https://github.com/rust-lang/rfcs/pull/2895
In Rust errors without dependencies

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