rustc_codegen_gcc can now bootstrap rustc on AArch64
Rust compiler (rustc) community just received a long-awaited news: rustc_codegen_gcc backend can now bootstrap rustc on AArch64. This means that now you can build Rust compiler with a backend that generates code using GCC (not LLVM) on 64-bit ARM (end to end). This is a milestone for an alternative codegen approach that has been in development for years. It's important for portability, toolchain diversity and the long-term health of the Rust ecosystem.
In this post I will try to explain what rustc_codegen_gcc is, why bootstrapping is important, what AArch64 milestone means (and doesn't mean) and what happens next with the project.
What rustc_codegen_gcc is
Rust compiler (rustc) is not one program. It's not one backend. It's a frontend that lowers Rust to an intermediate representation (MIR). And then a codegen layer that produces machine code from this IR. For most of Rust's history, the default (and only) production codegen backend was LLVM: rustc would produce LLVM IR and then LLVM would do the optimisation and code generation.
rustc_codegen_gcc is an alternative codegen backend that targets GCC instead of LLVM. It provides the same codegen interface as the LLVM backend, but it lowers Rust IR to GCC's GIMPLE representation and then allows GCC to do the optimisation and code generation. So, you end up with a Rust compiler that can target anything GCC supports. It can use GCC's optimisers and code generators to target any architecture.
The goal is portability and diversity. While LLVM can target a lot of architectures, it doesn't support all the architectures that GCC supports. Or all the architectures that toolchains for certain platforms are based on. GCC is the default compiler on most Linux distributions. It's the default compiler on many embedded and enterprise platforms. So, if you can use GCC as a backend for your Rust toolchain then you can use it on platforms that don't have LLVM (or where LLVM is immature or poorly supported), and you eliminate a single point of failure in the story of Rust toolchains.
Why bootstrapping matters
The minimum requirement for a serious compiler is that it can compile itself. By "bootstrap" here I mean that you can use rustc_codegen_gcc backend to build rustc. And then use the built rustc to build rustc again. This is a test that your backend is "good enough" to handle all Rust compiler codebase. Including all the codegen logic, optimisations and platform specific stuff.
Until your backend can bootstrap, it's a research project. It can compile small programs and pass tests. But it hasn't been tested with the full complexity of a real, large Rust codebase. Bootstrap is the point where it becomes something you can use. Because it has demonstrated that it can handle the most important program.
The bootstrap on AArch64 is important because AArch64 is the architecture of most modern servers and most ARM based cloud instances. It's also the architecture of an increasing number of consumer and edge devices. While LLVM support for AArch64 is good, it's not the only game in town. And the long history and the importance of good optimisations in GCC matter. If you have a working Rust codegen path through GCC on AArch64, then you have a plausible alternative for one of the most important platforms.
What progress report 44 says
The report is 44th in a long series of reports on the project's progress. It was published 4 November 2026. The headline is the AArch64 bootstrap. Other than that it has the usual mix of improvements: bug fixes, improved support for specific language features, compatibility with LLVM backend output improved, performance improvements.
This report is also a good example of the incremental approach that this project has. rustc_codegen_gcc has been developed incrementally over the years. Feature by feature. So the reports always add a few more pieces of the puzzle. AArch64 bootstrap isn't a sudden breakthrough. It's a point where you have enough pieces in place to make the whole thing work end to end on a given architecture. This is how big compiler projects work. So, appreciate that as an achievement of sustained engineering, not a one-time dramatic event.
What this does not imply
Don't overinterpret the milestone. A few caveats:
AArch64 only. The bootstrap is on AArch64. The other architectures are at different levels of completion. And there's ongoing work to bring them up to the same level. The project's goal is to support a wide range of targets. But each architecture has its own quirks. And it's a big effort to support them all.
Not production ready. The bootstrap means that the backend can handle rustc. But it doesn't mean that it's as fast, as correct or as well optimised as the LLVM backend. We have a separate and ongoing effort to compare performance. There are known issues. The LLVM backend has a lot of optimisation work behind it for years. rustc_codegen_gcc is catching up. But it's not there yet.
Not the default. The Rust project hasn't adopted rustc_codegen_gcc as a default. Or even as a supported alternative for end users. It's still an experimental backend. Developed and used by a small number of developers and distributions. There's a long way from "can bootstrap" to "shipped in Rust release". Not just technical work. There's community consensus and commitment to maintenance too.
Compatibility is a moving target. rustc itself is always changing. So, you need to keep up with the codegen backend. If today your backend can bootstrap, then you need to keep updating it for each change to codegen interface. And the interface isn't static. To maintain an alternative backend, it's a constant cost. It's not a one-time effort.
Why toolchain diversity matters
rustc_codegen_gcc isn't about "more options". It's about resilience.
Historically, the Rust toolchain has relied on LLVM for code generation. This is a great thing. LLVM is awesome. But it's also a concentration of risk. If there's a bug in LLVM, then it affects every target of Rust. If LLVM doesn't have good support for a given platform then that's a platform where Rust is difficult to use. If there's a licensing or governance change in LLVM project, then it affects the Rust ecosystem.
GCC is a different project. Different governance. Different codebase. Different supported targets. If you can use GCC as a backend for your Rust toolchain, then you're not just relying on LLVM. This is good. Diversity is a good thing. Just like having multiple implementations of a standard is a good thing. It catches bugs. It increases support. It keeps everyone honest.
Also, there are practical reasons. Many embedded and enterprise platforms use GCC as their native toolchain. LLVM is a secondary or unsupported option. So, a Rust codegen path through GCC means that you can use Rust on those platforms without having to change your toolchain. This reduces the barrier to adoption. And it's exactly in those places where you most want to use Rust's safety features.
The history of the project
rustc_codegen_gcc was started in 2020 by Antoni Boucher (antoyo). He's the main maintainer. It started as an experiment to see if you can use GCC as a backend for rustc at all. It's been steadily growing since then. It's been funded in part by the Rust Foundation and by individual sponsors. It has a small but dedicated group of contributors.
The progress reports are a great example of transparent engineering. They're published roughly monthly. They list what was done, what's blocked, what's next. You can see a compiler backend being developed in real time. And it's a great record of the kind of incremental unglamorous work that goes into compiler development.
The bootstrap milestone is the culmination of incremental work. It's not a single PR. It's not a single feature. It's when you have enough language and enough of the stdlib supported to be able to build the compiler itself. It's a credit to years of sustained effort to reach that point on AArch64.
What this means for distributions
Linux distributions are one of the most interested parties. If you have a distribution that ships Rust, then you need a working Rust toolchain for all the architectures that your distribution supports. And the architectures that distributions care about include some where LLVM support is secondary. For example, Debian, Fedora and others have been closely watching rustc_codegen_gcc. A working backend on AArch64 is a step towards being able to build Rust packages on ARM servers using your distribution's native GCC based toolchain.
This is important for reproducibility. For build infrastructure. If you can build Rust with GCC on your distribution, then you can reuse your existing compiler infrastructure. Use your existing hardening flags. Use your existing cross compilation setup. This is a real benefit from an operational perspective. It's one of the reasons why distributions are interested in this project. Even though it's not yet production ready.
Conclusion: what comes nextAArch64 bootstrap is a big achievement.
But it's not a final destination. There are a lot of things that need to be done: bootstrap for other architectures, performance improvements, better compatibility with LLVM backend outputs (so that crates should compile exactly the same both in the LLVM backend and in this one), increase in the number of contributors and testers, etc.
Also we have to figure out how we relate to the Rust project itself. Now it's a separate entity that's maintained by a small group. In order to be a viable alternative, it's going to need more review, CI integration, and a commitment to stay in sync with the changes in rustc. It's a governance issue as much as it's a technical issue. Community will figure it out over time.
But we know that the technical arguments for having an alternative codegen backend are made. The fact that we were able to bootstrap it on AArch64 shows that it's doable. Now it's all about engineering and community, not about fundamental research. And that's a much better place to be for a project that started as a kind of an experiment.
Sources
rustc_codegen_gccprogress report 44 (4 Nov 2026): https://blog.antoyo.xyz/rustc_codegen_gcc-progress-report-44rustc_codegen_gccrepository: https://github.com/rust-lang/rustc_codegen_gcc- Rust compiler development guide (codegen backends): https://rustc-dev-guide.rust-lang.org/
- LLVM project: https://llvm.org/
- GCC project: https://gcc.gnu.org/