Skip to content
Tutorials Center
My learning

Topics

Lesson 1 of 74 ยท Getting Started

What Is Angular?

Learn what Angular is, how a batteries-included framework differs from a library like React, how releases work, and how this tutorial mixes real code with runnable demos.

Angular is a framework for building web applications, written in TypeScript and maintained by Google together with a large open-source community. You describe your user interface as a tree of components, each one a TypeScript class with an HTML template, and Angular keeps the page in step with your data. It also ships the tools that most real applications need: a router, a forms system, an HTTP client, dependency injection, a testing setup and a command-line tool that creates and builds projects.

That last point is the main idea of this lesson. Angular is an opinionated, batteries-included framework. Instead of choosing a router, a form library and a project layout yourself, you get one official answer for each, and every Angular project looks familiar to every Angular developer. That is a big advantage on large teams and long-lived applications, and it is the reason Angular is common in enterprise software.

Framework or library?

You will often hear that React is "a library" and Angular is "a framework". The words are fuzzy, but the difference in practice is real. A library does one job and you call it. A framework sets up the structure of the whole application and calls your code at the right moments.

flowchart LR
  subgraph A["Angular: one official toolkit"]
    direction TB
    A1["Components and templates"]
    A2["Router"]
    A3["Forms"]
    A4["HttpClient"]
    A5["Dependency injection"]
    A6["CLI, build and test"]
  end
  subgraph R["React: a UI library plus your choices"]
    direction TB
    R1["Components and JSX"]
    R2["Router: you pick"]
    R3["Forms: you pick"]
    R4["Data fetching: you pick"]
    R5["Build tool: you pick"]
  end

Angular bundles the pieces most applications need; with React you assemble them from the ecosystem.

Neither approach is better in every case. React gives you freedom and a smaller starting point, at the price of more decisions (see the React tutorial for that side). Angular gives you consistency and fewer decisions, at the price of more concepts to learn up front: decorators, dependency injection, templates with their own syntax, and a build step you do not control directly.

What Angular is not

  • It is not AngularJS. AngularJS (version 1.x) was a different, older framework with the same family name. The next lesson explains the differences, because old tutorials still mix the two up.
  • It is not a CSS framework. Angular does not decide how your app looks. You can use plain CSS, Sass, Tailwind or the optional Angular Material component library.
  • It is not only for huge apps. The framework has a lot of capability, but a small Angular app is a handful of files. You use what you need.
  • It is not a backend. Angular runs in the browser (and optionally on a server for rendering). Your data still comes from an API.

What you should know first

Angular code is TypeScript, so you will be more comfortable if you have worked through the TypeScript tutorial, at least types, classes and generics. Underneath, TypeScript is JavaScript, so JavaScript basics apply everywhere. Knowing HTML and CSS is assumed. If you have used React, you will recognize ideas such as components, props (called inputs in Angular) and state, but the syntax differs. We compare the two in places and never assume you know React.

Versions and release cadence

Angular follows semantic versioning with a predictable schedule. A new major version arrives about every six months, and minor releases with new features land between them. Each major version gets a period of active support followed by a longer period of long-term support (LTS) in which only critical fixes ship. At the time of writing the published policy is six months of active support plus twelve months of LTS, but always check the official release page before planning an upgrade.

The practical consequence is that you should stay close to the latest version. Angular ships automated upgrade tools (ng update) and the team avoids breaking changes where it can, deprecating features across several releases first.

This tutorial targets Angular 20 and newer. That means the modern style: standalone components with no NgModule, signals for state, the @if / @for / @switch template blocks, the inject() function, and the esbuild-based build. When older code looks different you will see a note about it.

The calculator below models the support schedule from the policy above, using a made-up release date so the numbers are easy to check. It is plain TypeScript and does not involve Angular at all.

TypeScript Model the release and support schedule

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 version numbers (100 and up) and the dates are invented on purpose. Reading the table, a major version is supported for 18 months in total, so at any moment about three major versions are inside their support window. That overlap is what gives you time to upgrade without panic.

Real Angular versus the runnable demos

Angular cannot run inside this website: it needs its own compiler and the Angular CLI, which turn your templates into JavaScript before the browser sees them. So this tutorial uses two kinds of code, and every lesson tells you which is which.

  • Real Angular code appears in ordinary code blocks marked typescript or html. Read it, and copy it into a project created on your computer with the CLI (the setup lesson shows how). You cannot press Run on it here.
  • Runnable stand-ins are the "Try it" editors. They are small hand-written TypeScript or JavaScript programs that reproduce the idea of an Angular feature, such as a tiny signal, a dependency container or a router, so you can run, change and break them. They are not Angular and they are simplified, but the behavior they model is the same.

Here is a taste of both. First, the real thing, a complete Angular component (read-only):

TypeScript
import { Component } from '@angular/core';

@Component({
  selector: 'app-greeting',
  template: `<h1>Hello, {{ name }}!</h1>`,
})
export class Greeting {
  name = 'Angular';
}

And now a stand-in that models the same idea: a class that holds data and a template that turns it into HTML text.

TypeScript A stand-in for a component: data plus a template

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 real Angular template is not a JavaScript function like ours. Angular's compiler reads the HTML at build time and generates optimized code. The stand-in only shows the contract: a component is data plus a view of that data.

Whenever a lesson says "stand-in", treat it as a learning model, not as a copy of Angular's internals. The real behavior is described in the prose and the read-only code blocks.

Where this tutorial goes

You will start with setup and your first component, then learn templates and data binding, components in depth, signals, dependency injection, routing, forms, HTTP and RxJS, then testing, rendering on the server, performance and tooling. Seven projects and practice sets follow. Each lesson ends with a short quiz.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What best describes Angular compared with React?

    Angular ships most of what an application needs and prescribes a structure. React is a UI library, so you choose routing, forms and data fetching yourself.
  2. 2. In what language do you normally write Angular applications?

    Angular is written in TypeScript and its tooling assumes TypeScript, although it compiles to JavaScript for the browser.
  3. 3. Roughly how often does Angular release a new major version?

    Major versions arrive about every six months, each with a period of active support followed by long-term support. Check the official policy for exact dates.
  4. 4. Why are the Try it editors in this tutorial called stand-ins?

    Angular needs its compiler and CLI. The runnable examples re-create the idea with plain TypeScript or JavaScript, while the real Angular code is shown read-only.

Summary

  • Angular is a TypeScript framework from Google for building web applications out of components with HTML templates.
  • It is batteries-included: router, forms, HTTP client, dependency injection, testing and CLI are official parts, so projects share one structure.
  • It is not AngularJS, not a CSS framework, and not a backend.
  • A new major version arrives about every six months; plan to stay near the latest version and use ng update.
  • This tutorial targets Angular 20 and newer: standalone components, signals, built-in control flow and inject().
  • Real Angular code is read-only; the Try it editors run hand-written stand-ins that model the ideas.

Next: Modern Angular vs AngularJS