If you have been following the evolution of Google's framework over the last few years, you know it has been undergoing a silent reconstruction — piece by piece.
With the release of Angular 22 on June 3, 2026, this reconstruction is no longer a promise and has become the standard.
We are not looking at another batch of experimental features: we are looking at the consolidation of an entirely rethought ecosystem.
For those who live and breathe enterprise applications, Clean Architecture, and Microfrontend ecosystems, this is the version that finally delivers what has been promised since Angular 16: an end-to-end reactive framework, zone-less by nature, and with much less ceremony along the way.
The experiments are over.
Below is what has actually changed — and what you need to do before running . 📖 If you are just starting out: several technical terms in this article (change detection, Signals, SSR, dependency injection, microfrontends...) are explained in a glossary at the end.
Read the article from end to end and use the glossary as a reference whenever you have a doubt.
What Arrived in Angular 22 is the new default change detection (the old became and is deprecated).
Stable Resource API: , , and are ready for production.
Stable Signal Forms: featuring the Submission API, dynamic schemas (Zod/Valibot), and interop with Reactive Forms.
New decorator: shortening . : for lazy dependency injection, with prefetch via . : for native debounce in Signals/Resources.
Incremental Hydration: enabled by default. : uses by default ( is deprecated).
Important Router and bootstrap improvements designed for Microfrontends.
1.
OnPush as the New Default Change Detection The moment the community has always asked for has arrived: is now the default behavior for any new component.
This decision makes perfect sense in a signals-first world — those who use Signals already receive surgical notifications about what changed, and OnPush takes full advantage of this, checking only the truly affected components instead of scanning the entire tree.
The old (which checked the whole tree) was renamed to and is deprecated.
If you still need the old behavior in a component, declare it explicitly: Critical detail for the migration: during , if Angular doesn't find an explicit strategy, it automatically applies so nothing breaks.
That is, you don't get performance "for free" — you need to migrate component by component to reap the benefits of OnPush.
2.
Stable Resource API and httpResource The Resource API was the missing piece in the Signals puzzle: deriving asynchronous data reactively, usually by triggering HTTP requests when a Signal changes.
Now , , and are stable and cleared for production.
The most comfortable entry point is .
It takes a reactive lambda that returns the request: if a Signal used inside it changes, the request is automatically re-fired.
The resource manages its own state via Signals: , , , and a more detailed status (, , , , , ).
And the best part: race conditions are handled automatically — if several requests arrive in sequence, only the result of the most recent one is used, exactly like would do in RxJS, but without you writing a single line of pipe.
Want to skip the request under certain conditions?
Just return in the lambda.
3.
Signal Forms Ready for Production The eternal divide between Reactive Forms and Template-Driven is over.
Signal Forms have left experimental status and are the recommended approach for forms: declarative, strongly typed, and reactive via Signals.
The heart of the API is the function, which receives a Signal with the data and a validation schema: The result is a : a nested structure of Signals where each field exposes , , , and .
In the template, you use the directive: And it doesn't stop there.
Angular 22 (adding to 21.1 and 21.2) brought a surprisingly complete forms stack: Submission API ( + submit): all submission logic inside the form itself, including mapping validation errors from the server back into t