Angular 16: What’s new in The Latest version

Angular 16 marks a significant evolution in front-end development, introducing powerful enhancements that streamline the developer experience.

This open-source framework, widely used for building modern web applications, now offers better performance, improved reactivity, and simplified code structure. When working on an angular application, developers can take advantage of these improvements more efficiently.

One of the standout updates is the new signals-based reactivity system, which improves how an angular application tracks and updates UI changes, making the process more predictable and efficient.

Angular 16 also enhances server-side rendering and debugging tools, helping developers build faster, more scalable apps.

Whether you’re updating existing projects or starting fresh, running your project locally using http localhost 4200 remains a simple way to test features when you run the following command via your CLI.

Whether you’re updating existing projects or starting fresh, Angular v16 provides the flexibility and tools to create high-quality web applications with ease and confidence. You can always start the server using a cli command that points your browser to http localhost 4200, ensuring your workflow stays smooth.

Key Takeaways

• Angular v16 includes several performance improvements, such as faster compilation times, faster startup times, and improved change detection.
  
• Angular v16 includes improvements to the Angular CLI, such as faster builds, improved error messages, and better support for web workers. These updates help streamline every cli command you execute.
  
• Angular v16 includes updated and improved documentation, making it easier for developers to get started with Angular and find the information they need.
  
• Angular v16 includes improved compatibility with TypeScript 4.4 and higher, as well as other dependencies such as Node.js.
  
• Angular v16 also includes some new features, such as support for custom element tags and improved support for internationalization (i18n). You can test many of these features locally by using run the following command and opening http localhost 4200 afterward.
  

What is Angular?

Angular is a widely used open-source framework developed by Google for building dynamic web applications, especially single-page applications (SPAs).

Working with an angular application allows developers to build scalable solutions for both small and enterprise-level projects.

It follows the Model-View-Controller (MVC) architecture, helping developers organize code for better scalability and maintainability.

Angular enhances standard HTML by adding custom syntax and directives, making it easier to build interactive and user-friendly interfaces.

Its powerful features—like two-way data binding, dependency injection, and built-in routing—streamline the development process.

With Angular, developers can manage complex applications more efficiently, ensuring faster performance and smoother navigation. Local previews using http localhost 4200 are common when you run the following command in your CLI.

New Upgrades of Angular 16

It’s time to highlight the essential features of Angular 16.

1. Brand New Reactivity Model For Angular

We are excited to announce that with the Angular version 16 release, a developer preview of an innovative reactivity model for Angular is a hot topic.

This model brings significant improvements to performance and the overall experience for Angular developers.

The new model is fully backward compatible and interoperable with the current system. It offers the following benefits:

• By minimizing the number of computations during change detection, you’ll find significantly enhanced runtime performance.
  
  As we progress with the implementation of Angular Signals, the developers working with Angular development company will experience a notable enhancement in the INP Core Web Vital metric for applications developed with signals.
  
  
• Angular 16 comes up with a simpler mental model for reactivity, clarifying the dependencies of the view and the flow of data throughout the Angular web application development. This helps improve any angular application structure seamlessly.
  
  
• Fine-grained reactivity (fine-grained code loading) is the new feature of Angular 16 that enables precise reactivity, enabling upcoming releases to detect changes exclusively in the relevant standalone components.
  
  
• Makes Zone.js optional in upcoming releases by utilizing signals to notify the framework when the model has changed.
  
  
• Provides computed properties without the need for recomputation in every change detection cycle.
  
  
• To improve interoperability with RxJS, we have devised a plan to introduce reactive inputs, thereby enhancing the compatibility between Angular and RxJS.
  

In v16, you’ll find a new signals library as part of @angular/core, along with an RxJS interop package called @angular/core/rxjs-interop.. The complete integration of signals into the framework is planned for later this year.

2. Introducing Angular Signals

Angular Signals, introduced in Angular v16, offer a new and efficient way to manage state changes in standalone applications.

Inspired by Solid.js, signals act as reactive functions—you can update a signal using set() and read its current value with get(). This allows for a clean, functional approach to state management.

What makes Angular Signals powerful is their ability to form dependency graphs. Signals can depend on each other, and when one changes, the others automatically update. This creates a dynamic and responsive data flow with minimal manual tracking.

Developers can also easily convert signals into observables using the @angular/core/rxjs-interop package, providing smooth integration with existing RxJS workflows.

This means you can use signals alongside observables for more flexible and scalable application logic.

As Angular continues to evolve, Signals represent a step forward in simplifying reactivity and improving performance, especially in complex UI development scenarios.

Here’s a simple example how to use it with Angular 16:

@Component({
  selector: 'my-app',
  standalone: true,
  template: `
    {{ fullName() }} Click
  `,
})
export class App {
  firstName = signal('Mr Angular’);
  lastName = signal('Dev');
  fullName = computed(() => `${this.firstName()} ${this.lastName()}`);

  constructor() {
    effect(() => console.log('Name changed:', this.fullName()));
  }

  setName(newName: string) {
    this.firstName.set(newName);
  }
}

The code segment presented generates a computed value called “fullName” that relies on the signals “firstName” and “lastName”. Additionally, we define an effect that triggers a callback each time any of the signals it utilizes are altered.

In this scenario, the “fullName” signal is indirectly dependent on “firstName” and “lastName”.

If we modify the value of “firstName” to “David”, the console in the browser will display a log.
“Name changed: Mr Angular David”

3. Improved Server-Side Rendering with Enhanced Speed

The Angular team has identified server-side rendering as the primary area for enhancing Angular.

With the introduction of the new app non-destructive hydration technique called “whole app non-destructive or partial hydration,” the application no longer requires a complete re-rendering by Angular.

Rather than starting from scratch, the Angular framework leverages existing DOM nodes for building internal data structures and binds event listeners to those nodes.

Angular developers can take advantage of various benefits, including:

• Elimination of content flickering on web pages, resulting in a smoother user experience.
  
• Enhanced Web Core Vitals, improving metrics related to page load speed and user interaction.
  
• Future-proof architecture that employs primitives, enabling precise code loading. This capability is currently evident in progressive lazy route hydration.
  
• Simple integration with existing apps requiring only a few lines of code.
  
• Gradual adoption of hydration for components that perform manual DOM manipulation through the use of the ngSkipHydration property in templates.
  
• Angular has observed up to a 45% improvement in Largest Contentful Paint (LCP) with full standalone app hydration.
  

Several applications have already implemented hydration in their production environments and have reported improvements in Core Web Vitals (CWV).

To begin, a few additional lines need to be added to your main.ts file in order to get started.

To begin, a few additional lines need to be added to your main.ts file in order to get started. Once set up, you can test hydration updates by serving your project using a cli command and previewing it via http localhost 4200.

import {
bootstrapApplication,
provideClientHydration,
} from '@angular/platform-browser';
...
bootstrapApplication(RootCmp, {
providers: [provideClientHydration()]
});

Another notable enhancement in Angular 16 is the inclusion of non-destructive hydration support, which enhances the speed and smoothness of server-side rendering (SSR).

This technique allows you to add server-side rendering of your application on the server and transmitting the HTML content to the browser.

Subsequently, JavaScript behavior and event listeners are attached to transform the page into a fully interactive and functional web page.

Angular 16 introduces a built-in feature called Server Side Rendering (SSR), which significantly enhances the performance and quality of SSR applications.

This feature provides several advantages, such as improved SEO, accessibility, and reduced time-to-interactive (TTI). While SSR has been a long-standing feature in frameworks like React or Next.js, implementing it in Angular posed its own set of challenges.

During the hydration process, the browser employs a non-destructive technique that ensures existing HTML content and attributes remain untouched and unaffected.

This means that any modifications or optimizations made to the HTML content on the server side are preserved.

Moreover, non-destructive hydration serves as a safeguard against potential conflicts or errors arising from inconsistencies between the HTML content on the client and server sides.

4. In Angular 16, the elimination of ngcc is observed

Angular 16 has officially removed the Angular Compatibility Compiler (ngcc), a tool initially introduced in Angular 9 to bridge the gap between the older View Engine and the newer Ivy rendering engine.

This change streamlines the framework by eliminating legacy code and reducing the overall bundle size, leading to improved performance.

With this update, libraries built on the View Engine are no longer compatible with Angular 16 and beyond. While this may appear as a breaking change, it’s worth noting that such libraries were never officially supported in Ivy-based versions.

Another notable improvement in Angular 16 is the long-awaited support for required inputs. Previously, developers used workarounds like component selectors to enforce this behavior.

Now, inputs can be explicitly marked as required, making Angular forms and components more robust and developer-friendly.

These enhancements reflect Angular’s commitment to modernization, efficiency, and developer experience.

@Component({
 selector: 'app-test-component[title]', // note attribute selector here
 template: '{{ title }}',
})
export class TestComponent {
 @Input()
 title!: string;
}

Regrettably, this approach falls short of being optimal. Firstly, it leads to cluttering of the component selector. Each required input name must be included in the selector, which poses difficulties, particularly during refactoring processes.

Furthermore, it disrupts the functionality of auto-import mechanisms in Integrated Development Environments (IDEs).

Secondly, if we overlook providing a value for an input labeled in this manner, the resulting error message lacks precision, as there is no exact match for such an “incomplete” selector.

The newly introduced feature addresses this issue by enabling us to explicitly indicate that an input is required, either through the @Input decorator.

@Input({required: true})
title!: string;

or the @Component decorator inputs array:

@Component({
 ...
 inputs: [
   {name: 'title', required: true}
 ]
})

Nevertheless, the new solution possesses two significant limitations. Firstly, it solely functions in Ahead-of-Time (AOT) compilation and does not apply to Just-in-Time (JIT) compilation.

Secondly, it remains affected by the strictPropertyInitialization TypeScript compilation flag, which is typically enabled by default in Angular (as it is recommended and beneficial).

TypeScript will generate an error for this property since it is declared as non-nullable but lacks initialization in the constructor or inline declaration.

Hence, it is necessary to disable this check in order to proceed. One way to achieve this is by explicitly indicating the non-nullability of the property using the non-null assertion operator, even though it must be provided in the consumer template.

5. Esbuild Dev Server

Ng build and ng serve in Angular version 16 now have experimental support for esbuild.

For development server purposes, Angular now utilizes Vite in ng serve. Additionally, both development and production builds are powered by esbuild.

Many developers preview esbuild improvements by starting their angular application through run the following command and visiting http localhost 4200.

...
"architect": {
"build": { /* Add the esbuild suffix/*
"builder": "@angular-devkit/build-angular:browser-esbuild",
...

To enable the use of “@angular-devkit/build-angular:browser-esbuild” instead of “@angular-devkit/build-angular:browser”, you should make this change here.

6. Binding router Information to Component Inputs

With this capability, the routing data mentioned below will be easily accessible in the dynamic component as input.

As a result, we can utilize inputs to retrieve these values instead of relying on ActivatedRoute. This approach can significantly benefit our application by eliminating a significant amount of redundant code.

• Router data
• Resolved router data
• params
• query Params

// The current approach, which remains functional.

@Component({
...
})
class SomeComponent {
route = inject(ActivatedRoute);
data = this.route.snapshot.data['dataKey'];
params = this.route.snapshot.params['paramKey']
}
//New approach
@Component({
...
})
class SomeComponent {
@Input() dataKey: string;
@Input() paramKey: string;
//or
@Input() set dataKey(value: string){
//react to the value
};
@Input() set paramKey(value: string){
//react to the value
};
}

7. takeUntilDestroyed and DestroyRef

Gradually, Angular is facilitating a more functional coding style. One step in this direction is the inclusion of the DestoryRef and takeUntilDestroyed RxJS operators. These operators serve as replacements for the ngOnDestroy component’s lifecycle hook.

Previously, if we desired to use ngOnDestroy within functions, it was not possible since it relied on classes.

@Component({})
class SomeComponent {
destroyRef = inject(DestroyRef);
store = inject(Store);
user
constructor() {
const sub = this.store.select(getUser()).subscribe((user) => {
this.user = user
});
destoryRef.onDestroy(() => {
sub.unsubscribe()
})
//OR
const sub = this.store.select(getUser()).pipe(takeUntilDestroyed())
.subscribe((user) => {
this.user = user
});
}
}

The usage of the takeUntilDestroyed operator is restricted to the constructor context exclusively. If we intend to utilize it outside of the constructor, we need to provide destroyRef as an argument.

In contrast to subscriptions in RxJS, this functionality is internally utilized to handle the cleanup of signal impacts. Consequently, no manual cleanup is required.

Additional features of Angular 16

• The introduction of standalone schematics in the developer preview allows for the creation of new Angular projects as standalone entities, providing a streamlined process.
  
• The Jest testing framework is being experimentally supported, indicating ongoing development and exploration of its capabilities.
  
• Developers working with Angular have the ability to specify a nonce attribute for component inline styles, which Angular then includes inlined.
  
• In Angular templates, self-closing tags can be utilized to create closing tags for all the affected components, resulting in a more concise syntax.
  
• Angular 16 brings an enhancement to the application performance and developer experience by introducing the option to link or bind route parameters with corresponding component’s inputs for the router.
  
• The notable inclusion of TypeScript 5.0 support is particularly relevant for ECMAScript decorators that extend JavaScript classes, providing expanded functionality and compatibility.
  
• Several schematics have been revised to facilitate independent applications, such as ng-new and the application schematic, the Angular Universal schematic, and the app-shell schematic.
  
• Angular Universal allows Angular to render an app on the server, generating static HTML contents, which represents an app state.
  
• In Angular 15, Angular Material transitioned to being built on MDC (Material Design Components). In version 16, the Angular team focused on incorporating design tokens from Material Design.
  
  This enables smoother migration to Angular Material 3 in the future and empowers designers and developers to extensively customize the user interface of their applications.

Easy Way to Install or Upgrade Angular 16

Angular offers multiple Angular development tools. Therefore, you just need to install Angular 16 via npm.

Execute the following cli command in the CLI:

npm install –global @angular/cli@next

Using this command, you can easily install Angular CLI’s latest version on your system. After installation, you can start your angular application using run the following command to open it in the browser at http localhost 4200.

Conclusion

Angular 16 builds on the foundation of Angular 15 and introduces powerful upgrades that significantly enhance application performance and developer productivity.

With a strong focus on reactivity and server-side rendering improvements, Angular 16 brings a more efficient approach to building fast and responsive web applications.

These updates are especially beneficial for AngularJS development companies aiming to create scalable and inclusive digital experiences.

Developers can now expect smoother workflows, faster builds, and improved rendering capabilities—helping deliver high-performance apps that meet modern user expectations and industry standards.