Angular 22: The Signals Era Goes Stable

Discover what's new in Angular 22: OnPush by default, stable Resource API and Signal Forms, the new @Service decorator, injectAsync, debounced, Fetch as default HttpClient backend, and many template improvements.

Angular 22 was released on June 3, 2026. There is no big revolution in this release: the keyword is maturity. After two years of work around Signals, several core building blocks finally leave their experimental status. And two default behaviours change in ways that affect every application.

In this article, we’ll go through the most important changes and see how to prepare your migration.

OnPush Becomes the Default Change Detection Strategy

This is the change the community has been discussing for years. With Angular 22, every new component uses the OnPush strategy without having to declare it. The reasoning is simple: with Signals, the framework knows precisely which component is affected by a change, and OnPush takes full advantage of that precision.

The old Default strategy is deprecated and replaced by Eager, which checks the whole component tree:

import { ChangeDetectionStrategy, Component } from "@angular/core";

@Component({
  selector: "app-legacy",
  changeDetection: ChangeDetectionStrategy.Eager,
  template: `...`,
})
export class LegacyCmp {}

Existing applications won’t break: ng update automatically adds Eager to every component that had no explicit strategy. These Eager markers effectively become your cleanup to-do list. You can remove them progressively, one component at a time, as you migrate your components to Signals. On a new project, you get OnPush for free.

The Resource API Is Now Stable

resource, rxResource and httpResource are now stable. This was the missing piece of the Signals ecosystem: deriving asynchronous data (typically from an HTTP call) from Signals, in a reactive way.

import { httpResource } from "@angular/common/http";
import { Component, signal } from "@angular/core";

@Component({/* ... */})
export class FlightSearch {
  protected readonly filter = signal({ from: "Hamburg", to: "Graz" });

  protected readonly flightsResource = httpResource<Flight[]>(
    () => ({
      url: "/api/flight",
      params: { from: this.filter().from, to: this.filter().to },
    }),
    { defaultValue: [] },
  );

  protected readonly flights = this.flightsResource.value;
  protected readonly isLoading = this.flightsResource.isLoading;
}

Here is how it behaves:

  • If a Signal read inside the function changes, the request is restarted.
  • Race conditions are handled automatically, like with a switchMap: only the latest response is kept.
  • Returning undefined from the function suspends the request.
  • The status property exposes the current state: idle, loading, reloading, error, resolved or local.

Resources preloaded on the server now also use the Transfer State, so the request is no longer executed a second time during the first render in the browser.

If you have been loading data with hand-written effect() calls or BehaviorSubjects, httpResource is now the official approach, with no risk of breaking changes in the next release.

Signal Forms Are Production-Ready

Signal Forms moved from experimental to stable remarkably fast, thanks to internal case studies at Google. The core of the API is the form function, which takes a Signal holding the data and a validation schema:

import { form, minLength, required } from "@angular/forms/signals";

protected readonly flightForm = form(this.flight, (path) => {
  required(path.from);
  required(path.to);
  minLength(path.from, 3);
});
<form [formRoot]="flightForm">
  <input [formField]="flightForm.from" />
  <div>{{ flightForm.from().errors() | json }}</div>
  <button>Save</button>
</form>

The stable version comes with a complete ecosystem:

  • a Submission API (submission.action, onInvalid, ignoreValidators)
  • the FormRoot directive
  • conditional CSS classes via provideSignalFormsConfig, with NG_STATUS_CLASSES to get back the classic ng-invalid classes
  • validateStandardSchema, which accepts a Zod or Valibot schema directly (even a dynamic one returned by a function)
  • a compatForm bridge to your existing Reactive Forms

The disabled, readonly and hidden helpers now accept a when property, and can return an explanatory string instead of a simple true.

You don’t have to rewrite all your forms at once: compatForm and SignalFormControl let you migrate one form at a time, alongside your existing Reactive Forms.

Dependency Injection: @Service and injectAsync

Angular 22 introduces the first new decorator in a long time: @Service(). It replaces the very common @Injectable({ providedIn: 'root' }) and makes the intent clearer:

import { Service } from "@angular/core";

@Service()
export class FlightClient {}

// Must be provided manually
@Service({ autoProvided: false })
export class TabRegistry {}

@Service() is a shorthand, not a full replacement for @Injectable(). You should keep using @Injectable() for specific provider configurations.

The new injectAsync function injects a service lazily: its bundle is only loaded when the service is used for the first time. It is ideal for a service that depends on a heavy library:

import { injectAsync, onIdle } from "@angular/core";

private readonly upgradeService = injectAsync(
  () => import("./upgrade-service").then((m) => m.UpgradeService),
  { prefetch: onIdle },
);

protected async upgrade() {
  const service = await this.upgradeService();
  service.upgrade(this.ticketId());
}

The prefetch option combined with onIdle (based on requestIdleCallback) preloads the bundle as soon as the browser is idle. You get code splitting at the service level, and not only at the route level.

Debouncing Signals with debounced

Unlike Observables, Signals have no notion of time. Angular 22 introduces the debounced function, which creates a Resource whose value is updated after a delay:

import { debounced, effect, signal } from "@angular/core";

const filter = signal("");
const debouncedFilter = debounced(filter, 300);

effect(() => console.log(debouncedFilter.value()));

For forms, debouncing is already built into validateAsync and validateHttp.

HttpClient Uses Fetch by Default

FetchBackend becomes the default HttpClient backend, and withFetch() is deprecated.

The main consequence is that the Fetch API can’t report upload progress. The reportProgress option is therefore split in two:

  • reportDownloadProgress, which works with Fetch
  • reportUploadProgress, which requires withXhr()

Using reportUploadProgress with Fetch throws an error, on purpose. Here again, ng update adds withXhr() to your configuration to preserve the existing behaviour.

Templates Get Closer to TypeScript

Between versions 21.1, 21.2 and 22, the template syntax gained a lot of new features:

  • object and array spread, and rest arguments: [class]="{ ...base, active: isActive() }"
  • arrow functions with implicit return: (click)="select((x) => x.id === item.id)"
  • instanceof directly inside an @if block
  • multiple fall-through @case blocks in a @switch
  • @default never; for an exhaustive @switch over a union type, and, new in 22, @default never(state); to target the enclosing union when switching on a discriminant
  • the ?. operator now follows the exact JavaScript semantics (undefined if the chain breaks) and enables real TypeScript narrowing afterwards
  • // and /* */ comments are allowed inside a tag, to document long lists of attributes
  • @defer (on idle(2000)) accepts a timeout

@default never(...) is especially interesting: it turns your @switch blocks into compile-time checks. If you add a value to your union type without handling it in the template, the build fails.

Router Improvements

The Router also received several improvements:

  • isActive(path, router, options) returns a Signal re-evaluated on every navigation, which is handy for active CSS classes.
  • withExperimentalAutoCleanupInjectors() destroys environment injectors (and their services) when leaving a route.
  • RouterLink gets a browserUrl input to display a different URL in the address bar than the one used internally.
  • Wildcard routes accept segments around **, for example 'foo/**/bar'.
  • Route parameters are now inherited from all parent routes by default.

Other Notable Changes

  • Incremental hydration is enabled by default by provideClientHydration(). Use withNoIncrementalHydration() to disable it.
  • Angular Aria is now stable.
  • ApplicationRef.bootstrap() accepts a configuration object (hostElement), and Angular can bootstrap inside a shadow root: two steps towards cleaner micro-frontends.
  • AI tooling: official agent skills, experimental WebMCP support (provideExperimentalWebMcpTools), and in development mode an angular:di-graph tool exposing the injection graph to in-page AI assistants.
  • TypeScript 6 is supported (5.9 is dropped), as well as Node.js 22 to 26.
  • Angular DevTools 1.15 comes with an improved Signals graph.
  • Many security fixes (sanitization, SSRF), which is another good reason not to postpone the update.

Migrating to Angular 22

The automatic migrations (Eager, withXhr(), hydration) soften the impact of the breaking changes, so the update should be smooth for most applications. Here is a simple plan:

  1. Run ng update, then search for the ChangeDetectionStrategy.Eager markers it added: this is your cleanup backlog.
  2. Replace ad hoc data loading code with httpResource.
  3. Migrate a pilot form to Signal Forms using compatForm before rolling it out to the rest of the application.

Conclusion

Angular 22 is not a release full of surprises, but it is an important one. Signals are no longer a set of promising experimental APIs: with OnPush by default, a stable Resource API and production-ready Signal Forms, they are now the foundation on which to build Angular applications.

If you have been waiting since Angular 20 to adopt Signals, this is the right time to upgrade.

Resources