Skip to content
Tutorials Center
My learning

Topics

Lesson 57 of 74 ยท Tooling and Ecosystem

What Changed in Each Angular Version

A readable timeline of Angular from the 2016 rewrite to Ivy, standalone components, signals, new control flow and zoneless apps, plus how to upgrade safely with ng update.

Angular is released on a schedule: a major version roughly every six months, with minor and patch releases between them. Each major version is supported for a limited time (about 18 months in total), and the team promises that you can upgrade one major at a time with automated migrations. Because the framework changed a lot between 2016 and today, knowing the timeline helps you read old code, answer "which version is this?" and plan upgrades.

This lesson gives you the story in order, a table of the milestones you will actually meet, and a safe upgrade routine. It builds on Introduction and NgModules and Legacy Angular Code.

Real versus stand-in. The bash and typescript blocks are real commands and code to read. The runnable example is a small TypeScript planner that lists the major versions an upgrade has to pass through; it models the rule, not the real tool. Release years and feature status below are a simplified summary; several features moved from "experimental" to "stable" across releases, so check the official release notes and update guide for the exact version you use.

The story in four eras

flowchart LR
  A["2016-2019<br/>Angular 2 to 8<br/>NgModules, View Engine"] --> B["2020-2022<br/>Angular 9 to 14<br/>Ivy, strict mode, standalone preview"]
  B --> C["2022-2024<br/>Angular 15 to 18<br/>standalone stable, signals, new control flow"]
  C --> D["2024 and later<br/>Angular 19 and up<br/>standalone default, signal APIs stable, zoneless"]

Each era removed a layer of ceremony: first module configuration, then change detection magic.

Angular 2 (2016) was a full rewrite of AngularJS (version 1.x), a different framework with components, TypeScript and a CLI. From there on, "Angular" always means the new framework (Angular vs AngularJS). There was no version 3 because the router package had already reached 3; the project then adopted semantic versioning, and versions 4, 5, 6, 7 and 8 added improvements without breaking the model.

Angular 9 (2020) made Ivy the default compiler and runtime. Ivy produced smaller bundles, better error messages and made later features possible, such as standalone components and the tree-shakeable runtime.

Milestones you will meet

Version Year What it brought
2 2016 New component-based framework in TypeScript
9 2020 Ivy compiler and runtime by default
14 2022 Standalone components (developer preview), typed reactive forms, inject() in more places
15 2022 Standalone APIs stable, functional router guards, directive composition API
16 2023 Signals (developer preview), required inputs, router data as inputs, non-destructive hydration preview
17 2023 New control flow (@if, @for, @switch), @defer, new application builder on esbuild and Vite, new branding and docs
18 2024 Experimental zoneless change detection, default content for <ng-content>, unified router/forms events
19 2024 Standalone is the default (no flag), linkedSignal and resource (experimental), incremental hydration and event replay
20 2025 Core signal APIs (effect, linkedSignal, toSignal) stable, zoneless in developer preview, httpResource experimental, template improvements
21 2025 Zoneless as the default for new apps, signal-based forms, newer test tooling

Use this table for orientation rather than for exact details. Features often appear in one release as experimental, become developer preview, then stable, and sometimes the API names change on the way. The release notes list each feature's status.

What the milestones mean for your code

NgModules to standalone (14 to 19). In version 15 you could drop modules; in 19 you could stop writing standalone: true. Code from each year therefore looks different, which is why NgModules and Legacy Angular Code exists.

TypeScript
// 2020 style
@Component({ selector: 'app-hello', template: `<p *ngIf="show">{{ name }}</p>` })
export class HelloComponent { @Input() name = ''; show = true; constructor(private http: HttpClient) {} }

// current style
@Component({ selector: 'app-hello', template: `@if (show()) { <p>{{ name() }}</p> }` })
export class Hello { name = input(''); show = signal(true); private http = inject(HttpClient); }

Signals (16 to 20). Signals replaced "check everything after any event" with precise dependency tracking. The API grew over several versions: signal, computed and effect, then signal inputs and outputs, model(), view queries as signals, linkedSignal, resource and signal forms. See Signals and Signals and RxJS Interop.

Control flow and deferred views (17). @if/@for/@switch are part of the template syntax, faster than structural directives, and do not need an import. @defer loads parts of a page lazily (Control Flow, Deferrable Views). Old *ngIf still works.

Zone.js to zoneless (18 to 21). Zone.js patched browser APIs to know when to re-render. Zoneless apps rely on signals and explicit notifications, which gives smaller bundles and cleaner stack traces (Change Detection). Which mode is the default depends on the version, so check your app.config.ts.

Build tooling (17 onward). The application builder uses esbuild and Vite, so builds and reloads are much faster than the old webpack builds (How Angular Works).

Server rendering. Hydration (16), then built-in SSR in new projects (17), incremental hydration (19) and route-level render modes (SSR and Hydration).

Upgrading with ng update

The Angular team maintains the update guide (a tool on angular.dev that lists steps for your exact from and to versions) and the ng update command, which upgrades packages and runs migrations: code transformations that rewrite your source for breaking changes.

The rules:

  1. One major version at a time. Going from 17 to 20 means 17 to 18, then 18 to 19, then 19 to 20. Skipping makes the migrations unreliable.
  2. Start clean. Commit all changes first; run the build and tests so you know the starting state.
  3. Update the core first, then the other Angular packages (Material, CDK, NgRx, ESLint plugins), then third-party libraries.
  4. Build and test after each step, and commit it separately so you can bisect problems.
Terminal
git status                                   # must be clean
ng version                                   # check the starting version
ng update @angular/core@19 @angular/cli@19   # one major at a time
ng build && ng test --watch=false
git commit -am "Update Angular to 19"

ng update @angular/material@19               # if you use Material
npm outdated                                 # then third-party packages

Use ng update with no arguments to see what is available. If a package blocks you with an incompatible peer dependency, check whether a newer release supports the target version before forcing the install with --force. Forcing can hide real incompatibilities.

After upgrading, optionally run the optional migrations on separate commits, since they change a lot of lines but not behavior: @if/@for instead of structural directives, input()/output() instead of decorators, inject() instead of constructor parameters, and standalone (NgModules).

TypeScript A stand-in: plan the steps of an upgrade

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with node:readline or readFileSync(0)), it gets the next line from this box.

The planner shows why a jump from 15 to 21 means six separate update rounds, and why you should not let an app fall far behind: each round is a small, tested step, and the longer you wait, the more steps there are at once. Treat an upgrade every six to twelve months as normal maintenance.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Which release made the Ivy compiler and runtime the default?

    Angular 9 switched to Ivy by default. It brought smaller bundles and was the base for later features such as standalone components.
  2. 2. Which feature arrived in Angular 17 and changed the template syntax?

    Version 17 introduced the built-in blocks and @defer. They replace *ngIf, *ngFor and *ngSwitch in new code.
  3. 3. You are on Angular 16 and want version 18. What is the safest approach?

    ng update migrations are designed for one major version at a time. Build, test and commit after each step.
  4. 4. What is the usual lifecycle of a new Angular feature?

    The team ships new ideas early, marks their status, and stabilizes them over a few releases. Check the release notes before relying on a preview API.

Summary

  • Angular has a major release about every six months; Angular 2 (2016) was a rewrite of AngularJS.
  • Ivy (9), standalone (14 and 15, default in 19), signals (16 and later), control flow and @defer (17), and zoneless change detection (18 to 21) are the big shifts.
  • Features move from experimental to developer preview to stable, so check release notes for status.
  • Upgrade with ng update one major at a time, from a clean commit, building and testing at every step.
  • Run optional migrations (control flow, input(), inject()) in separate commits.

Next: package your code for use elsewhere in Angular Elements and Web Components, or see how the pieces ship in Build and Deploy.