Angular History and Version History

Angular has gone through two major generations:

AngularJS (1.x)
      ↓
Complete redesign
      ↓
Angular 2
      ↓
Angular 4 → 5 → 6 → ... → 22

The most important distinction is:

AngularJS and modern Angular are not simply different versions of the same architecture. Angular 2 was a major rewrite.

Official Angular documentation uses AngularJS for the 1.x framework and Angular for Angular 2 and later. Angular

1. Where Angular Started

AngularJS originated at Google and became popular for building dynamic browser applications at a time when server-rendered pages and direct DOM manipulation were much more common.

AngularJS was JavaScript-based and centered around concepts such as:

Controllers
$scope
Directives
Modules
Templates
Two-way data binding
Dependency Injection

A typical AngularJS application looked conceptually like:

HTML
 ↓
AngularJS Directives
 ↓
Controller
 ↓
$scope
 ↓
View

For example:

app.controller('HomeController', function ($scope) {
    $scope.title = 'Welcome';
});

AngularJS eventually became difficult to evolve for increasingly large applications and modern web-development requirements.

This led to a complete architectural redesign.

2. AngularJS vs Angular

This is the historical transition you should remember.

AngularJS
Version 1.x
   |
   | Complete redesign
   v
Angular
Version 2+

Therefore:

AngularJS ≠ Angular 2 with a small upgrade

Angular 2 was effectively a new framework.

3. Angular 2 — The Modern Angular Beginning

Released: September 2016

Angular 2 established the foundation of what we now call Angular. Historical release records place its initial release in September 2016. Wikipedia

Major architectural ideas included:

TypeScript
Components
Decorators
Dependency Injection
RxJS
Angular Router
Forms
Component lifecycle
Modern template syntax

For example:

@Component({
  selector: 'app-home',
  templateUrl: './home.component.html'
})
export class HomeComponent {
}

This was very different from AngularJS controllers and $scope.

AngularJS

Controller
   ↓
$scope
   ↓
View

Angular 2+

Component Class
      ↓
Component Template
      ↓
Browser UI

This was the foundation for all subsequent Angular releases.

4. What Happened to Angular 3?

This is a famous Angular interview question.

There was no Angular 3 major framework release.

Angular packages had become version-number misaligned. In particular, the Angular Router was already on a 3.x version while major framework packages were 2.x.

The team skipped Angular 3 and moved to Angular 4 to better align package versioning. Great Learning

So:

Angular 2
   ↓
Angular 3   ← Skipped
   ↓
Angular 4

Interview Answer

Angular 3 was skipped mainly to align the version numbers of Angular's packages, particularly because the router package was already on version 3.x.

5. Angular 4

Released: March 2017 Wikipedia

Angular 4 was an evolutionary improvement over Angular 2 rather than another rewrite.

The focus included:

• Framework improvements
• Smaller/faster generated code
• Template/compiler improvements
• Continued alignment of Angular packages

An important lesson:

Angular 2 → Angular 4

NOT

AngularJS → another complete rewrite

Angular 4 remained architecturally part of modern Angular.

6. Angular 5

Released: November 2017

Notable improvements included:

• Build Optimizer
• Better Progressive Web Application support
• Material-related improvements
• General compiler/build improvements

Historical Angular release information specifically identifies PWA support and the Build Optimizer among Angular 5's important improvements. Wikipedia

The framework was increasingly becoming a complete enterprise application platform.

7. Angular 6

Released: May 2018

Angular 6 was especially important for tooling and package management.

One of the most important additions was:

ng update

This provided a standardized way to update Angular projects.

Another important command was:

ng add

which allowed packages to integrate themselves into Angular projects using schematics.

Angular 6 also continued Angular Elements/custom-elements work. Historical release records identify experimental custom-element support and ng update among this era's important changes. Wikipedia

This period established a philosophy Angular still follows:

Framework Evolution
       +
Migration Tooling
       =
Easier Upgrades

8. Angular 7

Released: October 2018

Angular 7 focused significantly on performance, tooling, Angular Material and the CDK.

Notable additions included:

• CDK virtual scrolling
• Drag-and-drop capabilities
• Performance improvements
• CLI improvements
• Angular Material/CDK enhancements

Another important historical point:

Starting with Angular 7, the major versions of Angular Core and Angular CLI are aligned. Angular

For example:

@angular/core 7.x
Angular CLI 7.x

9. Angular 8

Released: May 2019

Angular 8 was an important transitional release.

Major developments included:

• Differential loading
• Dynamic imports for lazy routes
• Web Worker support
• TypeScript 3.4 support
• Ivy available as an opt-in preview

Historical release records identify these as key Angular 8 developments. Wikipedia

Ivy would soon become extremely important.

10. Angular 9 — Ivy Becomes Central

Released: February 2020

Angular 9 made Ivy the default compiler/rendering infrastructure.

This was one of the most important technical transitions in Angular's history.

Before:

View Engine

After:

Ivy

Conceptually:

Angular Template
      ↓
Ivy Compiler
      ↓
Efficient JavaScript Instructions
      ↓
Browser

Ivy laid important groundwork for many later Angular improvements.

11. Angular 10

Released: June 2020

Angular 10 was more evolutionary.

The focus included:

• Framework/tooling updates
• Dependency updates
• Compiler improvements
• Stricter project configuration options
• Ecosystem modernization

At this stage Angular had settled into a predictable major-release rhythm.

12. Angular 11

Released: November 2020

Angular 11 continued improving:

Build performance
Compiler
CLI
Testing
Development tooling

It also continued the migration of Angular's ecosystem toward Ivy.

This period is useful to think of as:

Angular 9
   ↓
Ivy becomes default

Angular 10–11
   ↓
Ivy ecosystem matures

13. Angular 12

Released: May 2021

Angular 12 continued the modernization process.

One historically important transition was the move away from older browser support, especially Internet Explorer.

This era also continued moving Angular away from legacy compilation infrastructure.

14. Angular 13

Released: November 2021

Angular 13 was another important cleanup milestone.

The legacy View Engine was removed, simplifying Angular around Ivy. Angular's own roadmap records removal of the legacy View Engine as completed work. Angular

Think:

Old Angular

View Engine + Ivy transition


Angular 13 era

Ivy
 ↓
Primary architecture

Angular 13 also dropped IE11 support.

This allowed Angular to rely more heavily on modern browser capabilities.

15. Angular 14 — Beginning of Standalone Angular

Released: June 2022

This is one of the most important releases for understanding modern Angular.

Angular 14 introduced standalone components as a developer-preview direction and delivered strictly typed reactive forms. Angular's current documentation confirms that reactive forms have been strictly typed by default since Angular 14. Angular

Before standalone:

@NgModule({
  declarations: [
    HomeComponent
  ]
})
export class AppModule {
}

Standalone direction:

@Component({
  standalone: true,
  selector: 'app-home',
  templateUrl: './home.html'
})
export class Home {
}

This began reducing Angular's dependence on:

NgModule

as the primary organizational mechanism.

16. Angular 15 — Standalone Becomes Stable

Released: November 2022

Angular 15 made standalone APIs production-ready/stable.

This represented a major architectural simplification.

Earlier Angular

Component
   ↓
NgModule
   ↓
Application

Standalone Angular

Standalone Component
        ↓
Application

Standalone components specify dependencies directly rather than receiving their compilation scope through NgModules. Angular also provides migration tooling for converting existing NgModule applications. Angular

This is why modern Angular code increasingly uses:

imports: []

directly in component metadata.

17. Angular 16 — Signals Arrive

Released: May 2023

Angular 16 introduced one of the biggest changes to Angular's reactivity model:

Signals

Example:

import { signal } from '@angular/core';

count = signal(0);

Update:

this.count.set(10);

Read:

this.count();

Conceptually:

State
 ↓
Signal
 ↓
State changes
 ↓
Angular knows consumers changed
 ↓
UI can update

Angular's roadmap describes Signals as a rethinking of Angular's reactivity model. Angular

Angular 16 also advanced:

• Server-side hydration
• Standalone APIs
• Required inputs
• Build-system modernization

This began another major Angular transition:

Traditional Angular reactivity
          ↓
Signals-based fine-grained reactivity

18. Angular 17 — Modern Angular Takes Shape

Released: November 2023

Angular 17 was one of the biggest modernization releases.

Important features included:

New Built-In Control Flow

Older:

<div *ngIf="isLoggedIn">
  Welcome
</div>

Modern:

@if (isLoggedIn) {
  <div>Welcome</div>
}

Older:

<div *ngFor="let article of articles">
  {{ article.title }}
</div>

Modern:

@for (article of articles; track article.id) {
  <div>{{ article.title }}</div>
}

Angular's roadmap confirms that built-in control flow first shipped in v17 as developer preview. Angular

Deferrable Views

Angular 17 introduced:

@defer {
  <heavy-component />
}

This gives Angular a template-level mechanism for deferred code loading.

New Build Infrastructure

Angular 17 introduced a Vite/esbuild-based application builder and made it the default for new projects. Angular reports major build-time improvements for hybrid-rendering projects from this modernization. GitHub

Modern Angular Direction

By this point the model was clearly moving toward:

Standalone
+
Signals
+
Built-in Control Flow
+
@defer
+
Modern Build System

19. Angular 18

Released: May 2024

Angular 18 stabilized several technologies introduced earlier.

Most importantly:

Built-In Control Flow Became Stable

Angular 17
   ↓
@if / @for / @switch
Developer Preview

Angular 18
   ↓
Stable

Angular officially records built-in control flow becoming stable in v18. Angular

@defer Became Stable

Deferrable views also graduated to stable.

Experimental Zoneless Angular

Angular 18 introduced experimental zoneless change detection.

Historically, Angular commonly depended on:

zone.js

to help know when application activity might require change detection.

The longer-term direction is to make Angular capable of operating without that dependency.

Angular's roadmap confirms experimental zoneless support began in v18. Angular

Angular 18 also continued improving SSR, hydration, and Material 3.

20. Angular 19

Released: November 19, 2024 Angular

Angular 19 pushed Signals and server rendering further.

Its production-ready signal-oriented APIs included:

Signal inputs
Model inputs
Signal queries
Function-based outputs

Angular's v19 roadmap lists these alongside stable Signals, event replay, deferrable views and built-in control flow. Angular

Angular 19 also advanced:

• Incremental hydration
• Zoneless support
• SSR improvements
• Event replay
• HMR support

A useful historical progression is:

Angular 16
Signals introduced

       ↓

Angular 17–18
Signals mature

       ↓

Angular 19
Signal-based component APIs mature

21. Angular 20

Released: May 28, 2025 Angular

Angular 20 is especially relevant when studying the modern Angular programming model.

Angular's roadmap records several major milestones in the Angular 20 generation.

Signals Mature

Angular reports the fundamental reactivity primitives as stable, including:

signal
effect
linkedSignal
Signal-based inputs
Signal-based queries
``` :chatgpt-content-reference{index="19"}


### Incremental Hydration Became Stable

The progression was:

```text
v19
Incremental hydration
Developer Preview
      ↓
v20
Stable
``` :chatgpt-content-reference{index="20"}


### Zoneless Angular Continued Maturing

Angular 20.2 marked Zoneless Angular stable, according to Angular's v20 roadmap. :chatgpt-content-reference{index="21"}

### Template HMR

Template Hot Module Replacement became stable in v20. :chatgpt-content-reference{index="22"}

So the Angular 20-era architecture is much more:

```text
Standalone
+
Signals
+
Modern Control Flow
+
Zoneless-capable
+
SSR/Hydration
+
Modern Build Tooling

than the traditional NgModule-heavy Angular many developers first learned.

22. Angular 21

Released: November 19, 2025

Angular's support documentation records v21's release on November 19, 2025. Angular

Angular 21 continued the modern direction, including work around:

• Signal Forms
• Angular Aria
• AI-assisted developer tooling
• Angular MCP tooling
• Performance and developer-experience improvements

Angular's official v21 release material highlights Signal Forms, Angular Aria and MCP tooling among its major areas. Angular

23. Angular 22 — Current Major Generation

As of September 2026, Angular 22 is the current active major release. It was released on June 3, 2026. Angular 21 and Angular 20 remain in LTS, while Angular v2–v19 are outside official support. Angular

This is important because Angular recently changed its release cadence.

Historically, Angular had approximately:

1 major release every 6 months

through Angular 21.

From Angular 22 onward, Angular's current policy targets:

1 major release every 12 months
4–6 minor releases per major

with patch/pre-release builds occurring much more frequently. Angular

The currently published roadmap is also increasingly focused on:

Developer experience
Performance
AI developer experience
Signals integration
Modern tooling
``` :chatgpt-content-reference{index="27"}


---

# 24. Complete Angular Version Timeline

Here is the timeline worth remembering for interviews:

| Version | Release | Major Historical Importance |
|---|---:|---|
| AngularJS 1.x | 2010 era | Original JavaScript framework |
| Angular 2 | Sep 2016 | Complete rewrite; components + TypeScript |
| Angular 3 | **Skipped** | Package/version alignment |
| Angular 4 | Mar 2017 | Performance/compiler improvements |
| Angular 5 | Nov 2017 | Build Optimizer, PWA improvements |
| Angular 6 | May 2018 | `ng update`, `ng add`, tooling |
| Angular 7 | Oct 2018 | CDK, virtual scrolling, CLI/core alignment |
| Angular 8 | May 2019 | Ivy preview, differential loading |
| Angular 9 | Feb 2020 | **Ivy default** |
| Angular 10 | Jun 2020 | Tooling/framework modernization |
| Angular 11 | Nov 2020 | Build/compiler improvements |
| Angular 12 | May 2021 | Modernization, IE transition |
| Angular 13 | Nov 2021 | **View Engine removed**, IE11 dropped |
| Angular 14 | Jun 2022 | **Standalone preview**, typed forms |
| Angular 15 | Nov 2022 | **Standalone stable** |
| Angular 16 | May 2023 | **Signals introduced**, hydration |
| Angular 17 | Nov 2023 | **`@if`, `@for`, `@defer`, modern builder** |
| Angular 18 | May 2024 | Control flow stable, experimental zoneless |
| Angular 19 | Nov 2024 | Signal APIs mature, hydration/SSR advances |
| Angular 20 | May 2025 | Signals mature, incremental hydration stable |
| Angular 21 | Nov 2025 | Signal Forms/Aria direction, AI tooling |
| **Angular 22** | **Jun 2026** | **Current active major** |

Current release/support dates are maintained by Angular's official release documentation. :chatgpt-content-reference{index="28"}

---

# 25. Angular's Evolution in Five Major Eras

Instead of memorizing 20 versions independently, understand Angular in **five eras**.

## Era 1 — AngularJS

```text
AngularJS 1.x

JavaScript
Controllers
$scope
Directives
Two-way binding

Era 2 — Component-Based Angular

Angular 2–8

TypeScript
Components
NgModules
RxJS
Angular CLI
Dependency Injection
Router

This established modern Angular's basic architecture.

Era 3 — Ivy Angular

Angular 9–13

Ivy
Compiler improvements
Better builds
View Engine removed
Modern browser focus

This modernized Angular internally.

Era 4 — Standalone + Signals

Angular 14–16

Standalone Components
Typed Forms
Signals
Hydration
Reduced NgModule dependence

This began simplifying the developer model.

Era 5 — Modern Angular

Angular 17+
       |
       +-- Standalone-first
       |
       +-- Signals
       |
       +-- @if
       |
       +-- @for
       |
       +-- @switch
       |
       +-- @defer
       |
       +-- SSR / Hydration
       |
       +-- Zoneless direction
       |
       +-- Modern build tooling

This is the Angular style you should prioritize for new development.

26. Most Important Architectural Changes

If you remember only the biggest historical transitions, remember these:

AngularJS
Controllers + $scope
        |
        v
Angular 2
Components + TypeScript
        |
        v
Angular 9
Ivy becomes default
        |
        v
Angular 13
View Engine removed
        |
        v
Angular 14
Standalone introduced
        |
        v
Angular 15
Standalone stable
        |
        v
Angular 16
Signals introduced
        |
        v
Angular 17
@if / @for / @defer
Modern builder
        |
        v
Angular 18+
Zoneless + modern reactivity evolve
        |
        v
Angular 20+
Signals / hydration / zoneless mature
        |
        v
Angular 22
Current generation

27. How Angular Component Architecture Changed

This is particularly important for your Angular study.

Older Angular

A component was normally connected to an NgModule:

@Component({
  selector: 'app-home',
  templateUrl: './home.component.html'
})
export class HomeComponent {
}

Then:

@NgModule({
  declarations: [
    HomeComponent
  ],
  imports: [
    CommonModule
  ]
})
export class HomeModule {
}

Architecture:

Component
    ↓
NgModule
    ↓
Dependencies

28. Modern Angular

Modern standalone components can declare template dependencies directly:

@Component({
  selector: 'app-home',
  imports: [RouterLink],
  templateUrl: './home.html'
})
export class Home {
}

Conceptually:

Component
    |
    +---- Template
    |
    +---- Styles
    |
    +---- Imports
    |
    +---- Dependencies

This is one of the biggest changes in Angular's developer experience.

29. How Angular Bootstrapping Changed

Older Angular

platformBrowserDynamic()
  .bootstrapModule(AppModule);

Then:

main.ts
   ↓
AppModule
   ↓
AppComponent

Modern Standalone Angular

bootstrapApplication(App, appConfig);

Flow:

main.ts
   ↓
App

Angular provides official migration tooling specifically for moving existing applications from NgModule bootstrapping to standalone bootstrapping. Angular

30. How Template Syntax Changed

Traditional Angular

<div *ngIf="isLoggedIn">
  Welcome
</div>

<div *ngFor="let article of articles">
  {{ article.title }}
</div>

Modern Angular

@if (isLoggedIn) {

  <div>Welcome</div>

}

@for (article of articles; track article.id) {

  <div>{{ article.title }}</div>

}

Angular provides migrations from the older structural-directive syntax to built-in control flow. Angular

Important:

*ngIf and *ngFor are not concepts you should ignore—they remain important when maintaining existing Angular applications.

31. How Angular Reactivity Changed

Historically, Angular heavily relied on change detection associated with Zone.js.

Conceptually:

Event
 ↓
Zone.js observes async activity
 ↓
Angular change detection
 ↓
Check relevant application views
 ↓
Update UI

Signals introduced a more explicit reactive primitive:

count = signal(0);

Conceptually:

Signal
  ↓
Known reactive consumers
  ↓
State changes
  ↓
Angular can update efficiently

This eventually supports Angular's broader movement toward zoneless applications. Angular introduced experimental zoneless support in v18 and subsequently matured it. Angular

32. Angular Version Numbering

Angular follows semantic versioning:

Major.Minor.Patch

Example:

20.2.3

20 → Major
 2 → Minor
 3 → Patch

Angular defines them approximately as:

For example:

20.0.0 → 21.0.0
Major update

20.1.0 → 20.2.0
Minor update

20.2.1 → 20.2.2
Patch update

33. Angular Release Cycle Changed in 2026

This is a current interview point.

Until Angular 22, the project generally targeted:

Major release
     ↓
Every ~6 months

From Angular 22 onward, the current official policy targets:

Major release
     ↓
Every ~12 months

4–6 minor releases
     ↓
Within each major
``` :chatgpt-content-reference{index="33"}


The current published schedule includes:

```text
Angular 22.0 → June 2026
Angular 22.1 → July 2026
Angular 22.2 → around September 2026
Angular 22.3 → around November 2026
...
Angular 23.0 → around June 2027

These future dates are guidance and may change. Angular

34. Angular Support Policy

Current Angular major versions are typically supported for 24 months under the new cadence:

First 12 months
      ↓
Active Support

Next 12 months
      ↓
Long-Term Support (LTS)

During active support:

Regular updates
Bug fixes
Patches

During LTS:

Critical fixes
Security fixes

The current official status is:

35. How to Check Your Angular Version

Inside an Angular project:

ng version

This displays information such as Angular CLI, Angular packages, Node.js and related environment details. Angular officially recommends ng version for checking a project's Angular version. Angular

You can also inspect:

package.json

For example:

"dependencies": {
  "@angular/core": "^20.0.0",
  "@angular/common": "^20.0.0",
  "@angular/router": "^20.0.0"
}

36. How Angular Applications Are Upgraded

Angular provides:

ng update

For example, Angular's official guidance recommends using the CLI update tooling and its Update Guide for migrations. Angular

When crossing multiple old major versions, upgrades should generally be performed one major version at a time along supported migration paths:

Angular 18
   ↓
Angular 19
   ↓
Angular 20

rather than assuming:

Angular 18
   ↓
Angular 20

can safely skip all intermediate migrations. Angular's official update policy specifically describes sequential major-version updates for multi-major migrations. Angular

37. Why Angular Keeps Changing

Angular's evolution has consistently targeted several problems:

Less Boilerplate
      ↓
Standalone Components

Better Reactivity
      ↓
Signals

Better Template Syntax
      ↓
@if / @for / @switch

Better Lazy Loading
      ↓
@defer

Better Performance
      ↓
Ivy + modern build system

Better SSR
      ↓
Hydration / Incremental Hydration

Simpler Change Detection
      ↓
Zoneless Angular

Better Developer Experience
      ↓
CLI + migrations + tooling

Angular's current roadmap emphasizes developer experience, performance, and AI developer experience. Angular

38. Most Important Versions for Interviews

You do not need to memorize every minor feature of every Angular release.

Focus especially on these:

39. Interview Questions and Answers

Q1. What is the difference between AngularJS and Angular?

Answer:

AngularJS refers to Angular 1.x and is the original JavaScript-based framework. Angular 2+ is a major rewrite built around TypeScript, components, modern dependency injection, RxJS and a substantially different architecture.

Q2. Why was Angular 2 a major change?

Angular 2 replaced the AngularJS controller/$scope architecture with a component-based, TypeScript-oriented architecture.

AngularJS

Controller → $scope → View


Angular 2+

Component → Template → UI

Q3. Why was Angular 3 skipped?

Angular 3 was skipped mainly to align package version numbers, particularly because Angular Router had already reached version 3.x.

The next framework release was Angular 4.

Q4. Which Angular version introduced Ivy?

Ivy became available as an opt-in preview in Angular 8.

It became the default compiler/rendering infrastructure in Angular 9.

Q5. Which Angular version removed View Engine?

Angular 13 completed the transition away from the legacy View Engine.

Q6. Which Angular version introduced standalone components?

Angular 14 introduced standalone components as a preview direction.

Q7. When did standalone components become stable?

Angular 15.

Q8. Which Angular version introduced Signals?

Angular 16 introduced Angular Signals.

Example:

count = signal(0);

Q9. Which version introduced @if and @for?

Angular 17 introduced the new built-in control-flow syntax in developer preview.

@if (isLoggedIn) {
  <p>Welcome</p>
}

@for (article of articles; track article.id) {
  <p>{{ article.title }}</p>
}

It became stable in Angular 18. Angular

Q10. Which version introduced @defer?

Angular 17 introduced deferrable views:

@defer {
  <heavy-component />
}

The feature became stable in Angular 18. Angular

Q11. Which version introduced zoneless Angular?

Experimental zoneless support arrived in Angular 18 and matured over subsequent releases. Angular

Q12. What is the current Angular version?

As of September 2026, the current active major version is Angular 22, released June 3, 2026. Angular 21 and 20 are in LTS. Angular

Q13. What is the difference between old Angular and modern Angular?

A simplified comparison:

Traditional Angular
-------------------

NgModules
AppModule
*ngIf
*ngFor
Constructor DI common
Zone.js-based change detection
RxJS-centric reactive state


Modern Angular
--------------

Standalone Components
bootstrapApplication()
@if
@for
@defer
inject() available
Signals
Zoneless-capable architecture
Modern SSR / Hydration
Modern build tooling

This does not mean older APIs all immediately stop working. Angular deliberately provides incremental migration paths; for example, existing applications can migrate to standalone architecture progressively. Angular

40. Final Interview Summary

Angular began with AngularJS 1.x, a JavaScript framework based heavily on controllers, $scope, directives and two-way binding. Angular 2, released in 2016, was a complete redesign based on TypeScript and components. Angular 3 was skipped for package-version alignment, so Angular 4 followed Angular 2. Angular then evolved through major architectural milestones: Ivy became default in Angular 9, the old View Engine was removed by Angular 13, standalone components arrived in Angular 14 and became stable in Angular 15, Signals arrived in Angular 16, and Angular 17 introduced modern control flow such as @if and @for plus @defer. Angular 18 stabilized control flow and introduced experimental zoneless support, while Angular 19 and 20 further matured Signals, SSR, hydration and zoneless Angular. As of September 2026, Angular 22 is the current active major release. Angular

For your interview preparation, the most useful mental timeline is:

AngularJS
   ↓
Angular 2
Components + TypeScript
   ↓
Angular 9
Ivy
   ↓
Angular 13
View Engine removed
   ↓
Angular 14–15
Standalone
   ↓
Angular 16
Signals
   ↓
Angular 17
@if + @for + @defer
   ↓
Angular 18
Stable control flow + Zoneless experiment
   ↓
Angular 19–20
Signals + SSR + Hydration mature
   ↓
Angular 21–22
Current modern Angular generation