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, 7:56:55 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

50 sources
Jweb_Guru·Dec 23, 2014
> To have those guarantees the data would need to stored in an atomically reference counted structure (or something else with the same guarantees), which is just like you said. That is not true. `Send` is having its `'static` bound removed, so sharing data will no longer require reference counting for threads with bounded lifetime: https://github.com/rust-lang/rfcs/pull/458 (the RFC hasn't been officially accepted but it's been referenced as a foregone conclusion several times by Rust core team members). There is already an experimental library exploiting this for `Sync` data, which includes immutable substructures: https://github.com/nikomatsakis/rayon The only reason people aren't more aware of this is because the functionality isn't exposed in the standard library yet. The language is perfectly capable.
In Clojure: Creating a reducible repeat
portmanteaufu·Dec 22, 2014
> (Lifetime management is the obvious new language feature to target.) If you haven't toyed with Rust since late summer when Lifetime elision[1] landed, it's very worth revisiting. That feature made writing out lifetime notations unnecessary in 87% of the standard library. It's made things a lot more pleasant. There's still plenty of room for IDEs and editors to help out, of course, but the language itself is making great strides in usability as it matures. [1] https://github.com/rust-lang/rfcs/blob/704f0060176418659698e...
In Rust, an Anti-Sloppy Programming Language
aturon·Dec 13, 2014
I completely agree that a strong standard library is essential, and we've been working very hard over the last months to set explicit conventions, revamp APIs, and generally get Rust's standard library into a 1.0 state. You shouldn't read much into the "experimental" tags right now; they're part of an API stability tracking system that is heavily in flux at the moment. In particular, for most of the modules you mentioned, only the module name itself has not been marked "stable", while the contents have been. For example, if you look at the Vec type itself: http://static.rust-lang.org/doc/master/std/vec/struct.Vec.ht... you'll see that most methods are unstable or stable, rather than experimental. (The "experimental" status is currently the default, to help us keep track of API "stabilization" progress.) This stability tracking is part of
Read the rest
our general story about API compatibility; you can read more at http://blog.rust-lang.org/2014/10/30/Stability.html These markers won't take on their full meaning until we ship 1.0. For 1.0, all of the APIs you mentioned will be "stable", and indeed most of their internals already are. Over the next few weeks, we'll be updating stability markers to reflect the API scrutiny and design work that we've been doing. More generally, for all but a couple of the modules listed at http://static.rust-lang.org/doc/master/std/index.html?search... we have already performed a detailed scrutiny of the API, and have either landed changes needed for 1.0 or will do so very soon. Most truly experimental APIs have already been deprecated or removed. For IO in particular, you can read a very recent RFC that proposes the final set of API changes for 1.0: https://github.com/rust-lang/rfcs/pull/517 Hope that helps!
In Rust 1.0: Scheduling the trains
MichaelGG·Dec 13, 2014
If you do this: spawn(proc() { panic!("hmmph"); }); Then "nothing" happens. The default, correct, behaviour for "unhandled" errors is to abort the program. Rust apparently thinks it doesn't need this, because "poisoning". Which is a great thing, except it still doesn't excuse silently swallowing errors. It's one way to end up with a half-dead process. And considering Rust's overall strict handling of errors, it seems bizarrely counter-intuitive to go with the silent route here. The .NET team went through the exact same process and ended up taking a breaking change in v2 to fix their handling of background exceptions (so now they crash the app unless you opt-in to handling them). I described it here: https://github.com/rust-lang/rust/issues/19610 But it's closed pending writing an RFC and I haven't had time to figure that out yet. Edit:
Read the rest
I added the RFC: https://github.com/rust-lang/rfcs/pull/519
In Rust 1.0: Scheduling the trains
asb·Dec 12, 2014
I do wonder if Rust 1.0 is being branched just a little bit too early. I understand that you have to draw a line in the sand somewhere, and the rolling release model means new features can be rolled out quickly. On the other hand, I'm rather disappointed that the ergonomics of error handling may change substantially after 1.0. This is something that is going to affect every single Rust program written, and people may be surprised if 'the best way' to do this changes after 1.0. https://github.com/rust-lang/rfcs/pull/243
In Rust 1.0: Scheduling the trains
kibwen·Dec 11, 2014
As others have mentioned, Rust does indeed support cross-compilation (and has from day one). Sadly we still need to document it fully, though our spotty docs haven't stopped community members from getting Rust code running on FreeBSD and iOS and all sorts of ARM things. For the moment it may be enlightening to read the recently-implemented Flexible Target Specification RFC (https://github.com/rust-lang/rfcs/blob/master/text/0131-targ...), which you may have seen in action via Rust on the PSP (https://github.com/luqmana/rust-psp-hello).
In Bootstrapping Rust
kibwen·Dec 10, 2014
> For the record, I voted for enum, like in rust-lang ;-) Funny, because there's actually a long, long history of debate around whether Rust should refer to them as unions rather than enums (and change the keyword correspondingly). :) Here's the most recent one that I know of: https://github.com/rust-lang/rfcs/pull/27 Swift seems to have followed Rust's example with its terminology here, so this issue is hardly settled. It may shake out such that `enum` is used for tagged unions where the variants are declared as part of the type (`enum Foo { Bar, Baz}`) (and hence the variants can't be shared between types, at least not without wrapping in a newly-defined variant), whereas `union` is used for tagged unions where the type is composed from multiple existing types (`type Bar; type Baz; union Foo { Bar | Baz }`).
In Elm 0.14 – Simpler Core, Better Tools

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