# Rust

Empowering everyone to build reliable and efficient software.

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

## Enabling the parallel frontend on nightly

DevFeed: [Enabling the parallel frontend on nightly](<https://devfeed.tech/articles/enabling-the-parallel-frontend-on-nightly-136105.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/11/16/enabling-parallel-frontend-on-nightly/>)

Author: Jakub Beránek

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

Content type: release

Language: en

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

Topics: [Parallelism](<https://devfeed.tech/topics/parallelism.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [benefit](<https://devfeed.tech/tags/benefit.md>), [channel](<https://devfeed.tech/tags/channel.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compile](<https://devfeed.tech/tags/compile.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [contributors](<https://devfeed.tech/tags/contributors.md>), [faster](<https://devfeed.tech/tags/faster.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [graph](<https://devfeed.tech/tags/graph.md>), [limits](<https://devfeed.tech/tags/limits.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [multiple](<https://devfeed.tech/tags/multiple.md>), [nightly](<https://devfeed.tech/tags/nightly.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

Rust has enabled its parallel compiler frontend by default on nightly since nightly-2026-11-14 to uncover issues ahead of possible stabilization; stable remains sequential. The frontend handles type and borrow checking. Nightly starts with 2 threads, configurable via `--jobs-frontend`; 8 threads nearly tripled `cargo check` speed for some individual crates and improved whole-graph checking of `cargo` by about 15% on an 8-core machine. Incremental rebuild gains averaged 3-5% in the available benchmarks, which the article says are limited. Results vary with workload and CPU saturation, and more threads can increase memory use or cause out-of-memory failures. Diagnostic order may vary, and some reproducibility issues are known. Nightly users can opt out with `-Zunstable-options --jobs-frontend=1`. The project plans to monitor reports and continue performance and parallelism work before stabilization.

### Source excerpt

TL;DR: We are enabling the parallel frontend of the Rust compiler on nightly by default, to find remaining issues in preparation for its stabilization. Context The Rust compiler has been using multiple threads to compile code in its "backend" part (using LLVM) for a long time. However, its "frontend" part (which includes type checking and borrow checking) has been executing sequentially, on a single thread, which of course limits the performance of the compiler. If you are interested in a more in-depth explanation of parallelism in the Rust compiler, see this previous post. The compiler frontend actually had support for running in parallel for a long time, but it was not enabled by default due to various issues. Three years ago, we made it possible to opt into the parallel frontend on the nightly channel, with the plan to stabilize it in 2024. Clearly, we did not achieve that goal, but work on the parallel frontend was still slowly progressing in the meantime. Last year, Vadim Petrochenkov, together with several other contributors, started a coordinated effort to finally get the parallel frontend over the finish line. Since then, many long-standing issues were fixed, and its performance was improved. Now we are at a point where we would like to make it widely available. But before that, we want to find out if people encounter issues with it in the wild, which is why we are enabling it by default only on the nightly channel. Once we will be confident enough that it is working well, we want to stabilize it. The parallel frontend has been enabled on the nightly channel by default since nightly-2026-11-14. Benefits The primary benefit of enabling the parallel frontend is, of course, faster compilation of Rust programs. We benchmarked the parallel frontend in our benchmark suite, which measures the duration to compile the leaf crate in a crate graph. As usual, the results were varied. In some benchmarks, the parallel frontend barely helped. In others, for example when pe

## Announcing Rust 1.100.0

DevFeed: [Announcing Rust 1.100.0](<https://devfeed.tech/articles/announcing-rust-1-100-0-130818.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/>)

Author: The Rust Release Team

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

Content type: release

Language: en

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

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

Tags: [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [build](<https://devfeed.tech/tags/build.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cargo](<https://devfeed.tech/tags/cargo.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [exit](<https://devfeed.tech/tags/exit.md>), [flow](<https://devfeed.tech/tags/flow.md>), [functions](<https://devfeed.tech/tags/functions.md>), [language](<https://devfeed.tech/tags/language.md>), [release](<https://devfeed.tech/tags/release.md>), [releases](<https://devfeed.tech/tags/releases.md>), [return](<https://devfeed.tech/tags/return.md>), [rust](<https://devfeed.tech/tags/rust.md>), [stabilization](<https://devfeed.tech/tags/stabilization.md>), [stable](<https://devfeed.tech/tags/stable.md>), [testing](<https://devfeed.tech/tags/testing.md>), [type](<https://devfeed.tech/tags/type.md>), [types](<https://devfeed.tech/tags/types.md>), [zero](<https://devfeed.tech/tags/zero.md>)

### AI overview

Rust 1.100.0 stabilizes the never type (`!`), allowing it to be named anywhere and making `Infallible` an alias; the change also alters never-type fallback to `!` in Rust 2015, 2018, and 2021, which may expose rare compatibility issues. The core `Allocator` API is stable for use with `Vec` and `Box`, with broader collection support still pending. New `core::mem::DropGuard` runs a closure when dropped and can roll back mutations unless dismissed, while unsafe `std::mem::conjure_zst` provides a dedicated way to create zero-sized values. Cargo now warns about unused dependencies, subject to build-target coverage limits, reorganizes build directories to apply configuration hashes consistently, and supports minimum package publish ages during dependency resolution. Publish-age filtering requires registry timestamps, does not apply to `cargo install`, and can be overridden for an individual update. Install the release with `rustup update stable`.

### Source excerpt

The Rust team is happy to announce a new version of Rust, 1.100.0. Rust is a programming language empowering everyone to build reliable and efficient software. If you have a previous version of Rust installed via rustup, you can get 1.100.0 with: $ rustup update stable If you don't have it already, you can get rustup from the appropriate page on our website, and check out the detailed release notes for 1.100.0. If you'd like to help us out by testing future releases, you might consider updating locally to use the beta channel (rustup default beta) or the nightly channel (rustup default nightly). Please report any bugs you might come across! What's in 1.100.0 stable Never type Allocator API DropGuard API Conjuring zero-sized types Reporting unused dependencies in Cargo Reducing Cargo cache collisions Cargo min-publish-age Stabilized APIs Never type After 10 years and 5 failed stabilization attempts, the never type is finally stable! This also completes the project goal for this work. The never type, spelled ! in code, is the canonical uninhabited type. It represents the type of diverging computations - computations which never resolve to any value - where any code that follows is unreachable. Expressions that terminate control flow, such as return, break, and std::process::exit, also have the type !. Since having a value of the never type is impossible, Rust permits a never-to-any coercion, allowing to turn ! into any other type (this is what distinguishes it from any other uninhabited types). This can be used, for example, to not return a value from one of the branches of a match or an if: fn mrrrow(option: Option<u32>) { let value = match option { // `x` has type `u32` Some(x) => x, // `return` has type `!`, which is then coerced to `u32`, // allowing the `match` to pass type checking. None => return, }; // ... } While the never type could already be used and observed this way, and even named in the return type of functions (-> !), this release allows naming the ne

## Google Summer of Code 2026 results

DevFeed: [Google Summer of Code 2026 results](<https://devfeed.tech/articles/google-summer-of-code-2026-results-129369.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/11/11/gsoc-2026-results/>)

Author: Jakub Beránek

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

Content type: news

Language: en

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

Topics: [Bootcamp](<https://devfeed.tech/topics/bootcamp.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [contributors](<https://devfeed.tech/tags/contributors.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [google](<https://devfeed.tech/tags/google.md>), [google-summer-of-code](<https://devfeed.tech/tags/google-summer-of-code.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [mentoring](<https://devfeed.tech/tags/mentoring.md>), [project](<https://devfeed.tech/tags/project.md>), [projects](<https://devfeed.tech/tags/projects.md>), [publishing](<https://devfeed.tech/tags/publishing.md>), [results](<https://devfeed.tech/tags/results.md>), [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

All 13 Rust Project Google Summer of Code 2026 projects passed final evaluation, despite fewer projects than in 2025 due mainly to limited mentoring capacity. Work included safer GPU offloading, WebAssembly linking in Wild, Rust compiler CI support for autodiff and offload, a Miri debugger, new impl and mut restrictions, and improvements to libc, rust-analyzer, compiler tests, debuginfo testing, and rustup. Wild's Wasm linker was reported 2-15x faster and used 2-5x less memory than wasm-ld; its Linux kernel module linking was 2-4x faster than BFD or LLD. Some work remains: the rust-analyzer migration is incremental, one std::arch test suite is still unported, and serialport changes await integration for version 5.0. The program paired contributors with mentors through ongoing guidance and review, and the Rust Project expects to participate again.

### Source excerpt

The Rust Project participated in Google Summer of Code (GSoC) for the third time this year. This time we had 13 projects, and our dear contributors have been working very hard on them for several months. As usual, the projects had various durations, so while some of them have ended in August, the last one has only finished in November, so we have been waiting until we have all the results before publishing this blog post. We are very happy to announce that all 13 projects were successful and passed their final evaluation! We consider it to be a testament to the diligence of our contributors, and the helpfulness of our mentors, that we are able to keep a very high rate[1] of successful GSoC projects several years in a row. At the start of summer, we had a video call with our contributors, so that we could all get to know each other a bit, and learn about their projects. Over the following few months, we continuously communicated with the contributors, provided guidance and answered their questions and reviewed their pull requests. And most importantly, we learned many new things together! It was an overall great experience. We are grateful for all Rust contributions done by our GSoC participants and for the time we spent working together, and we hope that we will continue seeing at least some of them around in the future. We would like to thank all our Rust GSoC 2026 contributors. You did a great job! Even though this year we had fewer projects than in 2025, mostly due to limited mentoring capacity, Google Summer of Code 2026 was again a success for the Rust Project. We think that GSoC is a great way of introducing new contributors to our community, and we are looking forward to participating in GSoC (and other mentorship programs, such as Outreachy) again in the near future. If you are interested in becoming a (GSoC) contributor, check out our GSoC project idea list and our guide for new contributors. Below you can find a brief summary of our GSoC 2026 projects. You

## Announcing rustup 1.29.3

DevFeed: [Announcing rustup 1.29.3](<https://devfeed.tech/articles/announcing-rustup-1-29-3-116434.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/11/03/Rustup-1.29.3/>)

Author: The Rustup Team

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

Content type: release

Language: en

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

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

Tags: [automatically](<https://devfeed.tech/tags/automatically.md>), [cpus](<https://devfeed.tech/tags/cpus.md>), [download](<https://devfeed.tech/tags/download.md>), [error](<https://devfeed.tech/tags/error.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [illegal](<https://devfeed.tech/tags/illegal.md>), [init](<https://devfeed.tech/tags/init.md>), [lock](<https://devfeed.tech/tags/lock.md>), [malware](<https://devfeed.tech/tags/malware.md>), [malware-scanners](<https://devfeed.tech/tags/malware-scanners.md>), [patch](<https://devfeed.tech/tags/patch.md>), [point](<https://devfeed.tech/tags/point.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rustup](<https://devfeed.tech/tags/rustup.md>), [scanners](<https://devfeed.tech/tags/scanners.md>), [solaris](<https://devfeed.tech/tags/solaris.md>), [toolchain](<https://devfeed.tech/tags/toolchain.md>), [update](<https://devfeed.tech/tags/update.md>), [x86-64](<https://devfeed.tech/tags/x86-64.md>)

### AI overview

Rustup 1.29.3 fixes an "Illegal instruction" error on some x86_64 CPUs without SSE4.1 and a "lock() not supported" error on Solaris. To update, stop programs that may be using rustup and run `rustup self update`; `rustup update` also updates rustup after a toolchain update. If self-update fails, the source describes manually replacing the rustup binary with the platform's `rustup-init`, after ensuring no other rustup processes are running. Anti-malware scanners may temporarily block file operations, especially when installing rust-docs.

### Source excerpt

The rustup team has published a new point release of rustup, 1.29.3. Rustup is the recommended tool to install Rust, a programming language that empowers everyone to build reliable and efficient software. What's new in rustup 1.29.3 This new patch release has fixed some minor regressions over the previous one: Fixed "Illegal instruction" error on certain x86_64 CPUs without SSE4.1. pr#5162 Fixed "lock() not supported" error on Solaris. pr#5167 Further details are available in the changelog! How to update If you have a previous version of rustup installed, getting the new one is as easy as stopping any programs which may be using rustup (e.g. closing your IDE) and running: $ rustup self update Rustup will also automatically update itself at the end of a normal toolchain update: $ rustup update For this particular release, if you have encountered any issues during self-update, you may try to update rustup manually by following the steps below: Download the corresponding rustup-init binary for your platform. Make double sure that no other rustup processes are running. Replace your existing rustup binary with the downloaded rustup-init renamed to rustup. As a reminder, this binary is often located at $HOME/.cargo/bin/rustup, or $CARGO_HOME/bin/rustup if you have overridden the $CARGO_HOME environment variable. If you don't have it already, you can get rustup from the appropriate page on our website. Rustup's documentation is also available in the rustup book. Caveats Rustup releases can come with problems not caused by rustup itself but just due to having a new release. In particular, anti-malware scanners might block rustup or stop it from creating or copying files, especially when installing rust-docs which contains many small files. Issues like this should be automatically resolved in a few weeks when the anti-malware scanners are updated to be aware of the new rustup release. Thanks Thanks again to all the contributors who made this rustup release possible!

## How to fund Rust contributors

DevFeed: [How to fund Rust contributors](<https://devfeed.tech/articles/how-to-fund-rust-contributors-100415.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/10/26/how-to-fund-rust-contributors/>)

Author: Jakub Beránek

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

Content type: tutorial

Language: en

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

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [open source maintenance](<https://devfeed.tech/topics/open-source-maintenance.md>), [Maintainers](<https://devfeed.tech/topics/maintainers.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Finance](<https://devfeed.tech/topics/finance.md>)

Tags: [contributors](<https://devfeed.tech/tags/contributors.md>), [development](<https://devfeed.tech/tags/development.md>), [features](<https://devfeed.tech/tags/features.md>), [foundation](<https://devfeed.tech/tags/foundation.md>), [funding](<https://devfeed.tech/tags/funding.md>), [github](<https://devfeed.tech/tags/github.md>), [github-sponsors](<https://devfeed.tech/tags/github-sponsors.md>), [goals](<https://devfeed.tech/tags/goals.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [maintainers](<https://devfeed.tech/tags/maintainers.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [open-source-projects](<https://devfeed.tech/tags/open-source-projects.md>), [rust](<https://devfeed.tech/tags/rust.md>), [sponsor](<https://devfeed.tech/tags/sponsor.md>)

### AI overview

The article recommends three ways to fund Rust contributors: support general maintenance through the Rust Foundation Maintainers Fund or RustNL Maintainers Team; sponsor fundable Rust Project Goals to advance specific features or toolchain improvements; or donate directly to individual contributors through options such as GitHub Sponsors. Maintenance funding supports ongoing housekeeping, dependency updates, issue and security triage, refactoring, and code review, which the article says can help features ship faster over time. Project Goal funding can pay for focused development as well as maintenance work needed to unblock and review features; funded Goals are more likely to meet milestones. Direct support lets donors choose contributors whose work they value. Companies can contact the Funding team or join the free Rust Commercial Network to find and coordinate funding opportunities. The excerpt also notes non-donation options, including paid employee contribution time and hiring contributors.

### Source excerpt

TLDR: To fund general maintenance, donate to the Rust Foundation Maintainers Fund or sponsor the RustNL Maintainers Team To fund specific features and improvements, sponsor fundable Rust Project Goals To fund individual contributors, donate to their GitHub Sponsors accounts There is always so much to do in the Rust Project! New features to implement, bugs to fix, performance optimizations to make, issues to triage... It takes a lot of work to keep our high bar of quality while also shipping new features and improvements. And the workload keeps increasing with the continuous growth of Rust adoption. As is unfortunately common in open source projects, a large fraction of that work is currently done by volunteers. That causes various issues, such as people burning out or complex features taking many years to ship. Unsurprisingly, one of the best ways to help improve that is to get more people who work on Rust funded! This year, several funding initiatives started ramping up, and we already experience many positive effects. They helped us improve the maintenance status of critical Rust projects and make significant progress on several long-awaited features, such as allocators, the never type, the next trait solver or the Polonius borrow checker. However, only a fraction of people working on Rust are currently funded for their work. We know that there are Rust users, both individuals and companies, who would like to help improve Rust by funding it, but it might not always be obvious how exactly to do that. This post thus provides suggestions on how you can support the development of Rust in three ways. If you're unsure which option fits, or would like to discuss funding on behalf of your company, please contact the Funding team. Fund general maintenance Maintenance is a continuous process required to keep Rust (or any software project for that matter) working. It consists of two main activities. The first is general housekeeping, such as ensuring that Continuous Integratio

## Announcing rustup 1.29.2

DevFeed: [Announcing rustup 1.29.2](<https://devfeed.tech/articles/announcing-rustup-1-29-2-92719.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/10/20/Rustup-1.29.2/>)

Author: The Rustup Team

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

Content type: release

Language: en

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

Topics: [project release](<https://devfeed.tech/topics/project-release.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [software composition analysis](<https://devfeed.tech/topics/software-composition-analysis.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [cve](<https://devfeed.tech/tags/cve.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [details](<https://devfeed.tech/tags/details.md>), [malware](<https://devfeed.tech/tags/malware.md>), [malware-scanners](<https://devfeed.tech/tags/malware-scanners.md>), [release](<https://devfeed.tech/tags/release.md>), [rust](<https://devfeed.tech/tags/rust.md>), [toolchain](<https://devfeed.tech/tags/toolchain.md>), [update](<https://devfeed.tech/tags/update.md>), [what-s-new](<https://devfeed.tech/tags/what-s-new.md>)

### AI overview

rustup 1.29.2 is a small release that updates the rustls-webpki and webpki-root-certs dependencies to address the eMudhra intermediate certificates issue cited in CVE-2026-111943 and RUSTSEC-2026-0382. To update an existing installation, stop programs using rustup and run `rustup self update`; rustup also updates itself after `rustup update`. The source notes that anti-malware scanners may temporarily block rustup or file operations, especially when installing rust-docs.

### Source excerpt

The rustup team is happy to announce the release of rustup version 1.29.2. Rustup is the recommended tool to install Rust, a programming language that empowers everyone to build reliable and efficient software. What's new in rustup 1.29.2 This is a small release which only updates the rustls-webpki and webpki-root-certs dependencies to address the problematic eMudhra intermediate certificates issue described in CVE-2026-111943. See also RUSTSEC-2026-0382. Further details are available in the changelog! How to update If you have a previous version of rustup installed, getting the new one is as easy as stopping any programs which may be using rustup (e.g. closing your IDE) and running: $ rustup self update Rustup will also automatically update itself at the end of a normal toolchain update: $ rustup update If you don't have it already, you can get rustup from the appropriate page on our website. Rustup's documentation is also available in the rustup book. Caveats Rustup releases can come with problems not caused by rustup itself but just due to having a new release. In particular, anti-malware scanners might block rustup or stop it from creating or copying files, especially when installing rust-docs which contains many small files. Issues like this should be automatically resolved in a few weeks when the anti-malware scanners are updated to be aware of the new rustup release. Thanks Thanks again to all the contributors who made this rustup release possible!

## Announcing Rust 1.99.1

DevFeed: [Announcing Rust 1.99.1](<https://devfeed.tech/articles/announcing-rust-1-99-1-88066.md>)

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

Author: The Rust Release Team

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

Content type: release

Language: en

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

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [D](<https://devfeed.tech/topics/d.md>)

Tags: [bugs](<https://devfeed.tech/tags/bugs.md>), [ffi](<https://devfeed.tech/tags/ffi.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [macos](<https://devfeed.tech/tags/macos.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rust-1-99](<https://devfeed.tech/tags/rust-1-99.md>), [uefi](<https://devfeed.tech/tags/uefi.md>)

### AI overview

Rust 1.99.1 is a point release that fixes regressions involving missing `wcslen` symbols, x86_64 FFI `bool` return values, and rust-lld's ability to load libLLVM on macOS. The announcement also suggests testing future releases on the beta and nightly channels.

### Source excerpt

The Rust team has published a new point release of Rust, 1.99.1. Rust is a programming language that is empowering everyone to build reliable and efficient software. If you have a previous version of Rust installed via rustup, getting Rust 1.99.1 is as easy as: rustup update stable If you don't have it already, you can get rustup from the appropriate page on our website. What's in 1.99.1 Rust 1.99.1 fixes the following regressions from prior releases: Missing symbol wcslen: Some Rust targets were getting link errors for missing wcslen, and that function is now present in Rust's compiler-builtins library as a fallback. The LLVM loop-idiom-wcslen pass may introduce calls to wcslen as an optimization, and some Rust targets did not have that function readily available in libc or elsewhere. The UEFI targets in particular were broken for any project using std, as some of these calls were introduced in the precompiled standard library, but the issue was also reproducible for similar user code patterns. Miscompilation of FFI bool return values on x86_64: Rust functions returning bool through FFI could leave bits 1-7 of the return register unspecified, causing callers to observe raw values other than 0 or 1. This return type is now marked for zero-extension again, as required by the ABI. rust-lld failed to load libLLVM on macOS: This linker could fail to run if the compiler was invoked without the rustup proxy, as there was no direct setting for the appropriate library search path. Now rust-lld is built with an rpath entry for the directory containing libLLVM.dylib. If you'd like to help us out by testing future releases, you might consider using the beta (rustup default beta) and nightly (rustup default nightly) channels locally and in your CI. Please report any bugs you might come across! Contributors to 1.99.1 Many people came together to create Rust 1.99.1. We couldn't have done it without all of you. Thanks!

## Demoting i686 Windows targets to std-only

DevFeed: [Demoting i686 Windows targets to std-only](<https://devfeed.tech/articles/demoting-i686-windows-targets-to-std-only-63719.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/10/02/demoting-i686-windows-targets-to-std-only/>)

Author: Mateusz Mikuła, Ralf Jung

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

Content type: release

Language: en

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

Topics: [Cross-Compilation](<https://devfeed.tech/topics/cross-compilation.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>), [MSVC](<https://devfeed.tech/topics/msvc.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [ci](<https://devfeed.tech/tags/ci.md>), [cross](<https://devfeed.tech/tags/cross.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [rust](<https://devfeed.tech/tags/rust.md>), [target](<https://devfeed.tech/tags/target.md>), [toolchain](<https://devfeed.tech/tags/toolchain.md>), [toolchains](<https://devfeed.tech/tags/toolchains.md>), [x86](<https://devfeed.tech/tags/x86.md>), [x86-64](<https://devfeed.tech/tags/x86-64.md>)

### AI overview

Rust 1.100 will demote its i686 Windows MSVC and GNU targets to tiers without host tools. Standard library builds will remain available, and the MSVC target will continue to receive CI testing. Developers will need to cross-compile 32-bit Windows binaries from a supported host; other 32-bit platforms are unaffected.

### Source excerpt

With Rust 1.100.0, the following changes to 32-bit Windows targets will happen: i686-pc-windows-msvc Tier 1 with host tools target will be demoted to Tier 1 without host tools. i686-pc-windows-gnu Tier 2 with host tools target will be demoted to Tier 2 without host tools. Builds of the standard library will continue to be distributed, but host tools such as the compiler will be no longer available. i686-pc-windows-msvc as a Tier 1 target still undergoes CI testing. To build 32-bit Windows binaries, cross-compiling from a still-supported host toolchain (such as a 64-bit Windows ones) will be required from now on. Background Desktop and Server 32-bit only x86 CPUs are no longer sold for over 15 years, and general 32-bit Windows support has ended in October 2025. This means that the development platforms these targets are meant for hardly exist these days, and even if they do exist they typically aren't capable enough for development. Even on the modern x86_64 hardware, building i686 Windows toolchains has proven to be problematic. We have encountered compiler binaries crashing when built with the i686 MSVC target, and the GNU C++ toolchain failing with OOMs during LLVM build. Considering all these things, cross-compiling these targets from a better supported one is what we have found to be the best solution forward. As part of that, we stopped producing host tools for these targets. For the time being, the prebuilt standard library is still available, and in case of i686-pc-windows-msvc still tested on CI. What Changes? After Rust 1.100, it will no longer be possible to install toolchains on 32-bit Windows hosts. We recommend cross-compiling from a still-supported host (such as a 64-bit Windows toolchain) instead. Other 32-bit platforms are not impacted by this change. For more details about these demotions, see RFC 3999 for i686-pc-windows-msvc demotion, and MCP 1020 for i686-pc-windows-gnu demotion.

## Announcing Rust 1.99.0

DevFeed: [Announcing Rust 1.99.0](<https://devfeed.tech/articles/announcing-rust-1-99-0-63442.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/10/01/Rust-1.99.0/>)

Author: The Rust Release Team

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

Content type: release

Language: en

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

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

Tags: [assembly](<https://devfeed.tech/tags/assembly.md>), [libc](<https://devfeed.tech/tags/libc.md>), [pointers](<https://devfeed.tech/tags/pointers.md>), [release](<https://devfeed.tech/tags/release.md>), [rust](<https://devfeed.tech/tags/rust.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Rust 1.99.0 stabilizes C-ABI variadic function definitions and naked variadic functions with non-C ABIs. It also settles safety requirements for size and alignment queries on raw pointers and updates Box::leak documentation to discourage later deallocation patterns due to interactions with compiler optimizations and upcoming custom allocators.

### Source excerpt

The Rust team is happy to announce a new version of Rust, 1.99.0. Rust is a programming language empowering everyone to build reliable and efficient software. If you have a previous version of Rust installed via rustup, you can get 1.99.0 with: $ rustup update stable If you don't have it already, you can get rustup from the appropriate page on our website, and check out the detailed release notes for 1.99.0. If you'd like to help us out by testing future releases, you might consider updating locally to use the beta channel (rustup default beta) or the nightly channel (rustup default nightly). Please report any bugs you might come across! What's in 1.99.0 stable extern "C" variadics Rust 1.99.0 stabilizes defining C-ABI variadic functions with "C" and "C-unwind" ABIs. Variadic functions defined this way use a variable argument list (...) and accept an arbitrary number of arguments. Rust could already call externally-defined variadic functions (e.g., libc::printf). With Rust 1.99, these functions can now be written in Rust itself: /// SAFETY: must be called with (at least) 2 i32 arguments. unsafe extern "C" fn sum(mut args: ...) -> i32 { // SAFETY: guaranteed by the caller. let a = unsafe { args.next_arg::<i32>() }; let b = unsafe { args.next_arg::<i32>() }; a + b } fn foo() -> i32 { unsafe { sum(0i32, 2i32) } } The type of ... is VaList, which is ABI-compatible with the C va_list type across targets. What types can be read from a VaList is guarded by the VaArgSafe trait. For more details on c-variadic functions, see the Reference. This release also stabilizes support for defining naked variadic functions with non-"C" ABIs, which must be written via inline assembly. Layout information from raw pointers This release settles the safety requirements for retrieving the size and alignment on raw pointers to both Sized (trivially safe, already possible on stable) and non-Sized types. This is done by stabilizing three functions: Layout::for_value_raw mem::size_of_val_raw mem

## Announcing a Maintainer in Residence: Scott Schafer for the Cargo team

DevFeed: [Announcing a Maintainer in Residence: Scott Schafer for the Cargo team](<https://devfeed.tech/articles/announcing-a-maintainer-in-residence-scott-schafer-for-the-cargo-team-58114.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/09/22/announcing-a-maintainer-in-residence-scott-schafer-for-the-cargo-team/>)

Author: Jakub Beránek

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

Content type: release

Language: en

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

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Maintainers](<https://devfeed.tech/topics/maintainers.md>), [Tech Debt](<https://devfeed.tech/topics/tech-debt.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>)

Tags: [leadership](<https://devfeed.tech/tags/leadership.md>), [maintainers](<https://devfeed.tech/tags/maintainers.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [rust](<https://devfeed.tech/tags/rust.md>), [tech-debt](<https://devfeed.tech/tags/tech-debt.md>)

### AI overview

The Rust Project announces Scott Schafer as a full-time Maintainer in Residence for Cargo. Funded through the Rust Foundation Maintainers Fund with support from the Rust Leadership Council and AWS, the role will help address Cargo's maintenance workload, technical debt, refactoring needs, and backlog.

### Source excerpt

At the end of August, we announced our first Maintainers in Residence, Rust Project contributors who are funded for their upstream contributions and maintenance work from the Rust Foundation Maintainers Fund (RFMF). Since then, the Rust Leadership Council has dedicated more funds from its Project Priorities budget to RFMF, and together with AWS also providing additional funds, this allowed us to open a new full-time Maintainer in Residence (MiR) position to support the Cargo team. We would like to thank the Rust Leadership Council, AWS, and also the Rust Foundation for providing us with this opportunity! If you would like to help us hire more maintainers to improve Rust, consider donating to RFMF. This post explains why we chose to support the Cargo team specifically, and introduces Scott Schafer, the new Cargo Maintainer in Residence. Why Cargo? The new MiR full-time position is dedicated to helping with the maintenance of Cargo, our build system and package manager. The Cargo project is deeply involved in many new Rust features, improvements, and Project Goals. Combined with its cross-cutting nature, where it has to support many different use-cases and integrate with several other tools, it takes a lot of work just to keep up with its maintenance needs, let alone support so many feature requests and proposed changes. Because of that, the Cargo team has sometimes struggled with meeting its maintenance demands. You might remember that for several years, it actually held a feature freeze, to reduce Cargo's internal tech debt, perform necessary refactorings, go through the issue and pull request backlog, and come up with scalable internal development and design processes, so that they could eventually go back to even thinking about adding new features. Recently, some changes occurred within the team, which made it more difficult for them to meet their maintenance baseline. Some members of the team left, while others lost their dedicated funding for working on Cargo ma

## GitHub Actions leaking secrets when Miri output is cached

DevFeed: [GitHub Actions leaking secrets when Miri output is cached](<https://devfeed.tech/articles/github-actions-leaking-secrets-when-miri-output-is-cached-57487.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/09/21/github-actions-leaking-secrets-when-miri-output-is-cached/>)

Author: Manish Goregaokar

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

Content type: news

Language: en

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

Topics: [Cache](<https://devfeed.tech/topics/cache.md>), [GitHub Actions](<https://devfeed.tech/topics/github-actions.md>), [Security](<https://devfeed.tech/topics/security.md>), [Environment Variables](<https://devfeed.tech/topics/environment-variables.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Repository](<https://devfeed.tech/topics/repository.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [environment-variables](<https://devfeed.tech/tags/environment-variables.md>), [github](<https://devfeed.tech/tags/github.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [run](<https://devfeed.tech/tags/run.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

The Rust Security Response Team warns that Miri can store all environment variables in target/, allowing secrets to persist when that directory is cached in GitHub Actions. Pull requests may then access those cached secrets. The short-term fix limits preserved variables to selected CARGO_* variables and OUT_DIR, while maintainers are advised to review affected workflows.

### Source excerpt

The Rust Security Response Team was notified that Miri stores all environment variables to target/, allowing secrets to persist in caches. While not necessary a vulnerability in and of itself, when paired with GitHub Actions caching behavior, it is possible for this to expose secrets to PRs. Overview GitHub Actions makes it possible to cache directories between runs. Typical setups allow CI runs on main (and other branches) to write to cache, and PRs can only read from cache (preventing cache poisoning). Rust projects tend to speed up CI by caching binaries built by cargo install and sometimes the contents of target/. PR CI can be triggered by anyone who can open PRs on your repository. GitHub requires maintainer approval for the first PR, but future PRs will rerun CI on every push. Anyone who has previously landed a change can trigger a CI run extracting information from cached target/ and then cover their tracks by pushing a second commit to the PR. GitHub sometimes hides overwritten commits in its UI, making this kind of attack harder to detect. CI run logs and overwritten commits are also deleted after a few months. When cargo miri is invoked, Miri needs to retain build-relevant environment variables between runs1. The current code to do so achieves this by storing all environment variables to target/. This, of course, persists when target/ is cached. If your environment contained secrets, these can now be accessed by PRs via the cache. Our fix Our short term fix for this is to make Miri only preserve CARGO_* environment variables (excepting CARGO_*_TOKEN) and OUT_DIR. In the longer term, Miri and cargo may figure out better ways to inform Miri of the relevant list of environment variables. Note that this patch may not be available on nightly yet. We also performed an ecosystem scan of GitHub repositories and identified 1 repository with this issue and 7 repositories that do not appear to be vulnerable but should be cautious anyway. We have reached out to those

## Be alert: targeted attacks on prominent Rustaceans

DevFeed: [Be alert: targeted attacks on prominent Rustaceans](<https://devfeed.tech/articles/be-alert-targeted-attacks-on-prominent-rustaceans-42155.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/09/17/targeted-attacks/>)

Author: Adam Harvey

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

Content type: news

Language: en

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

Topics: [Security](<https://devfeed.tech/topics/security.md>), [Malware](<https://devfeed.tech/topics/malware.md>), [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [attacks](<https://devfeed.tech/tags/attacks.md>), [developers](<https://devfeed.tech/tags/developers.md>), [malware](<https://devfeed.tech/tags/malware.md>), [mfa](<https://devfeed.tech/tags/mfa.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

The Rust project warns of an ongoing campaign targeting Rust community members and maintainers of popular crates. Attackers use seemingly legitimate job or project outreach, video calls, fake company profiles, and malicious commands or software to compromise devices and accounts and publish malware. The advisory recommends using trusted call platforms, checking account activity, and enabling MFA.

### Source excerpt

We believe that there is an ongoing campaign targeting rust-lang members and owners of popular crates that is attempting to compromise devices and accounts in order to use them to publish malware. What we've seen A video call is set up for something positive -- maybe for a job, maybe for a project, maybe for a contract opportunity -- and then that's used as a vector to either get the target to install something on their computer (such as a purportedly missing audio codec) or execute another command (for example, via putting a command on the clipboard). These attackers are setting up new but legitimate seeming company profiles, including plausible LinkedIn presences, in order to pass cursory inspection. A previous attack of this form targeted many prominent Rust developers in June, and, last month, the arrayref crate was briefly compromised through similar attacks. At this moment we do not know if these are all a part of the same campaign. This attack style is known to be used by the DPRK, and has been seen outside of the Rust community as well. What you can do Please take extra care in the near term. Be appropriately suspicious of cold outreaches, and ensure that any calls you have with new people are on platforms you trust -- ideally, try to be the one who sets up the call on a platform you already use. Please also re-check that your accounts look normal: MFA enabled, no unexpected logins on platforms that can track that, and so on. If you have any concerns about your accounts, please reach out to help@crates.io (for crates.io account concerns) and/or security@rust-lang.org (for any other concerns). We're very happy to help.

## Rust debugging survey 2026 results

DevFeed: [Rust debugging survey 2026 results](<https://devfeed.tech/articles/rust-debugging-survey-2026-results-2354.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/09/07/rust-debugging-survey-2026-results/>)

Author: Sam Kellam

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

Content type: article

Language: en

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

Topics: [debugging](<https://devfeed.tech/topics/debugging.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [ide](<https://devfeed.tech/topics/ide.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [developers](<https://devfeed.tech/tags/developers.md>), [ide](<https://devfeed.tech/tags/ide.md>), [rust](<https://devfeed.tech/tags/rust.md>), [survey](<https://devfeed.tech/tags/survey.md>)

### AI overview

The Rust project reports results from its first Rust Debugging Survey, which received more than 2,300 responses. The article examines who uses debuggers, how Rust developers debug programs, and the debugging challenges they encounter. More than 46% of respondents currently use debuggers, while print debugging and the macro are widely used, followed by debugging inside an IDE and on the command line.

### Source excerpt

One of the biggest challenges Rust developers report in our annual surveys is a subpar debugging experience. So, back in February, we ran our first Rust Debugging Survey, in the hopes of identifying how Rust developers are using debuggers and what problems they are facing when doing so. We received over 2,300 responses, and we'd like to thank everyone who took the time to participate in the survey! In this report, we'll go over some of the results of the survey. If you'd like, you can also check out the complete results of the survey. If you'd like to skip ahead to any particular section, you can do so with this index: Who Uses Debuggers? How Are Debuggers Used? Challenges Debugger Visualizers Closing Remarks Who Uses Debuggers? The first step to making sense of the survey results is understanding who took the survey. We asked respondents to rate their Rust expertise, from "Never used it" to "Advanced". Over 80% reported themselves as "Advanced" or "Intermediate", split roughly evenly between the two: [PNG] [SVG] We also asked respondents if they currently use or have used debuggers in Rust. Over 46% said they currently do, with the remaining responses split between "have in the past" and "never have". That means that over half of respondents do not currently use a debugger for Rust! [PNG] [SVG] Categorized by expertise, the responses reveal that roughly half of "beginners" have never used debuggers in Rust! On the other hand, nearly half of "advanced users" currently do use debuggers in Rust: [PNG] [SVG] For respondents who indicated they had previously used Rust but no longer did, we asked if challenges with debugging support were why they stopped. For nearly 3%, the answer was "yes", with an additional 24% reporting debugging issues as being partially responsible (though mind the small response count; most respondents were active users of Rust): [PNG] [SVG] How Are Debuggers Used? Knowing what debuggers developers are using and how is another important part of un

## Announcing Rust 1.98.1

DevFeed: [Announcing Rust 1.98.1](<https://devfeed.tech/articles/announcing-rust-1-98-1-2353.md>)

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

Author: The Rust Release Team

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

Content type: release

Language: en

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

Topics: [releases](<https://devfeed.tech/topics/releases.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>)

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

### AI overview

Rust 1.98.1 is a point release that fixes a vtable-generation miscompilation which could produce undefined behavior, including null-pointer segfaults or arbitrary effects.

### Source excerpt

The Rust team has published a new point release of Rust, 1.98.1. Rust is a programming language that is empowering everyone to build reliable and efficient software. If you have a previous version of Rust installed via rustup, getting Rust 1.98.1 is as easy as: rustup update stable If you don't have it already, you can get rustup from the appropriate page on our website. What's in 1.98.1 Rust 1.98.1 fixes a miscompilation in vtable generation. In Rust 1.98.0, in some circumstances, rustc would incorrectly generate a trait object vtable with a null pointer where a function pointer should be. This leads to undefined behavior in the emitted code. In some cases this may 'just' cause segfaults due to the null pointer being loaded, but it is possible for it to be justification for arbitrary effects (as is typical for UB). If you'd like to help us out by testing future releases, you might consider using the beta (rustup default beta) and nightly (rustup default nightly) channels locally and in your CI. Please report any bugs you might come across! Contributors to 1.98.1 Many people came together to create Rust 1.98.1. We couldn't have done it without all of you. Thanks!

## Announcing rustup 1.29.1

DevFeed: [Announcing rustup 1.29.1](<https://devfeed.tech/articles/announcing-rustup-1-29-1-2352.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/09/01/Rustup-1.29.1/>)

Author: The Rustup Team

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

Content type: release

Language: en

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

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

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [cli](<https://devfeed.tech/tags/cli.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [docs](<https://devfeed.tech/tags/docs.md>), [http](<https://devfeed.tech/tags/http.md>), [releases](<https://devfeed.tech/tags/releases.md>), [rust](<https://devfeed.tech/tags/rust.md>), [toolchain](<https://devfeed.tech/tags/toolchain.md>), [update](<https://devfeed.tech/tags/update.md>), [windows](<https://devfeed.tech/tags/windows.md>)

### AI overview

Rustup 1.29.1 improves concurrent update and component-install operations, adds local HTTP documentation serving, and changes several installation behaviors. The release also fixes Windows-related installation issues and updates target terminology.

### Source excerpt

The rustup team is happy to announce the release of rustup version 1.29.1. Rustup is the recommended tool to install Rust, a programming language that empowers everyone to build reliable and efficient software. What's new in rustup 1.29.1 The headlines of this release are: Concurrency in certain rustup operations has been improved: When running rustup update, rustup will first check for possible updates in parallel. pr#4752 When running rustup component add with multiple components, they will be installed concurrently. pr#4790 Implicit installation of the active toolchain in rustup-init and rustup invocations has been deprecated where deemed unnecessary and will now produce a warning. pr#4840 Please see our blog post for more details regarding this change. rustup doc now supports the --serve flag which allows serving the docs over local HTTP. This should help users with containerized browser and/or rustup setups. pr#4986 Installing i686-pc-windows-* host toolchains on 64-bit Windows now requires --force-non-host. pr#4935 rustup-init will no longer leave unexpected files on disk after cancelled installations. pr#4996 A bug has been fixed which might cause Windows installation to fail when using rustup-init.sh. pr#4756 "Target triple" has been renamed to "target tuple" across the project to reflect the new terminology. pr#4743 pr#4827 pr#4834 Please note that this is not a breaking change in the CLI since the existing options such as --target are not using this terminology. In addition, rustup now officially supports aarch64-pc-windows-gnullvm as a host platform. pr#4523 Further details are available in the changelog! How to update If you have a previous version of rustup installed, getting the new one is as easy as stopping any programs which may be using rustup (e.g. closing your IDE) and running: $ rustup self update Rustup will also automatically update itself at the end of a normal toolchain update: $ rustup update If you don't have it already, you can get rustup

## Announcing our first Maintainers in Residence

DevFeed: [Announcing our first Maintainers in Residence](<https://devfeed.tech/articles/announcing-our-first-maintainers-in-residence-2351.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/08/26/announcing-our-first-maintainers-in-residence/>)

Author: Lori Lorusso, Jakub Beránek

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

Content type: article

Language: en

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

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Maintainers](<https://devfeed.tech/topics/maintainers.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [Google](<https://devfeed.tech/topics/google.md>), [OpenAI](<https://devfeed.tech/topics/openai.md>)

Tags: [aws](<https://devfeed.tech/tags/aws.md>), [blog](<https://devfeed.tech/tags/blog.md>), [contributors](<https://devfeed.tech/tags/contributors.md>), [google](<https://devfeed.tech/tags/google.md>), [maintainers](<https://devfeed.tech/tags/maintainers.md>), [openai](<https://devfeed.tech/tags/openai.md>), [rust](<https://devfeed.tech/tags/rust.md>), [support](<https://devfeed.tech/tags/support.md>)

### AI overview

The Rust Project announces its first Maintainers in Residence and Maintainer Grant recipients, with funding for at least 12 months through the Rust Foundation Maintainers Fund. The article explains the program's support categories, selection process, and focus on strengthening critically underfunded, high-impact Rust teams.

### Source excerpt

We are very happy to announce the Rust Project's first round of Maintainers in Residence: Gen Li (@rami3l), Chris Denton (@ChrisDenton), Alejandra González (@blyxyas), León Liehr (@fmease), and Maintainer Grant recipients: Jason Newcomb (@Jarcho) and Jonas Böttiger (@joboet). These contributors will be funded for their rust-lang maintenance activities for (at least) the following 12 months! The funding of the Maintainer in Residence (MiR) and Maintainer Grantee roles is possible thanks to generous donations to the Rust Foundation Maintainers Fund (RFMF) from Google, AWS, OpenAI, the Rust Project Leadership Council and also individual sponsors. We also want to thank the people who advocated for maintainer funding within their companies; Tyler Mandry from Google, Niko Matsakis and Jess Izen from AWS and Predrag Gruevski from OpenAI, and also the whole Rust Leadership Council and our funding advisors. If you would like to help us support even more Rust contributors, consider donating to RFMF. The Rust Foundation has published a press release and a blog post, where you can learn more about the sponsors and the supported contributors. Read more below to learn about the MiR program, how we chose the funded contributors, and of course who they are! Background The Maintainer in Residence program, established in RFC 3931, is designed to provide stable financial support for Rust contributors, so that they can truly focus on crucial maintenance activities. Currently, there are three categories of support that we offer: Full-time MiR: funded for 5 days/week of Rust Project work Half-time MiR: funded for ~2.5 days/week of Rust Project work Maintainer Grant: funded for ~1 day/week of Rust Project work Funding for this program comes from the Rust Foundation Maintainers Fund, which was launched recently, and the whole program is managed by the Rust Funding team. When deciding who to fund, we took a systematic approach. First, we looked at Rust teams to understand their maintenance

## Enabling the next-generation trait solver on nightly

DevFeed: [Enabling the next-generation trait solver on nightly](<https://devfeed.tech/articles/enabling-the-next-generation-trait-solver-on-nightly-2350.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/08/21/enabling-next-solver-on-nightly/>)

Author: lcnr

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

Content type: article

Language: en

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

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

Tags: [bugs](<https://devfeed.tech/tags/bugs.md>), [diagnostics](<https://devfeed.tech/tags/diagnostics.md>), [inference](<https://devfeed.tech/tags/inference.md>), [performance](<https://devfeed.tech/tags/performance.md>), [rust](<https://devfeed.tech/tags/rust.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

Rust is enabling its next-generation trait solver by default on nightly ahead of planned stabilization. The compiler-internal replacement changes trait and associated-type handling, fixes many known issues, and needs testing for breakage, performance regressions, and diagnostics.

### Source excerpt

After nearly 4 years of active development, the next-generation trait solver is close to stabilization. We are enabling it by default on nightly to surface any remaining issues and plan to stabilize it in the next months. This is the largest single change to the Rust compiler since its initial release. It completely replaces how we prove where-clauses, normalize associated types, and much more. Please try out the latest nightly and open an issue if you encounter any bugs or regressions. This is an internal component of the compiler. The main benefits of this rework will come in the future. The removal of the old implementation will unblock features such as Type Alias Impl Trait and Return Type Notation, allow us to add new implicit default trait bounds (e.g., Move and Forget), and enable us to fix the remaining type system unsoundnesses. Even so, this already fixes a huge number of issues. As an underapproximation, we currently know of more than 200 issues on GitHub fixed by this change. This also has a significant impact on compile times; more on that later. When developing on nightly, you may accidentally rely on behavior only supported by the new trait solver. This is an incredibly big change which results in a non-trivial amount of breakage. Most of these changes are intended improvements to type inference or the removal of undesirable behavior. We are tracking the known issues and breakage in a pinned GitHub issue. What can I do? Please update to the latest nightly version by using rustup update nightly and use it to test your existing projects and libraries. Please tell us if you encounter any breakage, compile-time performance regression, or bad diagnostics. We have not yet spent too much time on error messages for the next-generation trait solver, so we would also appreciate you using this nightly for development to find poor diagnostics and other bugs in our error handling. If you encounter any issue, take a quick look at the pinned GitHub issue to see if t

## Supply chain attack on arrayref

DevFeed: [Supply chain attack on arrayref](<https://devfeed.tech/articles/supply-chain-attack-on-arrayref-2349.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/08/20/supply-chain-attack-on-arrayref/>)

Author: Manish Goregaokar

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

Content type: news

Language: en

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

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

Tags: [local](<https://devfeed.tech/tags/local.md>), [payload](<https://devfeed.tech/tags/payload.md>), [research](<https://devfeed.tech/tags/research.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [supply-chain](<https://devfeed.tech/tags/supply-chain.md>)

### AI overview

The Rust Security Response Team confirmed a supply-chain attack involving malicious crates. A compromised build script downloaded a malicious payload, leading to the deletion or yanking of affected versions and the locking of a potentially compromised account. Developers are advised to inspect their local Cargo registry cache for the listed crates and versions.

### Source excerpt

What happened On 2026-08-20 at 7:15 UTC we got a report that the proc-macro1 crate was malicious. The Rust Security Response Team verified this to be the case: the crate had a build script that was downloading a malicious payload. This crate proc-macro1 and others like it (proc-macro-en, aovine, arone, aronenao, tinymember) have been deleted. Furthermore, we discovered that the popular arrayref crate had recently been republished and made to depend on this crate, with the most recent versions yanked. We have removed the malicious version and unyanked the maliciously-yanked versions. Other crates by that author (internment, append-only-vec) were also affected so we have done the same for those, and locked the account as a precaution. We do not believe the author of arrayref to be acting maliciously, but their computer or credentials are likely compromised, and we are attempting to contact them. What you need to do We recommend you check your local dependencies to ensure these crates were not pulled in. Here are the malicious versions that we deleted from crates.io: append-only-vec@0.1.9: published at 2026-08-20T07:37:49Z, deleted at 2026-08-20T09:25:24Z. Online for 107 minutes. arrayref@0.3.10: published at 2026-08-20T07:15:00Z, deleted at 2026-08-20T08:41:40Z. Online for 86 minutes. internment@0.8.7: published at 2026-08-20T07:34:07Z, deleted at 2026-08-20T09:04:11Z. Online for 90 minutes. proc-macro1, proc-macro-en, aovine, arone, aronenao, tinymember (any versions). You can quickly check if these crates have been used locally by going through ~/.cargo/registry/cache with this command: find ~/.cargo/registry/cache -type f \( \ -name 'append-only-vec-0.1.9.crate' -o \ -name 'arrayref-0.3.10.crate' -o \ -name 'internment-0.8.7.crate' -o \ -name 'proc-macro1-*.crate' -o \ -name 'proc-macro-en-*.crate' -o \ -name 'aovine-*.crate' -o \ -name 'arone-*.crate' -o \ -name 'aronenao-*.crate' -o \ -name 'tinymember-*.crate' \ \) -print Thanks We'd like to thank the Research T

## Announcing Rust 1.98.0

DevFeed: [Announcing Rust 1.98.0](<https://devfeed.tech/articles/announcing-rust-1-98-0-2348.md>)

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

Author: The Rust Release Team

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

Content type: release

Language: en

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

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

Tags: [bugs](<https://devfeed.tech/tags/bugs.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [release](<https://devfeed.tech/tags/release.md>), [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

Rust 1.98.0 introduces algebraic floating-point methods that permit compiler optimizations and buffered integer formatting aimed at performance. The release also discusses a compiler bug affecting prior versions.

### Source excerpt

The Rust team is happy to announce a new version of Rust, 1.98.0. Rust is a programming language empowering everyone to build reliable and efficient software. If you have a previous version of Rust installed via rustup, you can get 1.98.0 with: $ rustup update stable If you don't have it already, you can get rustup from the appropriate page on our website, and check out the detailed release notes for 1.98.0. If you'd like to help us out by testing future releases, you might consider updating locally to use the beta channel (rustup default beta) or the nightly channel (rustup default nightly). Please report any bugs you might come across! What's in 1.98.0 stable Algebraic floating-point methods The floating-point types f32 and f64 now have "algebraic" methods for addition, subtraction, multiplication, division, and remainder. These allow optimizations on these operations using the algebraic properties of real numbers, even though these properties do not hold with the limitations of floating-point representations. The exact set of optimizations is not specified, but may be similar to the kind of optimization you would see with the -ffast-math option in other languages. For example, floating-point addition is not associative, so a sum like a + b + c + d must be evaluated in the left-associative order in which it is parsed, like ((a + b) + c) + d. If you write the same sum as a chain of algebraic_add calls, then the compiler is free to reorder it, perhaps like (a + b) + (c + d) to evaluate the partial sums simultaneously. Broader loop-vectorization is often enabled by using these algebraic methods as well. These methods are non-deterministic, since the compiler is free to choose different optimizations, but they never cause undefined behavior. See the library documentation and the original API change proposal for more details. Buffered integer formatting All of the primitive integer types now have a format_into method that takes a &mut NumBuffer<Self> parameter, which i

## Enabling the next iteration of the borrow checker on nightly

DevFeed: [Enabling the next iteration of the borrow checker on nightly](<https://devfeed.tech/articles/enabling-the-next-iteration-of-the-borrow-checker-on-nightly-2347.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/08/04/enabling-polonius-alpha-on-nightly/>)

Author: Jack Huey

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

Content type: article

Language: en

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

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

Tags: [code](<https://devfeed.tech/tags/code.md>), [performance](<https://devfeed.tech/tags/performance.md>), [rust](<https://devfeed.tech/tags/rust.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Rust is enabling the Polonius Alpha borrow checker on nightly for testing ahead of planned stabilization. The new formulation provides flow-sensitive borrow checking for lifetime outlives relationships, potentially allowing code that current NLL borrow checking rejects, while nightly testing will help identify performance regressions, unsoundness, and diagnostic issues.

### Source excerpt

TL;DR We are enabling the next iteration of the borrow checker (coined Polonius Alpha) on nightly in preparation for stabilization in the next few months. Whaaaaaat? Yes! You heard it right! The next iteration of the Rust borrow checker is coming! Rust's first borrow checker ("AST borrowck") was very limited and was phased out in 2019 in favor of NLL, other than a "migrate mode" that was used to provide nice error messages. That migrate mode was finally removed in 2022. The Polonius borrow checker spun out of the NLL effort in 2018. The initial formulation passed the NLL test suite and accepted (sound) code that NLL did not. However, performance was a critically-limiting factor; generally borrow check was slower than NLL, but certain programs were considerably slower than NLL to the extent that using that implementation/formulation of Polonius was a non-starter. Attempts were made over the years to implement the Polonius formulation in a performant manner, without much luck in addressing the core issues. In 2023, a new formulation of a Polonius-style borrow checker was imagined that required minimal rearchitecture of the existing NLL implementation and could be extended to allow more code to compile. We had hoped, to try to stabilize this new formulation in 2024; but, various things popped up that delayed this. But! We're nearly there now! At this point, there are no known remaining issues with the subset coined Polonius Alpha that we intend to stabilize. And, performance is generally acceptable for stabilization (will discuss that a bit below). So, we are enabling the Polonius Alpha borrow checker on nightly for testing until we stabilize fully later in the year. We're doing this in order to help find: Any serious performance regressions we're unaware of Unsoundness in the formulation that we haven't thought about Any weird diagnostic issues that we need to improve Note: we have not yet seen any diagnostic changes You can report any issues on Github or on Zulip. Ok

## Announcing Rust 1.97.1

DevFeed: [Announcing Rust 1.97.1](<https://devfeed.tech/articles/announcing-rust-1-97-1-2346.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/07/16/Rust-1.97.1/>)

Author: The Rust Release Team

Published: 2026-07-16T00:00:00Z

Content type: release

Language: en

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

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [releases](<https://devfeed.tech/topics/releases.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Beta channel](<https://devfeed.tech/topics/beta-channel.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>)

Tags: [beta-channel](<https://devfeed.tech/tags/beta-channel.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [ci](<https://devfeed.tech/tags/ci.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [release](<https://devfeed.tech/tags/release.md>), [releases](<https://devfeed.tech/tags/releases.md>), [rust](<https://devfeed.tech/tags/rust.md>), [update](<https://devfeed.tech/tags/update.md>)

### AI overview

Rust 1.97.1 is a point release that fixes a miscompilation related to an LLVM optimization. The release backports an LLVM fix and disables the underlying change in Rust 1.97.0 that increased the likelihood of the issue.

### Source excerpt

The Rust team has published a new point release of Rust, 1.97.1. Rust is a programming language that is empowering everyone to build reliable and efficient software. If you have a previous version of Rust installed via rustup, getting Rust 1.97.1 is as easy as: rustup update stable If you don't have it already, you can get rustup from the appropriate page on our website. What's in 1.97.1 Rust 1.97.1 fixes a miscompilation in an LLVM optimization. We have backported both an LLVM fix and a disable of the underlying change in Rust 1.97.0 of Rust's generated IR that increased the likelihood of this happening. However, note that the underlying miscompilation has been present since at least Rust 1.87. If you'd like to help us out by testing future releases, you might consider running your code's CI or locally using the beta channel (rustup default beta) or the nightly channel (rustup default nightly). Please report any bugs you might come across! Contributors to 1.97.1 Many people came together to create Rust 1.97.1. We couldn't have done it without all of you. Thanks!

## crates.io: development update

DevFeed: [crates.io: development update](<https://devfeed.tech/articles/crates-io-development-update-2345.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/07/13/crates-io-development-update/>)

Author: Tobias Bieniek

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

Content type: article

Language: en

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

Topics: [Code](<https://devfeed.tech/topics/code.md>), [Syntax Highlighting](<https://devfeed.tech/topics/syntax-highlighting.md>), [Authentication](<https://devfeed.tech/topics/authentication.md>), [Server](<https://devfeed.tech/topics/server.md>), [JSON](<https://devfeed.tech/topics/json.md>), [Front end](<https://devfeed.tech/topics/frontend.md>), [releases](<https://devfeed.tech/topics/releases.md>), [json-ld](<https://devfeed.tech/topics/json-ld.md>)

Tags: [authentication](<https://devfeed.tech/tags/authentication.md>), [code](<https://devfeed.tech/tags/code.md>), [development](<https://devfeed.tech/tags/development.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [github](<https://devfeed.tech/tags/github.md>), [http](<https://devfeed.tech/tags/http.md>), [identity](<https://devfeed.tech/tags/identity.md>), [json](<https://devfeed.tech/tags/json.md>), [releases](<https://devfeed.tech/tags/releases.md>)

### AI overview

This development update describes major crates.io improvements, including a source code viewer for published crate versions, searchable file trees, syntax highlighting, shareable line selections, and planned version-to-version diffs. It also explains the archive and manifest infrastructure used to serve files efficiently and outlines work to make crates.io usernames independent of GitHub accounts, enabling future support for other identity providers.

### Source excerpt

Another six months have passed since our last development update, and the crates.io team has been busy. Here's a summary of the most notable changes and improvements made to crates.io since then. Source Code Viewer Crate pages now have a "Code" tab that lets you browse the contents of published crate versions directly on crates.io. This shows you the exact files that cargo downloads when you add a crate as a dependency, which might differ from the linked repository. This makes it much easier to audit your dependencies, including files that never appear in the repository, like the normalized Cargo.toml files that cargo generates. The viewer comes with a file tree sidebar with search functionality, syntax highlighting, and GitHub-style line selection, where clicking or dragging line numbers produces shareable #L10-L20 URLs. Under the hood, the server now builds a zip file for every published version. Since the .crate files that cargo consumes are gzipped tarballs without random access support, a background job re-packs each of them into a seekable zip archive plus a JSON manifest describing the contained files. Both are served from our static CDN. The frontend then fetches only the manifest and loads each file on demand with an HTTP range request. Because of this architecture, browsing crate sources essentially adds no load on the crates.io API servers. Existing crate versions have been backfilled, so this works for old releases too. The rendering library behind the code viewer is a diff renderer at heart, and that's no accident: a version-to-version diff viewer built on the same infrastructure is currently in the works. This will allow you to review exactly what changed between two published versions, right on crates.io. Stay tuned! Untangling crates.io Accounts from GitHub At the end of May, the crates.io team accepted RFC #3946. Crates.io accounts always have been tightly coupled to GitHub: signing in means "Log in with GitHub", and your crates.io identity is your