Angular gets a Rust compiler that promises cold builds up to 3x faster

Why Angular had to rewrite the compiler

The Angular team, through people like Alex Rickabaugh and Mark Techson, published a post on the official blog in late September 2026 detailing the Angular Preprocessor (ngp), a partial rewrite of the compiler in Rust. The reason wasn't just speed: it was survival. Shortly before, Microsoft released TypeScript 7.0, whose rewrite in Go removed the ts.Transformer API, used by Angular's current compiler (ngc) to transform decorators like @Component and @Pipe into runtime instructions.

Without an equivalent of this API on the Go side, and with the crossing between JavaScript and Go on every file being prohibitively slow, Angular had no way to simply keep migrating alongside TypeScript. The solution found was to decouple compilation from TypeScript's internal APIs and rebuild the analysis stage on top of Oxc, VoidZero's Rust toolchain that already runs under the hood of Vite. In a post on X, the team described the work as a partial rewrite, not a from-scratch restart.

How ngp works under the hood

The new pipeline runs in three well-separated stages, which changes how the compiler talks to the rest of the toolchain:

1. A Rust frontend, built on top of Oxc, analyzes files in parallel to discover Angular declarations and resolve metadata.
2. The TypeScript template compiler, still maintained, emits two artifacts: a runtime file with the transformed component and a .ngtypecheck.ts file containing the Type Check Block (TCB) used for template type checking.
3. A downstream tool, chosen by the project (tsgo, tsrs, esbuild, or Rolldown), takes over type checking and final JavaScript emission, independently of the previous stage.

The bulk of ngp landed in the repository on October 8, 2026, in a single commit with more than 370,000 lines, of which about 56,000 were in Rust.

The numbers that showed up in early tests

Cédric Exbrayat, from Ninja Squad, ran the beta on three real projects, ranging from 15 to 1,714 components, and measured what has been confirmed so far: a 2x to 3x gain in cold builds, with memory use on the largest project dropping from 2.8 GB to 1.4 GB. The fastest combination was ngp with tsrs and Rolldown; tsgo and esbuild were only marginally behind.

This is already very promising, and there are certainly further gains to be made when the team focuses on performance optimization.

Cédric Exbrayat, Ninja Squad

Christopher Holder, from push-based.io, tested a different path: he wrote vite-plugin-ngp to compile Angular files on demand, inside the dev server. On the Super Productivity codebase, with 252 components, the development server reached the first page in 10.5 seconds versus 17.4 seconds for ng serve, and template edits started applying in 112 milliseconds instead of a full 2.6-second reload. In a generated application with 5,000 components, the difference reached 1.6 seconds versus 28.4 seconds.

Holder was direct about the maturity of what he built: in his own words, the plugin "is a prototype on a prototype" (in the original, in English, "a prototype on a prototype"), and it's pinned to version 22.3.0-next.2.

The community's reaction and what's coming from VoidZero

On Reddit, the reception to the announcement was largely enthusiastic:

Read the whole article. Impressive. The Angular team surpassed my expectations!

Comment in a Reddit thread about the ngp release

It's worth remembering that Angular isn't the first to test this route. VoidZero itself maintains an experimental Angular compiler on top of Oxc, covered by InfoQ in April 2026, which reported an improvement of around 97% on narrower workloads. Today that project is described as "actively looking for maintainers." The Angular team confirmed that VoidZero's work influenced ngp's architecture and that the two groups have been collaborating, with ngp taking on the role of the official path going forward.

What changes in practice for Angular developers

None of this is ready for production yet, and that's the most important piece of information for anyone managing a CI pipeline today. Adoption of ngp is expected to arrive in a minor version of Angular 22, and only after TypeScript 7.1 restores a compatible compiler API. Until then, production builds are expected to stay on the current ngc.

Those on older versions of Angular also need to deal with a prior step: the official upgrade guide recommends first reaching version 20 or newer before considering ngp. For Brazilian teams with large monorepos (banks, retail, and telecom often have Angular applications with hundreds of components), the memory numbers are as attention-grabbing as the build time: cutting from 2.8 GB to 1.4 GB on a large project can mean running CI on smaller runners, or no longer hitting memory limits in a shared pipeline.

For those who just want to experiment, Holder's vite-plugin-ngp is currently the most accessible way to feel the hot reload gains in a development environment, even knowing it's a prototype on a prototype and that the pinned version can change without notice. It's worth testing on an isolated branch, without expecting stability, and following the Angular blog and the ngp repository to know when the combination with TypeScript 7.1 opens the path to production.