# Inside Rust Blog

Want to follow along with Rust development? Curious how you might get involved? Take a look!

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Maintainer spotlight: Anthony Bolden (@Walnut356)

DevFeed: [Maintainer spotlight: Anthony Bolden (@Walnut356)](<https://devfeed.tech/articles/maintainer-spotlight-anthony-bolden-walnut356-113396.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/11/02/maintainer-spotlight-anthony-bolden-walnut356/>)

Author: Jakub Beránek

Published: 2026-11-02T00:00:00Z

Content type: article

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Tool](<https://devfeed.tech/topics/tool.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Maintainers](<https://devfeed.tech/topics/maintainers.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [google-summer-of-code](<https://devfeed.tech/tags/google-summer-of-code.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [spotlight](<https://devfeed.tech/tags/spotlight.md>)

### AI overview

Anthony Bolden's work has focused on making Rust debugging more usable on Windows, especially for programs built with MSVC. After Rust toolchains did not distribute debuginfo visualizers on Windows and compiler debuginfo tests did not work there, he contributed fixes and worked to improve the tests. He says the Rust build command worked on his first attempt, while trying to work with LLVM on Windows had been frustrating. His Google Summer of Code project improved compiler debuginfo testing; afterward, he joined the Rust compiler team. His planned work includes better visualizers for `Vec` and wide pointers, hashmap indexing, and performance improvements. He says proposed LLDB plugin interface changes might enable native Rust debugging integration, improved expression parsing, and possible miri integration. He also suggests shipping visualizers written in Rust. Bolden advises new Rust programmers to experiment and investigate compiler errors rather than focusing too early on best practices.

### Source excerpt

There are hundreds of people who maintain the Rust toolchain, often on a volunteer basis on top of another job. The Rust Content team is working on a series of blog posts highlighting some of these prolific contributors to recognize the awesome work that they are doing in order to make Rust better for everyone. You can find the previous post here. Consider donating to the Rust Foundation Maintainers Fund if you'd like to support Rust Project maintainers. In this post, we would like to introduce Anthony Bolden (@Walnut356). Anthony is a self-taught programmer who went on a mission to improve the Rust debugger experience. This year, he participated as a contributor in the Google Summer of Code program, and recently he joined the Rust compiler team. We interviewed Anthony to find out what brought him to programming and how he became an expert on debuggers. Read more below! Can you briefly introduce yourself and tell us how you started with programming? Hello, my name is Anthony Bolden, also known as @Walnut356, and I live in Wisconsin. I do not have any formal computer science education and I've never had a job in the tech industry, so my journey to programming was a bit different. I work overnight shifts in a hotel, where I often have a lot of time to spare, and I needed something to occupy my mind. For I while, I used to solve puzzles or read books, but eventually I got tired of that. I wanted to find a long-term project, so I tried programming. It took me a couple of tries until it "clicked", but when that happened, I instantly fell in love with it. It is so much fun! How did you discover Rust? I bought a couple of C++ books when I was learning how to program, so that was my entrypoint. But I was very dissatisfied with the development experience there. I wanted to make a simple game, because I've always found game design fascinating, but adding a dependency like SDL to my project turned out to be very difficult. I spent SO MUCH time trying to get it to work, and it

## Variadic Generics Micro Survey results

DevFeed: [Variadic Generics Micro Survey results](<https://devfeed.tech/articles/variadic-generics-micro-survey-results-103457.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/10/27/variadic-generics-micro-survey-results/>)

Author: Olivier Faure

Published: 2026-10-27T00:00:00Z

Content type: article

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Bevy](<https://devfeed.tech/topics/bevy.md>)

Tags: [bevy](<https://devfeed.tech/tags/bevy.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [generics](<https://devfeed.tech/tags/generics.md>), [results](<https://devfeed.tech/tags/results.md>), [survey](<https://devfeed.tech/tags/survey.md>), [use-cases](<https://devfeed.tech/tags/use-cases.md>)

### AI overview

The survey collected over 3,300 responses, including 900 written answers to one question; the team reviewed them by hand, citing privacy and quality concerns about using AI. Respondents most strongly described practical uses for variadic generics and tuple-wide trait implementations, often to replace macros that require repetitive implementations up to a fixed tuple size. Variadic mappings drew broadly similar support, while responses to non-linear variadics were more cautious; the authors note that its example steered answers toward filtering and specialization. Overall sentiment was "cautious, but interested." Some respondents prioritized features such as specialization or better const generics, and skeptics warned that accumulating arcane features could make Rust harder for newcomers. The authors say future proposals should use readable syntax and show clear benefits over macro workarounds. These results reflect the supplied article excerpt; it points to a separate full report with polls and example answers.

### Source excerpt

A year ago, we launched the Variadic Generics Micro Survey, with the goal of collecting people's use cases for a hypothetical variadic generics feature. Because of its open-ended purview, this survey included a lot of open answers. Not only that, respondents were encouraged to fill out answers, in as much detail as they wanted. And they did: we got over 3300 submissions, including 900 text answers to just one question. We fed these answers to Claude and it told us th- ha, just kidding, if only. More seriously, we did consider using AI to process the answers, but decided not to over privacy and quality concerns. Instead we ended up going through the dataset by hand, hence why these results took so long to publish. This article will include both the numerical survey results and some trends observed in the free answers. See also the full report, which includes the polls and examples of answers showcasing the trends. Table of contents Background First use-cases Variadic mappings Non-linear variadics Final questions Background This first questions were about users' backgrounds. How long have you been using Rust? [PNG] [SVG] Have you heard about variadic generics before? [PNG] [SVG] Where have you heard about variadic generics? [PNG] [SVG] Among the open responses, the most common were: [PNG] [SVG] The "solving a problem" category is interesting: a few people mentioned wanting to solve a specific problem, doing some research, and finding that they wanted was called "variadic generics". Here we can already notice the Bevy community is somewhat over-represented in the answers. It's not clear to what extent this is because Bevy users care a lot about variadics, or because there was a lot of advertising for the survey on the Bevy Discord server. First use-cases This code example was given to illustrate variadic generics (with pseudocode syntax): impl<...Ts: SomeTrait> SomeTrait for (...Ts) { fn do_stuff(&self) -> u32 { let mut sum = 0; for member in ...self { // The trait bou

## Announcing the GPU notification group and Linker Working Area

DevFeed: [Announcing the GPU notification group and Linker Working Area](<https://devfeed.tech/articles/announcing-the-gpu-notification-group-and-linker-working-area-91167.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/10/20/gpu-target-notification-group/>)

Author: The compiler team

Published: 2026-10-20T00:00:00Z

Content type: release

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [linker](<https://devfeed.tech/tags/linker.md>), [notification](<https://devfeed.tech/tags/notification.md>)

### AI overview

The compiler team announced two groups: a GPU target notification group and a Linker working area. The GPU group brings together experts from vendors including AMD, Nvidia, and Intel to help diagnose and resolve GPU issues, mainly through maintenance; its Zulip stream is #t-compiler/gpgpu-backend. The Linker working area is intended to advance compiler support for alternative linkers such as Wild and serve as a contact point for linker questions and issues; its stream is #t-compiler/linker. Notification groups focus on monitoring and responding to issues, while working areas explore feature and compiler improvements. Anyone interested can join either by opening a PR against rust-lang/team.

### Source excerpt

We are announcing two new groups in the compiler team: The GPU target notification group, for helping us to diagnose and resolve GPU-related issues The Linker working area, with expertise or interest in linkers About the GPU-target notification group The GPU target notification group is made of experts from various vendors (AMD, Nvidia, Intel, etc.) and its goal is to better respond to issues and in general work in this area of expertise, for example this one. This group has an associated Zulip stream (#t-compiler/gpgpu-backend). About the Linker working area Creating of a linker group was discussed in MCP#964 to kickstart work about integrating alternative linkers in the compiler, like Wild. As the second goal, this group can be a point of contact for handling questions and issues regarding linkers. This group has an associated Zulip stream (#t-compiler/linker). What is a "notification group" and a "working area group"? Notification groups are made of people volunteering to keep an eye and respond to issues in a specific area they have expertise, they mostly help with maintenance. Working areas explore and do work focused on specific areas with the goal of adding features or improving the compiler. Each group may have an associated Zulip stream where people can ask questions and discuss topics specific to that target. Anyone can add their own name to these groups and be notified when an issue in that area is raised. If you are interested in participating, feel free to sign up for these groups. To do so, just open a PR against the rust-lang/team repository (here an example). For more info, see the documentation about notification groups and compiler working areas.

## 1.99.1 pre-release testing

DevFeed: [1.99.1 pre-release testing](<https://devfeed.tech/articles/1-99-1-pre-release-testing-86244.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/10/13/1.99.1-prerelease/>)

Author: Release automation

Published: 2026-10-13T00:00:00Z

Content type: release

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Release notes](<https://devfeed.tech/topics/release-notes.md>), [rustrover](<https://devfeed.tech/topics/rustrover.md>)

Tags: [pre-release](<https://devfeed.tech/tags/pre-release.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Rust 1.99.1 is available as a pre-release for testing, with release scheduled for October 15. The post provides an update command and invites feedback on the pre-release process.

### Source excerpt

The 1.99.1 pre-release is ready for testing. The release is scheduled for October 15. Release notes can be found here. You can try it out locally by running: RUSTUP_DIST_SERVER=https://dev-static.rust-lang.org rustup update stable The index is https://dev-static.rust-lang.org/dist/2026-10-13/index.html. You can leave feedback on the internals thread. General feedback about our pre-release process is welcome on this GitHub issue.

## Infrastructure Team 2026 Q3 Recap and Q4 Plan

DevFeed: [Infrastructure Team 2026 Q3 Recap and Q4 Plan](<https://devfeed.tech/articles/infrastructure-team-2026-q3-recap-and-q4-plan-85478.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/10/12/infrastructure-team-q3-recap-and-q4-plan/>)

Author: Marco Ieni

Published: 2026-10-12T00:00:00Z

Content type: article

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [enterprise data protection](<https://devfeed.tech/topics/enterprise-data-protection.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>), [AWS Local Zones](<https://devfeed.tech/topics/aws-local-zones.md>), [datadog](<https://devfeed.tech/topics/datadog.md>)

Tags: [aws](<https://devfeed.tech/tags/aws.md>), [cloud-siem](<https://devfeed.tech/tags/cloud-siem.md>), [datadog](<https://devfeed.tech/tags/datadog.md>), [ddos](<https://devfeed.tech/tags/ddos.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [latency](<https://devfeed.tech/tags/latency.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

The Rust Infrastructure Team reports its Q3 2026 work and Q4 plans. Q3 changes included security logging, Fastly WAF and DDoS protection for crates.io and docs.rs, CDN performance improvements, dependency and GitHub Actions security automation, expanded development and CI capacity, and infrastructure changes for Rust contributors. Q4 plans include stronger access controls, consolidated logging, secure deployment automation, and decommissioning a self-hosted monitoring instance.

### Source excerpt

Here's what the Infrastructure Team delivered in Q3 2026 and what we're focusing on in Q4. You can find the previous blog post of this series here. Q3 2026 Accomplishments Audit logs in Datadog Cloud SIEM We enabled audit logs for the following services and sent them to Datadog, so that the Rust Foundation security team can analyze them using Cloud SIEM: The Rust GitHub Enterprise and the Rust Foundation GitHub Enterprise, via audit log streaming. AWS, via CloudTrail. Heroku, Wiz, Fastly, and Datadog itself. See the GitHub issue for more details. Web Application Firewall and DDoS protection for crates.io and docs.rs Together with the crates.io and docs.rs teams, we set up the Fastly Next-Gen WAF (Web Application Firewall) for docs.rs and crates.io (see the GitHub issue). The WAF blocks potential security threats and enforces rate limits. We also enabled Fastly DDoS protection for both services. Together, these helped us mitigate DDoS attacks against crates.io this quarter, and reduce the load on the docs.rs server. CDN improvements for crates.io and docs.rs We made several improvements to the Fastly configuration of crates.io and docs.rs: Faster crate downloads processing: We removed a regex from the Fastly code that handles crate downloads, and did some other optimizations (#1095, #1096). Requests now take 10% less compute time in the Fastly CDN nodes. Most users won't notice the difference, since networking dominates download latency, but it makes our CDN setup more efficient and sustainable. Content-Length in HEAD responses: Fastly HEAD responses now include the Content-Length header for non-compressible artifacts such as .crate files. This fixes some issues encountered when using Buck2. crates.io static assets served from the edge: GET and HEAD requests for READMEs and other static assets of crates.io are now resolved by the CDN instead of the crates.io web app hosted on Heroku. docs.rs CDN logs in Datadog: The docs.rs Fastly service now sends its logs to Datado

## Generic Const Args and You

DevFeed: [Generic Const Args and You](<https://devfeed.tech/articles/generic-const-args-and-you-63726.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/10/02/generic-const-args-and-you/>)

Author: BoxyUwU

Published: 2026-10-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [generic programming](<https://devfeed.tech/topics/generic-programming.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [generics](<https://devfeed.tech/tags/generics.md>), [implementation](<https://devfeed.tech/tags/implementation.md>)

### AI overview

The post explains Rust's Generic Const Arguments feature family, which aims to replace `generic_const_exprs` and allow more expressions involving generic parameters in const generics. It describes the feature gates, current restrictions, and experimental macroless syntax, noting that the features are not ready for stabilization.

### Source excerpt

Generic Const Args and You Back in June of 2024 at RustFest Zürich, the Const Generics project group first discussed a new design for supporting more complex uses of generic parameters in Const Generics. Since then, we've continued to refine the initial design and have implemented the new design as a family of features dubbed "Generic Const Arguments" (GCA for short). These features are intended to replace the existing generic_const_exprs feature which has existed in some form or another since min_const_generics was stabilized back in 2021. Even though GCA obviates generic_const_exprs it was still incredibly valuable to have invested the time into it that we did as the design and implementation of GCA was informed quite significantly by generic_const_exprs. Each feature in the GCA family introduces support for a specific set of expressions to be used in Const Generics with generic parameters. This post will go over all of the features part of the GCA family and explain their design and how to use them. A huge thanks to @camelid for doing almost all of the initial implementation work for the GCA prototype. Without him GCA would have stayed just a vague concept rather than anything tangible. Additionally, a huge thanks to @khyperia who has done a significant amount of the implementation and design work required to go from the original GCA prototype to the fully featured family that it is now. Finally there have been a tonne of other people who have made contributions to getting GCA to where it is today. For a full list of everyone and all of their contributions, see the Full Const Generics project goal. What is GCA On stable, only generic parameters by themselves (e.g. { N }) or fully concrete constants (e.g. { 1 + 1 }) are supported by Const Generics. It's not possible to have arrays like [u8; T::NUM_BYTES] or [u8; N + 1]. This limitation prevents a lot of useful abstractions and pushes users to rely on the typenum crate instead. Generic Const Arguments is a family o

## 1.99.0 pre-release testing

DevFeed: [1.99.0 pre-release testing](<https://devfeed.tech/articles/1-99-0-pre-release-testing-63455.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/09/29/1.99.0-prerelease/>)

Author: Release automation

Published: 2026-09-29T00:00:00Z

Content type: release

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [release engineering](<https://devfeed.tech/topics/release-engineering.md>), [Release notes](<https://devfeed.tech/topics/release-notes.md>), [Beta channel](<https://devfeed.tech/topics/beta-channel.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [pre-release](<https://devfeed.tech/tags/pre-release.md>), [rust](<https://devfeed.tech/tags/rust.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Rust 1.99.0 is available as a pre-release for testing ahead of its scheduled October 1 release. Users can install it locally and provide feedback through the Rust internals thread or a GitHub issue about the pre-release process.

### Source excerpt

The 1.99.0 pre-release is ready for testing. The release is scheduled for October 1. Release notes can be found here. You can try it out locally by running: RUSTUP_DIST_SERVER=https://dev-static.rust-lang.org rustup update stable The index is https://dev-static.rust-lang.org/dist/2026-09-28/index.html. You can leave feedback on the internals thread. General feedback about our pre-release process is welcome on this GitHub issue.

## Leadership Council update -- September 2026

DevFeed: [Leadership Council update -- September 2026](<https://devfeed.tech/articles/leadership-council-update-september-2026-60737.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/09/28/leadership-council-update/>)

Author: Jakub Beránek

Published: 2026-09-28T00:00:00Z

Content type: news

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Finance](<https://devfeed.tech/topics/finance.md>), [Fedora Council](<https://devfeed.tech/topics/fedora-council.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [contributors](<https://devfeed.tech/tags/contributors.md>), [election](<https://devfeed.tech/tags/election.md>), [elections](<https://devfeed.tech/tags/elections.md>), [foundation](<https://devfeed.tech/tags/foundation.md>), [funding](<https://devfeed.tech/tags/funding.md>), [funds](<https://devfeed.tech/tags/funds.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [language](<https://devfeed.tech/tags/language.md>), [leadership](<https://devfeed.tech/tags/leadership.md>), [library](<https://devfeed.tech/tags/library.md>), [maintainers](<https://devfeed.tech/tags/maintainers.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [moderation](<https://devfeed.tech/tags/moderation.md>), [october](<https://devfeed.tech/tags/october.md>), [process](<https://devfeed.tech/tags/process.md>), [project](<https://devfeed.tech/tags/project.md>), [results](<https://devfeed.tech/tags/results.md>), [september-2026](<https://devfeed.tech/tags/september-2026.md>), [update](<https://devfeed.tech/tags/update.md>)

### AI overview

The Council completed September representative selections: Jakub Beránek and Oli Scherer continue for Infrastructure and Moderation, while Pete LeVasseur represents Language and Mark Rousskov represents Library. The next selections for the other half of the Council are planned for March 2027. Nominations have been gathered for two Rust Project Director positions on the Rust Foundation Board, with the election and announcement still pending. The Council also allocated an additional $120,000 to the Funding team, beyond an earlier $50,000; together with other Maintainers Fund money, this supported seven contributors--five Maintainers in Residence and two Maintenance Grantees. The excerpt says the Council decided to spend the full Project Priorities budget annually rather than retain a buffer, but cuts off before explaining further details.

### Source excerpt

Hello again from the Rust Leadership Council! We wanted to share an update on what the Council has been working on since our last update. Accomplishments so far Welcome Mark Rousskov and Pete LeVasseur to the Council Every six months, the Leadership Council performs a Council representative election, to elect new representatives of several top-level teams. This time, the representatives of the Infrastructure, Language, Library, and Moderation teams were elected. The September representative selections have completed. Here are the results: Jakub Beránek (@kobzol) will continue representing the Infrastructure team Pete LeVasseur (@PLeVassuer) will represent the Language team Mark Rousskov (@Mark-Simulacrum) will represent the Library team Oli Scherer (@oli-obk) will continue representing the Moderation team We welcome Pete and Mark to the Leadership Council! We would also like to thank our outgoing representatives TC and Josh Triplett for their time on the Council. We appreciate your help and support! Thanks to everyone who participated in the process! The next representative selections will be in March 2027 for the other half of the Council. Project Director Elections Same as last year, the Leadership Council has launched an election to select two new Project Directors who will sit on the Rust Foundation Board of Directors (#324). The nominations for the Director positions have been gathered, but the actual election will happen in October. Once we know the two elected Project Directors, we will announce them on the Rust Blog. Rust Foundation Maintainers Fund Since the last update, we decided to allocate an additional $120k to the recently established Funding team (#328), in addition to the $50k which we have already allocated previously. The funding team used this money, together with other funds from the Rust Foundation Maintainers Fund to financially support seven Rust contributors, five Maintainers in Residence and two Maintenance Grantees. Read the announcement b

## Maintainer spotlight: Alejandra González (@blyxyas)

DevFeed: [Maintainer spotlight: Alejandra González (@blyxyas)](<https://devfeed.tech/articles/maintainer-spotlight-alejandra-gonzalez-blyxyas-57496.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/09/21/maintainer-spotlight-alejandra-gonzalez-blyxyas/>)

Author: Jakub Beránek, Lori Lorusso

Published: 2026-09-21T00:00:00Z

Content type: article

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Maintainers](<https://devfeed.tech/topics/maintainers.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [learning](<https://devfeed.tech/tags/learning.md>), [maintainers](<https://devfeed.tech/tags/maintainers.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [spotlight](<https://devfeed.tech/tags/spotlight.md>)

### AI overview

A maintainer spotlight interviews Alejandra González about her path into Rust, her work on the Clippy linter, learning Rust, and helping new contributors. The article also highlights the role of volunteer maintainers in improving the Rust toolchain.

### Source excerpt

There are hundreds of people who maintain the Rust toolchain, often on a volunteer basis on top of another job. The Rust Content team is working on a series of blog posts highlighting some of these prolific contributors to recognize the awesome work that they are doing in order to make Rust better for everyone. You can find the previous post here. Consider donating to the Rust Foundation Maintainers Fund if you'd like to support Rust Project maintainers. In this post, we would like to introduce Alejandra González (@blyxyas). Alejandra started contributing to Rust around four years ago. She primarily works on the Clippy linter as a part of the Clippy team, which she joined in 2023. She is helping other people starting their Rust and Clippy contribution journeys, and recently, she became one of our first Maintainers in Residence! We interviewed Alejandra to find out how she started contributing to Rust, and why she considers performance to be so crucial. Read more below! Can you briefly introduce yourself and your background? Hi, I am Alejandra González, also known as @blyxyas. I was born breathing the mediterranean sea brew, or, in other words, I am from Spain. When I was around thirteen, I thought that I should learn something that will pay off in the long run, and what better than programming? I started with JavaScript and web development, but it didn't feel like my thing, because I like to make fast things, and this technology didn't allow me to do that. I also tried C++ for a while, but didn't like it very much. Then I discovered Rust through a YouTube channel, on the archaic version 1.45, and I was immediately hooked. The borrow checker, traits, macros, it was mind-bending at first, and it felt great. How did you learn Rust? Primarily through Rustlings, which I really like. I think that many programming language learning materials are not that great. They are either extremely beginner, or extremely advanced. Everyone knows what's a loop, they look pretty much id

## Welcome Dongpo and Ross to the Cargo team

DevFeed: [Welcome Dongpo and Ross to the Cargo team](<https://devfeed.tech/articles/welcome-dongpo-and-ross-to-the-cargo-team-15108.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/09/08/welcome-dongpo-and-ross-to-the-cargo-team/>)

Author: Weihang Lo

Published: 2026-09-08T00:00:00Z

Content type: news

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [caching](<https://devfeed.tech/tags/caching.md>), [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

The Rust Project announces Dongpo Liu and Ross Sullivan joining the Cargo team. Ross is leading the 2026 cross-workspace caching goal, while Eric Huss steps down and Jacob Finkelman and Weihang Lo become Cargo's new co-leads.

### Source excerpt

We are excited to welcome Dongpo Liu and Ross Sullivan to the Cargo team! Dongpo has contributed to the Rust Project for years across different teams. He has been an important bridge between Cargo and other Rust teams and has brought insights and fresh ideas from across the Project. Dongpo also integrated cargo info from an external experiment into Cargo as a built-in command. That fulfilled a feature request that was nearly ten years old! He is also a kind and thoughtful reviewer. He always gives careful feedback and takes the time to help contributors. Fun fact: Dongpo joined the team in December 2024, but we never publicly announced it! Ross is brave and a deep thinker. In his first Cargo contributions, he jumped straight into one of Cargo's hardest topics: build artifact management and caching. He has shepherded the new build directory layout through design, implementation, and extensive community testing. This work lays a great foundation for cross-workspace caching and many other future optimizations. He is now leading the 2026 Project Goal for cross-workspace caching! Ross also always takes responsibility for his work. He responds quickly in discussions, fixes regressions, and helps unblock other teams. We are very glad to have him on the team. At the same time, Eric Huss has stepped down from the Cargo team. He contributed to the Rust Project for nearly a decade and served as a Cargo team lead for more than seven years. Eric's fingerprints can be found across basically every part of Cargo. He was our go-to person whenever we needed to understand the history of Cargo. In fact, his work reached far beyond Cargo. He maintained mdBook and books such as the Rust Reference and the Rustonomicon. He also helped lead the Edition work and represented the Dev tools team on the Leadership Council. Cargo and the Rust Project are much better because of him. Thank you, Eric! With Eric stepping down, the Cargo team has selected Jacob Finkelman and Weihang Lo as its new co-l

## 1.98.1 pre-release testing

DevFeed: [1.98.1 pre-release testing](<https://devfeed.tech/articles/1-98-1-pre-release-testing-15107.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/09/02/1.98.1-prerelease/>)

Author: Release automation

Published: 2026-09-02T00:00:00Z

Content type: release

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [releases](<https://devfeed.tech/topics/releases.md>), [Release notes](<https://devfeed.tech/topics/release-notes.md>)

Tags: [pre-release](<https://devfeed.tech/tags/pre-release.md>), [release](<https://devfeed.tech/tags/release.md>), [rust](<https://devfeed.tech/tags/rust.md>), [testing](<https://devfeed.tech/tags/testing.md>), [update](<https://devfeed.tech/tags/update.md>)

### AI overview

The Rust 1.98.1 pre-release is ready for testing and is scheduled for release on September 3. The article provides instructions for trying it locally and links to release notes and feedback channels.

### Source excerpt

The 1.98.1 pre-release is ready for testing. The release is scheduled for September 3. Release notes can be found here. You can try it out locally by running: RUSTUP_DIST_SERVER=https://dev-static.rust-lang.org rustup update stable The index is https://dev-static.rust-lang.org/dist/2026-09-02/index.html. You can leave feedback on the internals thread. General feedback about our pre-release process is welcome on this GitHub issue.

## Program management in July-August 2026

DevFeed: [Program management in July-August 2026](<https://devfeed.tech/articles/program-management-in-july-august-2026-15106.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/08/31/program-management-2026-jul-aug/>)

Author: Nurzhan Saken

Published: 2026-08-31T00:00:00Z

Content type: article

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [funding](<https://devfeed.tech/tags/funding.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [project](<https://devfeed.tech/tags/project.md>), [rust](<https://devfeed.tech/tags/rust.md>), [update](<https://devfeed.tech/tags/update.md>)

### AI overview

The Rust project's July-August 2026 program-management update reports seven newly opened goals, one completed goal, two discontinued goals, and changes in goal funding. It also covers project updates, repository and Zulip channel renaming, improved goal-owner reporting, configurable reminder frequency, and automatic Zulip topic creation for proposed goals.

### Source excerpt

It's been fun since the last update. Tomáš was away for a month, and I had to get my wisdom teeth pulled right after he left. Despite everything, a lot has happened! Project Goals Since the previous update, we've opened seven more goals: Contracts: primitive ownership assertions Process-Safe Rustup Toolchain Operations End-to-End Executable Rust Specification f16b Primitive Type Polymorphic code generation experiment C interop: Complex<T> Allocators 1.0 There's now a roadmap for Binary size reduction, which includes async future and statemachine optimization goals, build-std, and future possibilities that aren't goals yet. One goal was completed (Stabilize Cargo's linting system), and two were discontinued (Experimental language specification and Continue Experimentation with Pin Ergonomics). Several goals have received partial funding (Incremental Systems Rethought, Native async fn dynamic dispatch in traits, and Cargo cross workspace cache), and some are now fully funded (C interop: f80, f128, and c_longdouble, C interop: Complex<T>, and Async statemachine optimization). Don't forget to add your goal to the funding table if it needs funding (see template)! Some goal owners and contributors have been writing about their work beyond the regular goal updates. Here are some of the places to check out: Monthly updates by Hexcat Rust Maintainer Monthly Report: August 2026 by Gen Li Status Update - July 2026 by the BorrowSanitizer team Field Projection Designs by Benno Lossin Four levels of in-place initialization by Yoshua Wuyts Optimizing the new trait solver by Jana Dönszelmann Rust Function Overloading - Call for Experimentation by teor A Vision for a Rust Formal Specification by Nadrieril Infrastructure The Goals repository has been renamed to rust-lang/goals from the verbose rust-lang/rust-project-goals, and we've renamed the Zulip channels to #goals, #goals/proposed, and #goals/meta. The website now lives at goals.rust-lang.org; the old links should redirect there

## Electing new Project Directors 2026

DevFeed: [Electing new Project Directors 2026](<https://devfeed.tech/articles/electing-new-project-directors-2026-15105.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/08/28/electing-new-project-directors-2026/>)

Author: Manish Goregaokar

Published: 2026-08-28T00:00:00Z

Content type: article

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [process](<https://devfeed.tech/tags/process.md>), [project](<https://devfeed.tech/tags/project.md>), [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

The Rust Project has launched its 2026 process to elect two Project Directors to the Rust Foundation Board. Project members are invited to nominate candidates by September 21, with the election following candidate gathering.

### Source excerpt

Today we are launching the process to elect two Project Directors to the Rust Foundation Board of Directors. This is the fourth round of slots, following from last year's election. We will briefly explain the goals and procedures here, but this is mostly copy-pasted from last year's post and the official process documentation. We ask all Project members to begin working with their Leadership Council representative to nominate potential Project Directors. See the candidate gathering section for more details. Nominations are due by September 21. What are Project Directors? The Rust Foundation Board of Directors has five seats reserved for Project Directors. These Project Directors serve as representatives of the Rust Project itself on the Board. Like all directors on the Foundation board, the Project Directors are elected by the entity they represent, which in the case of the Rust Project means they are elected by the Rust Leadership Council. Project Directors serve for a term of two years and will have staggered terms. This year we will appoint two directors and next year we will appoint three directors. See the role description document for more details about what is involved in being a Project Director. The current Project Directors are Carol Nichols, David Wood, Jack Huey, Niko Matsakis, and Ryan Levick. This year, Carol Nichols and Ryan Levick's seats are up for reelection. We want to make sure the Project Directors can effectively represent the Project as a whole, so we are soliciting input from everyone on the team. The elections process will go through two phases: 1) candidate gathering and 2) election. Read on for more detail about how these work. Candidate gathering The first phase is beginning right now. In this phase, we are inviting the members of all of the top level Rust teams and their subteams to nominate people who would make good Project Directors. The goal is to bubble these up to the Council through each of the top-level teams. You should be heari

## 1.98.0 pre-release testing

DevFeed: [1.98.0 pre-release testing](<https://devfeed.tech/articles/1-98-0-pre-release-testing-15103.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/08/19/1.98.0-prerelease/>)

Author: Release automation

Published: 2026-08-19T00:00:00Z

Content type: release

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [releases](<https://devfeed.tech/topics/releases.md>), [Release notes](<https://devfeed.tech/topics/release-notes.md>)

Tags: [pre-release](<https://devfeed.tech/tags/pre-release.md>), [release](<https://devfeed.tech/tags/release.md>), [rust](<https://devfeed.tech/tags/rust.md>), [update](<https://devfeed.tech/tags/update.md>)

### AI overview

This article announces that the Rust 1.98.0 pre-release is ready for testing. It states that the release is scheduled for August 20 and provides instructions and links for trying it and submitting feedback.

### Source excerpt

The 1.98.0 pre-release is ready for testing. The release is scheduled for August 20. Release notes can be found here. You can try it out locally by running: RUSTUP_DIST_SERVER=https://dev-static.rust-lang.org rustup update stable The index is https://dev-static.rust-lang.org/dist/2026-08-18/index.html. You can leave feedback on the internals thread. General feedback about our pre-release process is welcome on this GitHub issue.

## Rust Function Overloading - Call for Experimentation

DevFeed: [Rust Function Overloading - Call for Experimentation](<https://devfeed.tech/articles/rust-function-overloading-call-for-experimentation-15104.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/08/19/overloading-experiment/>)

Author: teor

Published: 2026-08-19T00:00:00Z

Content type: release

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [interoperability](<https://devfeed.tech/topics/interoperability.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [interoperability](<https://devfeed.tech/tags/interoperability.md>), [languages](<https://devfeed.tech/tags/languages.md>), [rust](<https://devfeed.tech/tags/rust.md>), [syntax](<https://devfeed.tech/tags/syntax.md>)

### AI overview

The Rust Project is experimenting with function and method overloading for FFI bindings through the incomplete nightly "splat" compiler feature. The experiment aims to assess implementation complexity and improve interoperability with C++, while its design may change or be removed.

### Source excerpt

In partnership with the Rust Foundation's Rust-C++ Interop Initiative, the Rust Project has been experimenting with function overloading for FFI bindings. This experiment is now at a stage where compiler and interop tool developers can start exploring function overloading. Stable Rust already supports a form of overloading using tuples and traits, but calling these overloaded functions looks strange, because the overloaded arguments have to be passed as a single tuple argument, like this: hypot((2.0, 3.0, 6.0)). Stable Rust also allows overloading of built-in operators with user-defined types, via traits like Add (the + operator) and Neg (the - value negation operator). We are running an unstable nightly Rust language experiment to answer questions like: How much overloading can we do with Rust's existing trait system? Could this help us call C++ from Rust ergonomically? In the tradition of yeet (to avoid bikeshedding), we are using basic syntax in the first stage of the experiment: the #[rustc_splat] attribute. Alternative syntaxes can be considered later, if the experiment generates useful outcomes. Experimental Function Overloading Rust nightly builds from 2026-07-31 onwards have experimental support for more ergonomic function and method overloading, using the incomplete "splat" compiler feature; if you're a compiler or interop tool developer, we encourage you to experiment with it! This experiment lets overloaded functions be called with separate arguments, like this: hypot(2.0, 3.0, 6.0). No double parentheses required! But type inference and type checking still happen as they would in a stable Rust overload. We are experimenting with splat to get a feel for the complexity of the implementation, and to see if it solves some language interoperability use cases. Like most Rust language experiments, this nightly feature has no RFC, and can change or be removed at any time. Experiment Design We expect the feature to change significantly in future, or to be replace

## Experiment in reducing target directory size on nightly

DevFeed: [Experiment in reducing target directory size on nightly](<https://devfeed.tech/articles/experiment-in-reducing-target-directory-size-on-nightly-15102.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/08/18/reducing-target-dir-size-on-nightly/>)

Author: Jakub Beránek

Published: 2026-08-18T00:00:00Z

Content type: article

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [compilation](<https://devfeed.tech/tags/compilation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [disk-space](<https://devfeed.tech/tags/disk-space.md>), [information](<https://devfeed.tech/tags/information.md>), [rust](<https://devfeed.tech/tags/rust.md>), [space](<https://devfeed.tech/tags/space.md>), [state](<https://devfeed.tech/tags/state.md>)

### AI overview

The Cargo Team is testing -Zembed-metadata=no by enabling it by default on the nightly channel. The experiment aims to reduce Rust target directory size by avoiding duplicated crate metadata in build artifacts, while gathering feedback about viability and user impact.

### Source excerpt

TL;DR: The Cargo Team will be rolling out an experiment to identify user impact for a proposed change. Cargo will enable the -Zembed-metadata=no feature on the nightly channel by default, which can help reduce the size of the target directory somewhat. This is an experiment designed to gather feedback about viability of this feature. Users are not expected to migrate to support this feature, but to report any issues and opt-out if needed in the meantime. What is this about? High disk usage of Rust compilation artifacts is frequently cited as one of the biggest annoyances of Rust users. In our 2025 State of Rust survey, it was actually the second most commonly reported problem, right after compilation speed. There are various reasons why the target directory can become quite large, such as: Cargo compiles the whole crate graph from scratch by default, which produces a lot of build artifacts. Debug information takes a lot of disk space. Incremental compilation artifacts take a lot of disk space. While you can disable debug information or incremental compilation to reduce the target directory size, that of course comes with severe trade-offs in compilation speed and debuggability of your program. However, there is one source of data in the target directory that currently takes too much size even though it doesn't really have to. It is the "crate metadata", which can be duplicated across multiple files. We will focus on that in this blog post. What causes duplicated (meta)data For years, Cargo has been using pipelined compilation to speed up building of crate graphs. When compiling a library crate, it tells the compiler to produce an .rmeta file (which contains all the crate metadata required to use this library) as soon as possible, even before having the final executable code available. This enables dependent crates to start compiling sooner. However, once the library does finish compiling, the final produced .rlib file will contain both the executable code and the Ru

## Leadership Council September 2026 Representative Selections

DevFeed: [Leadership Council September 2026 Representative Selections](<https://devfeed.tech/articles/leadership-council-september-2026-representative-selections-15101.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/08/18/leadership-council-repr-selection/>)

Author: Jakub Beránek

Published: 2026-08-18T00:00:00Z

Content type: release

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [leadership](<https://devfeed.tech/tags/leadership.md>), [rust](<https://devfeed.tech/tags/rust.md>), [september-2026](<https://devfeed.tech/tags/september-2026.md>), [teams](<https://devfeed.tech/tags/teams.md>)

### AI overview

The Rust Leadership Council representative selection process is beginning for the Infra, Lang, Libs, and Mods teams. Teams are expected to confirm representatives by September 23, 2026, with new members joining council meetings from September 25.

### Source excerpt

The selection process for representatives on the Leadership Council is starting today. Every six months, half of the council terms end. The following teams are up to choose their representative for the next year: Infra Lang Libs Mods We are aiming to have the teams confirm their choices by September 23, 2026, and for any possible new members to be ready to join the council meetings starting September 25th. Criteria for representatives Any member of the top-level team or a member of any of their subteams is eligible to be the representative. See candidate criteria for a description of what makes a good representative. There is a limit of at most two people affiliated with the same company or other legal entity being on the council 1. During the selection process, the council will consider the affiliation of candidates to decide if all choices will be compatible with that constraint. Representatives may serve multiple terms if the team decides to choose the same representative again. There is a soft limit of three terms.2 It is recommended that teams rotate their representatives if possible to help avoid burnout and to spread the experience to a broader group of people. What do Representatives do? A representative provides a voice on the council to represent the interests of their teams and contribute to the long-term success of the Rust Project. A detailed description of the role may be found at the Representative Role Description. How should teams make their selection? The Leadership Council has put together a Representative Selection Guide with recommendations for teams on how to go about choosing a representative. It is not a requirement that teams follow this guide; top-level teams may choose their own process. See Limits on representatives from a single company/entity ↩ See Term limits. ↩

## June 2026 Project Director Update

DevFeed: [June 2026 Project Director Update](<https://devfeed.tech/articles/june-2026-project-director-update-15100.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/08/17/project-director-update/>)

Author: Carol Nichols and David Wood

Published: 2026-08-17T00:00:00Z

Content type: news

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Security](<https://devfeed.tech/topics/security.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [update](<https://devfeed.tech/tags/update.md>)

### AI overview

The Rust Foundation's June 2026 board update covers policy discussions, committee review, infrastructure security improvements, sustainable funding ideas for crates.io, C++ interoperability work, upcoming Foundation activities, the Trusted Training program, and the Rust Commercial Network.

### Source excerpt

This post covers the Rust Foundation board meeting that took place on June 9, 2026. Find the full June 2026 minutes on the Foundation's site. Highlights include: Abi Broom brought a draft Donation Acceptance Policy to the board for discussion; us Project Directors provided some feedback and gathered some feedback from the Project. The board discussed whether our current subcommittees were serving us, and we agreed to re-evaluate committee membership after Project Director selections in September. The Foundation has successfully distributed hardware 2FA tokens to all relevant Foundation and Project members to improve infrastructure security. The Foundation staff has started brainstorming possible ideas to fund crates.io sustainably in line with the Joint Statement on Sustainable Stewardship signed by many open source languages' package registry maintainers. These ideas are targeting heavy corporate usage and will be discussed with the Project and the Board before implementation. teor held a workshop on C++ interop at the All Hands and has been working on a number of other interop projects. There will be updates soon! The August board meeting will be cancelled, and there will be a hybrid in-person and online board meeting at RustConf in September. The Foundation is also running a Team Health Summit the day before RustConf. The Foundation is planning to coordinate with DARPA to gather an evaluation committee for TRACTOR submissions, which is a contest the board agreed for the Foundation to support in 2024. The Foundation staff and Project Directors will be connecting with the Project in Zulip soon to discuss any questions or comments about this initiative prior to DARPA soliciting Project input/evaluator volunteers. The Foundation launched its Trusted Training program with five initial training partners. The Foundation launched the Rust Commercial Network, a community where the companies and organizations running Rust in production work together, and with the Rust Proj

## Call for testing: Restricting trait implementability and field mutability

DevFeed: [Call for testing: Restricting trait implementability and field mutability](<https://devfeed.tech/articles/call-for-testing-restricting-trait-implementability-and-field-mutability-15099.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/08/10/call-for-testing-impl-and-mut-restrictions/>)

Author: Ryosuke Yamano

Published: 2026-08-10T00:00:00Z

Content type: article

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [rust](<https://devfeed.tech/tags/rust.md>), [scope](<https://devfeed.tech/tags/scope.md>), [sealed](<https://devfeed.tech/tags/sealed.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Rust RFC 3323, "Restrictions," is ready for testing on nightly Rust. It introduces impl_restriction for limiting where traits may be implemented and mut_restriction for limiting where fields may be mutated.

### Source excerpt

We are excited to announce that RFC 3323 "Restrictions" is ready for testing on nightly Rust. In this post, we will briefly describe the features. If you are already familiar with them, you can skip ahead to the How can I help? section. The RFC is split into two features: impl_restriction and mut_restriction. What is impl_restriction? The impl_restriction feature allows explicit restriction of the scope in which a trait may be implemented. For example, consider a trait Foo with a method that we want users to be able to call, while preventing downstream crates from providing their own implementations. With this feature, we can write: #![feature(impl_restriction)] pub impl(crate) trait Foo { fn method(); } impl Foo for usize { fn method() {} } The impl(crate) restriction prevents Foo from being implemented outside the current crate. As with pub, other paths can also be specified, such as impl(super) or impl(in path). Without this feature, this use case is typically handled using the sealed trait pattern, which is described in the Rust API Guidelines. In short, this pattern defines a public Sealed trait inside a private module and makes it a supertrait of Foo. Because downstream crates cannot name Sealed, they cannot implement Foo. pub trait Foo: private::Sealed { fn method(); } // Implement `Foo` for selected types. impl Foo for usize { fn method() {} } mod private { pub trait Sealed {} // Implement `Sealed` for those same types, but no others. impl Sealed for usize {} } However, this pattern requires defining an additional Sealed trait. The new impl_restriction feature provides a more direct and concise way to express the same restriction. The feature also allows the compiler to produce a more direct error message when an implementation is attempted outside the permitted scope. For example, the following code: #![feature(impl_restriction)] pub mod foo { pub mod bar { pub(crate) impl(super) trait Foo {} } // `Foo` may be implemented here. impl bar::Foo for i8 {} } //