Angular versioning and staying current

Intermediate · 8 min

How Angular's release cadence and semantic versioning work, and how `ng update` moves a real app across major versions.

Before thisThe CLI, project anatomy, and standalone bootstrapping

Nihira Techiees · 8 min

Angular versioning and staying current

The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.

Taught by Nihira TechieesReport a problem with this video
Not started
Set this lesson's status

What you'll learn

  • Angular ships a new major version roughly every six months, and commits to supporting each major for 18 months total (6 active + 12 long-term support).
  • Angular's idea of "breaking" almost always means deprecated, then removed one or two majors later — not silently changed behavior; deprecations are documented and usually ship an automated migration.
  • Running `ng update` runs schematics — small code-mod scripts — that rewrite your code for you where a change is mechanical, not just a version bump in `package.json`.

The problem a release schedule solves

A framework that changes whenever its maintainers feel like it is a framework you can’t plan around. If you don’t know when the next breaking change is coming, you either freeze your dependencies forever (and slowly rot) or you upgrade in a panic every time something breaks. Neither is sustainable for a team shipping a real product over years, not months.

Angular’s answer is a published, predictable schedule: a new major version roughly every six months, each one supported for eighteen months total — six months as the “active” release getting new features, then twelve more as long-term support getting only critical fixes and security patches. You can look at a release calendar today and know, approximately, when the version you’re running stops getting patched. That’s the entire point: predictability is the feature, not the version number itself.

What “breaking” actually means in practice

Semantic versioning says a major version bump is allowed to break things. In an ecosystem that took that literally, every major release would be a scramble. That’s not how Angular’s major releases actually work, because the framework leans hard on a middle step: deprecation.

The typical path for a change is: introduce the new API alongside the old one → mark the old one @deprecated with a note on what replaces it → leave both working for at least a full major version, often two → remove the old one only once there’s been real time to migrate. You can see this pattern directly in recent history — the shift from constructor-only dependency injection to the inject() function, or from *ngIf/*ngFor to the @if/@for control-flow blocks, didn’t delete the old syntax the moment the new one shipped. Both existed side by side for a long stretch specifically so nothing broke on upgrade day.

That’s why “major version” in Angular rarely means “rewrite your app this weekend.” It usually means “some things you were already warned about, several versions ago, are finally gone.”

ng update: not just a version bump

Bumping @angular/core in package.json by hand and running npm install will get you the new code, but it won’t fix the places your code relied on something that changed. That’s what ng update is for. Running:

ng update @angular/core @angular/cli

does two things: it updates the packages, and it runs any schematics those packages ship for that specific version jump. A schematic is a small, scripted code transform — not a human rewriting your files, but an automated pass that knows the shape of the old pattern and the shape of the new one, and rewrites your source accordingly wherever it safely can. Not every migration is fully automatable — some genuinely need a judgment call only you can make — but the mechanical, repetitive part of a migration (renaming an import, converting an options object’s shape) is exactly what a schematic exists to absorb.

This lesson’s video walks through a real ng update run, major-version to major-version, which is the clearest way to see schematics actually doing work instead of reading about them abstractly. Watch for the files it touches without you asking it to — that’s the schematic, not a manual edit.

Reading the changelog instead of guessing

Angular publishes its changelog, its deprecation list, and update guides as part of its own documentation — not scattered across blog posts you have to go hunting for. Before running ng update on anything beyond a patch version, it’s worth a few minutes reading what that specific jump changes. The schematic handles the mechanical part; the changelog tells you what to expect it to touch, so a failed build after an update is a known trade-off you read about, not a surprise.

Check yourself

  1. 01If a feature is marked deprecated in Angular 17, roughly how much time do you realistically have before it might be removed?

    At least a full major version's worth of notice, often two — Angular's convention is to deprecate a feature, document the replacement, and only remove it a major version or two later, not in the very next release.

  2. 02What does `ng update @angular/core @angular/cli` actually do beyond bumping version numbers in `package.json`?

    It runs the update schematics those packages ship for that version jump — automated code transforms that handle the mechanical parts of a migration (renaming an API, converting a deprecated pattern to its replacement) so you don't have to do it by hand across every file.

Go deeper

Notes

Private to you

Esc
↑↓ navigate↵ open? shortcuts

Keyboard shortcuts

Press Esc to close

Anywhere

⌘K
Search and commands
/
Search
?
This sheet
Esc
Close

Reading a lesson

J
Next lesson
K
Previous lesson
B
Bookmark