Angular versioning and staying current
How Angular's release cadence and semantic versioning work, and how `ng update` moves a real app across major versions.
Angular versioning and staying current
The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.
Not started
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
If 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.
What 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
Notes are saved to your account.
Everything else on this page works without one — progress and bookmarks keep themselves in this browser and come with you when you sign in. Notes are the one thing worth not trusting to a browser you might clear.
Your notes could not be loaded.