Short answer: Angular 20 support ends on 28 November 2026. Upgrade to Angular 22, stepping through 21 with ng update: Angular 21 is already in long-term support and ends in June 2027, while 22 is the only version in active support, is supported until June 2028, and Angular 23 is not due until about June 2027.
In our test, a realistic Angular 20 app reached 22 with two ng update commands, and its build and unit tests passed after each one. Most of the remaining work sits around Angular: Node.js, TypeScript 6.0 settings and third-party libraries. Dates and versions below come from angular.dev and the npm registry, checked on 18 November 2026. If you want the upgrade done for you, see our Angular development and upgrade services.
When does Angular 20 support end, and how long are Angular 21 and 22 supported?
Angular 20 support ends on 28 November 2026. After that, Angular 21 and 22 are the only supported versions; Angular 2 to 19 are already unsupported.
| Angular | Released | Active support | Long-term support (LTS) ends | Latest release on 18 November 2026 |
|---|---|---|---|---|
| 20 | 28 May 2025 | Ended 19 November 2025 | 28 November 2026 | 20.3.35 |
| 21 | 19 November 2025 | Ended 3 June 2026 | June 2027 | 21.2.26 |
| 22 | 3 June 2026 | Until June 2027 | June 2028 | 22.2.6 |
Sources: Angular's supported versions table, and the npm registry for the latest releases (the v20-lts, v21-lts and latest tags of @angular/core).
What does 12 months active plus 12 months LTS mean for planning?
Until v22, Angular shipped a major version every six months. From v22 it ships one major a year, and each major is typically supported for 24 months: 12 months of active support with regular updates and patches, then 12 months of LTS with only critical fixes and security patches. Angular 20, from the six-month era, got about 18 months in total.
For planning, that means:
- Two majors are supported at any time: this year's, in active support, and last year's, in LTS.
- One upgrade a year keeps you supported. Angular 23 is expected around June 2027, so a team on 22 can move to 23 at any point between then and June 2028.
- The newest major buys the most time. Moving to 22 now covers you until June 2028, about a year and a half away. Stopping at 21 covers you until June 2027, six to seven months away.
What does end of support mean for Angular 20 in practice?
Nothing stops working on 28 November: your app keeps running and the 20.x packages stay on npm. What stops is new releases. Under Angular's LTS policy, a version in LTS gets fixes for newly found security vulnerabilities and for regressions caused by third-party changes such as a new browser version. After 28 November, Angular 20 gets neither.
- Security fixes go to 21 and 22 only. In February 2026, a critical vulnerability in Angular's server-side rendering package, CVE-2026-27739, was fixed in
@angular/ssr21.1.5 and also in 20.3.17 and 19.2.21, because Angular 20 and 19 were in LTS at the time. For@nguniversal, the server-side rendering packages used before Angular 17, the advisory lists no patched version. That is what end of support looks like. - The last Angular 20 release so far is 20.3.35, published on 2 November 2026.
- Libraries move on with Angular. The latest NgRx, PrimeNG, ng-zorro-antd and ngx-bootstrap releases accept only Angular 22 (see the library section below), so their fixes stop reaching Angular 20 apps too.
- Node.js 20 is already out of support. It reached end of life on 30 April 2026, and Angular 22 no longer supports it.
Should we upgrade to Angular 21 or 22?
Angular 22, for most teams. It is supported for a year longer, it is the only version still in active support, and in our test the step from 21 to 22 took one ng update command.
| Angular 21 | Angular 22 | |
|---|---|---|
| Status on 18 November 2026 | LTS: critical fixes and security patches only | Active: regular updates and patches |
| Supported until | June 2027 | June 2028 |
| Node.js | ^20.19.0, ^22.12.0 or ^24.0.0 | ^22.22.3, ^24.15.0 or ^26.0.0 |
| TypeScript | 5.9 | 6.0 |
Components with no changeDetection setting |
Checked on every change detection run | OnPush; ng update keeps existing components on the old behaviour |
HttpClient default backend |
XHR | fetch; withXhr() restores XHR |
| Libraries we checked (below) | All have a release for 21 | AngularFire only as a release candidate; ngx-toastr not yet |
| Our test app: build and 8 unit tests | Passed | Passed |
Sources: releases, version compatibility, the 22.0.0 changelog, and the npm registry.
Why 22:
- Runway. Stopping at 21 means another upgrade by June 2027; 22 moves it to June 2028.
- Active support. Angular 22 still gets regular fixes; 21 gets only critical and security fixes.
- The step is mostly automated. In our test,
ng updatemade every code change 22 needed and raised TypeScript to 6.0 by itself. - Nothing newer is close. There is no Angular 23 yet. The release schedule has 22.3 around November 2026, 22.4 and 22.5 in early 2027, and 23.0 around June 2027.
When stopping at 21 makes sense: only for a while, when something outside Angular blocks 22.
- A library you cannot replace has no Angular 22 release. On 18 November 2026, the latest stable AngularFire release, 21.0.0, requires Angular 21.2 and TypeScript below 6.0; its first release candidate for 22 came out on 16 November.
- Node.js cannot move yet. Angular 22 needs Node.js 22.22.3 or 24.15.0 or newer, so a build server stuck on an older Node.js holds you at 21.
Even then, do the 21 step now: it is the smaller step, and it puts you back on a supported version.
How do we upgrade from Angular 20 to 22, step by step?
Angular's ng update moves one major version at a time, so 20 to 22 is two updates. We tried skipping 21: on an Angular 20 app, ng update @angular/core@22 stops with "Updating multiple major versions of '@angular/core' at once is not supported."
- Start clean on the last 20.x release, with the build and tests passing. The 20 update took our 20.1 test app to 20.3.35.
- Move Node.js to 24.15.0 or newer, as its own change. Angular 20, 21 and 22 all accept Node.js 24, so both Angular steps run on it, and it is supported until 30 April 2028 (Node.js 22 ends on 30 April 2027). Update CI images, Dockerfiles and
.nvmrcfiles together. - Update to 21, naming in the same command any library that accepts only one Angular major (see the library section), then run Angular Material's update if you use it.
ng updateraises TypeScript to 5.9 when needed. Build, test, commit. - Update to 22 the same way.
ng updateraises TypeScript to 6.0; fix any compiler option it rejects (below). Build, test, commit. - Check the dependency tree:
npm ls @angular/coreshould report nothing as invalid. - Test the app as users use it, then release with a way back.
ng update refuses to run on a Git working tree with uncommitted changes unless you pass --allow-dirty, so commit after each update. Each commit is also a point to go back to.
# Before you start: a branch, the last 20.x release, a clean build and tests
git switch -c upgrade-angular-22
node --version # 24.15.0 or newer: Angular 20, 21 and 22 all accept it
npx ng update @angular/core@20 @angular/cli@20
npx ng build && npx ng test --watch=false
git add -A && git commit -m "Update to the last Angular 20 release"
# Step 1: Angular 20 to 21 (raises TypeScript to 5.9 if needed).
# Name libraries that accept only one Angular major, such as NgRx, in the same command.
npx ng update @angular/core@21 @angular/cli@21 @ngrx/store@21
git add -A && git commit -m "Update to Angular 21"
npx ng update @angular/material@21 # only if you use Angular Material
npx ng build && npx ng test --watch=false
git add -A && git commit -m "Update Angular Material to 21"
# Step 2: Angular 21 to 22 (raises TypeScript to 6.0)
npx ng update @angular/core@22 @angular/cli@22 @ngrx/store@22
git add -A && git commit -m "Update to Angular 22"
npx ng update @angular/material@22 # only if you use Angular Material
npx ng build && npx ng test --watch=false
git add -A && git commit -m "Update Angular Material to 22"
# Afterwards: an "invalid" line names a library that does not accept 22
npm ls @angular/coreWhat did ng update change in a real Angular 20 app?
We built a small but realistic Angular 20 app (a product list that loads data with HttpClient, a lazy-loaded route with a reactive form, and Karma unit tests) and ran the commands above on Node.js 24.22.1. Variants of it covered older setups. This is what ng update did:
| Step | Versions after | What ng update changed |
Build and 8 unit tests |
|---|---|---|---|
| 20 to 21 | Angular 21.2.26, CLI 21.2.30, TypeScript 5.9.3 | Rewrote *ngIf and *ngFor in one component as @if and @for. In variants: raised TypeScript from 5.8.3, added provideZoneChangeDetection() to main.ts where the app config lacked it, and switched moduleResolution from node to bundler |
Passed |
| 21 to 22 | Angular 22.2.6, CLI 22.2.7, TypeScript 6.0.3 | Added changeDetection: ChangeDetectionStrategy.Eager to all three components; added withXhr() to the one provideHttpClient() call without withFetch(); turned off two new template diagnostics in tsconfig.app.json and tsconfig.spec.json; added istanbul-lib-instrument for Karma coverage |
Passed, except the variant with baseUrl (below) |
- Read the diff. The control flow rewrite was correct but shifted a template's indentation, so run your formatter afterwards.
- Karma still works on 21 and 22.
ng updateoffers optional migrations to Vitest (--name migrate-karma-to-vitest) and, for apps on the Webpack builders that 22 deprecates, to the application builder (--name use-application-builder). Make each a separate change. - Angular Material followed cleanly, from 20.2.14 to 21.2.14 and 22.3.0, with the build and tests passing.
What changes from Angular 20 to 21?
Most of it is handled by ng update, and Node.js requirements do not change (^20.19.0, ^22.12.0 or ^24.0.0 for both). The items most likely to affect an existing app, from the 21.0.0 changelog, the CLI changelog and the update guide:
| Change in 21 | What to do |
|---|---|
| TypeScript 5.9 or newer required | ng update raises it (tested) |
Zone-based apps must provide provideZoneChangeDetection(), because Angular no longer adds the zone scheduler by default |
ng update adds it (tested) |
| Host bindings are type-checked by default | Fix the new build errors, or set typeCheckHostBindings: false for now |
Tests: TestBed rethrows errors when provideZoneChangeDetection is used, router navigations take extra microtasks, and TestBed uses a new fake PlatformLocation |
Fix the failing tests; wait for navigations to finish before asserting |
Removed: ApplicationConfig from @angular/platform-browser, moduleId and interpolation in @Component, NgModuleFactory, UpgradeAdapter |
ng update moves the ApplicationConfig import; the rest is by hand |
Router.lastSuccessfulNavigation is now a signal |
ng update adds the call |
Angular CDK overlays can render in the browser's top layer, so z-index stacking may change |
Check dialogs, menus and tooltips |
Server-side rendering: main.server.ts passes a BootstrapContext |
ng update updates it |
What changes from Angular 21 to 22?
This step changes more defaults. ng update keeps the old behaviour where it can; the rest needs checking. From the 22.0.0 changelog, the CLI changelog and the update guide:
| Change in 22 | What to do |
|---|---|
| Node.js 20 dropped; needs ^22.22.3, ^24.15.0 or ^26.0.0 | Move Node.js first |
| TypeScript 6.0 required | ng update raises it (tested); deprecated compiler options now fail the build (below) |
Components with no changeDetection setting default to OnPush |
ng update adds ChangeDetectionStrategy.Eager to keep the old behaviour (tested) |
HttpClient uses fetch by default, and withFetch() is deprecated |
ng update adds withXhr() where the XHR backend was in use (tested); upload progress reporting needs XHR |
In templates, ?. returns undefined instead of null, and nullable types narrow, which raises two new diagnostics |
ng update turns the diagnostics off (tested) and wraps existing ?. expressions in $safeNavigationMigration() to keep null; check comparisons with null |
strictTemplates is on by default |
ng update sets strictTemplates: false where it was not set |
Router: paramsInheritanceStrategy defaults to 'always', provideRoutes() is removed, and CanMatch needs its third argument |
ng update adds the argument where canMatch is called; update class implementations by hand, and set 'emptyOnly' to keep the old parameter behaviour or check routes that read parent parameters |
Removed: ComponentFactoryResolver, ComponentFactory, createNgModuleRef, ChangeDetectorRef.checkNoChanges() and the Hammer.js integration |
By hand: pass component classes to ViewContainerRef.createComponent() |
Forms: min and max validators no longer accept strings |
Bind numbers |
Compiler errors for duplicate input or output bindings and for elements matched by more than one component; data- attributes no longer bind to inputs or outputs |
Fix the templates; use explicit bindings instead of data- attributes |
Server-side rendering: incremental hydration is the default, and unrecognised Host headers get a 400 response |
ng update adds withNoIncrementalHydration() where needed; list your hosts in allowedHosts |
CLI: Karma coverage needs istanbul-lib-instrument, ng serve gives the PORT variable priority, and the Webpack builders are deprecated |
ng update adds the package (tested) |
// What ng update added to our components and tests on the way to 22
import { ChangeDetectionStrategy, Component } from '@angular/core';
import { provideHttpClient, withXhr } from '@angular/common/http';
@Component({
selector: 'app-product-list',
// Added to every component with no changeDetection setting,
// so it keeps the Angular 21 behaviour now that OnPush is the default
changeDetection: ChangeDetectionStrategy.Eager,
template: `...`,
})
export class ProductList {}
// Added where provideHttpClient() relied on the XHR backend.
// Keep it where you report upload progress; test before removing it elsewhere.
export const httpProviders = [provideHttpClient(withXhr())];Does TypeScript 6.0 break our tsconfig?
It can, and ng update does not fix it. TypeScript 6.0 deprecates several compiler options, and using one stops the build. The one Angular apps are most likely to have is baseUrl, often set for path aliases such as @app/*. In our variant with it, the Angular 22 build failed with error TS5101, "Option 'baseUrl' is deprecated and will stop functioning in TypeScript 7.0."
Removing baseUrl and starting each paths entry with ./ fixed it, and the build and tests passed. Setting "ignoreDeprecations": "6.0" also let it build, but that only lasts until TypeScript 7. Other options TypeScript 6.0 deprecates include moduleResolution: node (the 21 step had already switched ours to bundler), target: es5, downlevelIteration and outFile.
// tsconfig.json, inside "compilerOptions"
// Before: fails on Angular 22 and TypeScript 6.0 with error TS5101
"baseUrl": "./",
"paths": { "@app/*": ["src/app/*"] }
// After: no baseUrl, and each path starts with ./ (relative to tsconfig.json)
"paths": { "@app/*": ["./src/app/*"] }
// Stopgap only: keeps baseUrl until TypeScript 7
"ignoreDeprecations": "6.0"Are our third-party libraries ready for Angular 22?
Check every package that depends on Angular before you start, because ng update does not always stop you. In our tests it stopped for ngx-toastr, which accepts only Angular 21. With NgRx 21 installed, which also accepts only 21, it did not: it moved Angular to 22 and left NgRx behind. The build passed, but npm ls reported @angular/core as invalid and a fresh npm install failed with ERESOLVE, which is what your CI server would hit next. Naming @ngrx/store@22 in the same ng update command fixed it.
What the npm registry showed on 18 November 2026:
| Library | Release for Angular 22 | Release for Angular 21 |
|---|---|---|
| Angular Material and CDK | 22.3.0 (accepts 22 and 23) | 21.2.14 (accepts 21 and 22) |
| NgRx | 22.0.1 | 21.1.1 |
| PrimeNG | 22.1.5 (needs 22.1 or newer) | 21.1.10 |
| ng-bootstrap | 21.0.0 (its numbers run one behind Angular's) | 20.0.0 |
| ngx-bootstrap | 22.0.0 | 21.2.2 |
| ng-zorro-antd | 22.2.0 | 21.3.3 |
| AngularFire | Release candidate only: 22.0.0-rc.1, 16 November 2026 | 21.0.0 (needs 21.2 or newer) |
| ngx-toastr | None yet | 20.0.5 |
Libraries such as ngx-translate 18.1.0, Ionic Angular 9.0.12 and auth0-angular 2.16.0 declare open-ended ranges (Angular 18 or newer, or 13 or newer), so they do not block the install; that is not the same as being tested on 22.
Expect libraries to trail Angular. Angular Material released for 22 on 3 June 2026, the day Angular 22 came out; ng-bootstrap followed on 22 June, PrimeNG on 15 July and NgRx on 24 August. If one of yours has nothing for 22, upgrade to 21 now, then wait, replace it or contribute the fix. Forcing past the check (--force on ng update, --legacy-peer-deps on npm) installs a combination its authors have not declared support for.
# Which Angular versions does a library's latest release accept?
npm view @ngrx/store peerDependencies
# Which releases exist for a given major, and is there a prerelease for 22?
npm view @ngrx/store@21 version
npm view @angular/fire dist-tags
# Installed packages that depend on Angular; "invalid" marks a mismatch
npm ls @angular/coreHow do we test and roll out the upgrade with a way back?
An Angular upgrade does not touch your data, so going back is a redeploy of the previous build, as long as you keep the release simple.
- Ship the upgrade on its own, with no feature work or backend changes in the same release, so going back changes one thing.
- Test more than the unit tests. Run end-to-end tests on the main user journeys against a production build, and click through the screens most likely to change: forms using
minandmax, routes that read parent route parameters, uploads with progress bars, dialogs and menus that rely onz-index, and templates that compare a?.result withnull. - Keep the last Angular 20 build, tagged, with the command that redeploys it written down.
- Keep the old build's files on the server for a while. Our lazy-loaded route chunk had a different file name on 20, 21 and 22, and a browser that loaded the old version will still ask for the old files. Remove them a few days later, not during the deploy.
- Release to some users first if your hosting allows it, and watch the error tracker.
- Agree in advance what sends you back, such as a rise in front-end errors, and who makes the call.
What should we do if we cannot upgrade before 28 November 2026?
End of support means no more fixes, not a shutdown, so plan the next weeks instead of rushing a release:
- Do the 21 step first. It is the smaller one (in our test, one component rewritten automatically), it needs no Node.js change if you already run 20.19, 22.12 or 24, and it puts you back on a supported version until June 2027. Then plan 22 for early 2027.
- Until then, run the last 20.x release (20.3.35 at the time of writing, via
ng update @angular/core@20 @angular/cli@20), so you have every fix Angular shipped for 20. - Watch for advisories on the Angular packages you use, through
npm auditand the security advisory pages of angular/angular and angular/angular-cli. After 28 November, a fix for a new vulnerability will come in 21 and 22, not in 20. - Move Node.js off version 20 now. It is past end of life, and Angular 20 already runs on Node.js 22.12 or 24, so the move also prepares both Angular steps.
- Write the decision down: who accepted the risk, until when, and the planned date for each step.
How we approach an Angular upgrade at MicroPyramid
We start with an assessment, then run the upgrade as a fixed project that we finish and hand back to your team.
The Upgrade Assessment is a dependency and end-of-life audit of your Angular app and what it runs on: which libraries block 22, which compiler options TypeScript 6.0 will reject, where the tests are thin, and the order to move Node.js, Angular and the libraries in.
The upgrade is then a fixed project: Node.js moved, both ng update steps run and reviewed, blocking libraries upgraded or replaced, tests added where the risky screens had none, and a release with the previous build ready to redeploy. We hand it back with notes on what changed. To stay on supported versions afterwards, our software maintenance is a monthly retainer that runs month to month with 30 days' notice.
Still on Angular 20? Book an Angular Upgrade Assessment and we will show you what the path to Angular 22 looks like for your app.
Frequently Asked Questions
When does Angular 20 support end?
On 28 November 2026, when its long-term support ends; its active support ended on 19 November 2025. After that date Angular releases no more 20.x versions, security fixes included. Angular 21 is supported until June 2027 and Angular 22 until June 2028.
Is Angular 21 still supported?
Yes, until June 2027, but only in long-term support. Since Angular 22 came out on 3 June 2026, version 21 gets only critical fixes and security patches. Its latest release on 18 November 2026 is 21.2.26.
Can I skip Angular 21 and go straight to 22?
Not with ng update. Angular supports updating one major version at a time, and ng update @angular/core@22 on an Angular 20 app refuses to run. Update to 21, check the build and tests, then update to 22; both steps can still go out in the same release.
Is there an Angular 23?
Not yet. On 18 November 2026 the latest release is 22.2.6, with 22.3 in release candidates. Angular's schedule expects version 23.0 around June 2027, and since version 22 there is one major release a year.
What Node.js version does Angular 22 need?
Node.js ^22.22.3, ^24.15.0 or ^26.0.0; Node.js 20 is no longer supported. Node.js 24 is the practical choice for the upgrade, because Angular 20 and 21 accept it too, and it is supported until 30 April 2028.
What TypeScript version does Angular 22 need?
TypeScript 6.0 (at least 6.0, below 6.1). ng update installs it for you, 6.0.3 in our test, but TypeScript 6.0 turns deprecated compiler options such as baseUrl into build errors, so check your tsconfig.json files.
What happens if we stay on Angular 20 after 28 November 2026?
The app keeps running, but new vulnerabilities and browser-related regressions in Angular 20 will not be fixed. The latest releases of libraries such as NgRx and PrimeNG already require Angular 22, and Node.js 20, which Angular 20 still runs on, is out of support too.