Angular's Ivy: A Look Under the Hood

Anton Ioffe - November 25th 2023 - 9 minutes read

Welcome to the intricate world of Angular's Ivy, a monumental shift in the landscape of modern web development. Journey with us as we unravel the mysteries of this advanced rendering engine, diving deep beneath the surface to expose the cogent intricacies of its core architecture. Within these sections, we'll decode the sophisticated patterns through which Ivy revolutionizes the template-to-instruction translation, enhances change detection mechanisms, and optimizes runtime performances with cutting-edge techniques such as lazy loading and code-splitting. We’ll go further, laying bare the essentials for troubleshooting and fine-tuning your Ivy applications, empowering you to master the craft of developing sleek, efficient, and robust Angular applications. Prepare to immerse yourself in an expedition designed to elevate your technical acumen and satisfy your intellectual curiosity.

Diving into Ivy: Core Architecture and Key Concepts

Angular's Ivy compiler represents a monumental shift in the way the framework handles application building and rendering. Fundamentally, Ivy adopts an incremental DOM (iDOM) strategy, contrasting with the full DOM abstraction in previous versions. This means that rather than creating a full representation of the application's UI in memory, Ivy updates the DOM incrementally, only touching parts of it as necessary for reflecting changes to the data model. This approach significantly contributes to performance enhancements, especially for large-scale applications.

At the core of the Ivy architecture is the concept of Locality. This principle asserts that the compilation of components occurs in isolation, without the need for information about the rest of the system. Each Angular component compiles with its own set of information that is self-contained within a set of static fields—ngComponentDef being a primary example. These static fields contain metadata that instructs Ivy on how to create instances of components, run change detection, and handle dependencies. This self-sufficiency expedites the compilation process and contributes to a more modular framework design.

One of the most impressive features enabled by Ivy is Tree Shaking. Due to its modular compilation, Ivy can identify and exclude unused code from the final bundle. Tree Shaking is not restricted to application-specific code but extends to Angular's internal features as well. Code that doesn't contribute to the application's functionality is left out of production builds, resulting in smaller, lighter, and faster-loading applications.

Another fundamental concept introduced with Ivy is Incremental Compilation. Instead of recompiling the entire application when a single component changes, Ivy updates only what is necessary. Compiling files independently allows developers to reap the benefits of reduced rebuild times, facilitating a smoother and more efficient development process. This modular compilation strategy is a massive boon for developer productivity, especially in large applications where compilation times can be notably onerous.

Key to understanding Ivy is recognizing how static fields such as ngComponentDef, ngDirectiveDef, and ngModuleDef redefine the development experience. These fields, automatically generated during the compilation process, carry the instructions that the Ivy engine uses to render components, interpret directives, and construct module definitions. Overall, Ivy's design not only results in performance gains but also lays down an architecture that is conceptually easier to reason with, unlocking the potential for future optimisations in Angular development.

The Compilation Journey: Translating Templates into Instructions

When Ivy processes an Angular component's template, it effectively translates the high-level declarative HTML into a set of low-level, imperative JavaScript instructions. Consider a simple Angular component template that includes the use of directives such as *ngIf and *ngFor. Traditional compilers would generate complex codes that included checks and balances for such structural directives; however, Ivy streamlines this process significantly, resulting in simpler, more modular code. By turning the template into executable instructions, Ivy enables the Angular engine to create and manipulate DOM elements dynamically, which is crucial for reactive data binding and user interface updates.

Developers can peek at the JavaScript output to trace the rendering process, simplifying debugging and enhancing readability. A component showcasing a list of items based on an *ngFor directive becomes a series of labeled instruction blocks mirroring the declarative form. This more transparent and direct correlation allows developers to readily identify the flow of logic and makes tracking down issues within the rendering process a more intuitive endeavor.

The simplicity of the imperative code generated by Ivy aligns well with modern JavaScript engine optimizations. This improved synergy translates to a noticeable performance uplift, particularly in the responsiveness of dynamic content and user interactions. The generated output adheres to effective JavaScript patterns that interact more efficiently with the browser's underlying execution processes, leading to faster render times and a smoother user experience.

Additionally, Ivy's compiled output fosters modularity and encourages reusability in a way that previously-compiled output didn't naturally facilitate. Autonomous sets of instructions articulate the underlying templates, allowing components to be interchangeably used and repurposed throughout an application without carrying unnecessary weight. This granular approach supports Angular's core design philosophy of modular, component-driven architecture and preserves application scalability with maintainable code.

Lastly, the clarity within Ivy's generated code output makes antipatterns and inefficiencies more conspicuous. Poorly structured bindings or suboptimal template use reveal themselves against the streamlined backdrop, prompting developers to refine their code. The resulting artifact is a testament to thoughtful engineering practices that dovetail with both Angular-centric development and broader JavaScript code quality standards.

Change Detection Mechanisms in Ivy's World

In the refined landscape of change detection, Ivy marks a significant change from Angular's former View Engine, adopting an efficient algorithm that discerns slight variations in application state to optimally update component views. This streamlined process limits scanning to only the necessary bindings within components, greatly enhancing performance during each change detection cycle.

Ivy employs the ɵmarkDirty function to flag a component for checking in the next cycle of change detection. While effective for managing updates, developers must exercise caution as ɵmarkDirty is part of Angular's private API and could change in future versions. The following example demonstrates its use upon a user-initiated state update, providing more control over the change detection process:

import { ɵmarkDirty } from '@angular/core';

// Example component
export class MyComponent {
  // Logic to update the state
  updateComponentState() {
    // State update steps
    ɵmarkDirty(this); // Schedule a check for this component

Regarding Ivy's handling of change detection strategies, there's a noticeable change in application when using OnPush compared to the default CheckAlways strategy. OnPush requires an explicit indication of changes, like updated inputs or events within observables, to conduct a check. Misunderstandings often occur when developers adopt OnPush without implementing immutable data structures or explicit triggers for change detection. Consider the contrasting approaches below:

// OnPush strategy component
export class MyComponent {
  @Input() data: DataModel;
  // Incorrect example, mutation does not trigger change in OnPush
  incorrectUpdate() { = 'New Title';

  // Correct example, using immutable data flow
  correctUpdate(newTitle: string) { = {, title: newTitle};
    // Note: `detectChanges()` is usually unnecessary with input binding changes

Employing immutable data practices ensures that OnPush precisely detects and reacts to changes without excess processing.

Ivy also innovates with how it manages sub-templates in structures like *ngIf or *ngFor. These are independently processed, enhancing the predictability and modularity of component behaviors. Here's an example of dealing with an *ngIf sub-template:

// A template with *ngIf
  template: `
    <div *ngIf="condition">
      Content here is conditionally rendered and independently checked
export class MyExampleComponent {
  // Component logic

Ivy's advanced change detection capabilities call for developers to mindfully apply best practices and avoid common mistakes, like altering data directly in OnPush components, which negates optimization efforts. By actively engaging with Ivy's refined detection strategies, developers can create applications that are both efficient and maintain a clean and reliable data strategy.

Ivy's Runtime Dynamics: Lazy Loading and Code Splitting

Ivy leverages tree shaking and lazy loading as pivotal strategies for improving runtime performance, particularly when it comes to reducing the initial payload of an application. In the realm of tree shaking, Ivy excels by excluding any Angular features that are not utilized within the app. For example, directives or services that are never instantiated won't form part of the final bundle. This can be seen in action with features such as Angular Elements, where unnecessary module code is stripped away, leaving a more streamlined bundle.

Implementing lazy loading with Ivy requires careful attention to detail to ensure that components and modules are only loaded when needed. This is typically achieved using Angular's RouterModule and configuring routes with loadChildren, pointing to an import statement that dynamically imports the necessary module. For instance:

const routes: Routes = [
        path: 'feature',
        loadChildren: () => import('./feature/feature.module').then(m => m.FeatureModule)

This dynamic import indicates to the Ivy compiler that the FeatureModule should not be included in the initial bundle but rather loaded on-demand. It's essential to avoid importing lazy-loaded modules anywhere else in the application, as this would negate the benefits and could lead to a larger-than-necessary main bundle.

One common pitfall encountered when aiming for optimal lazy loading is the inclusion of unnecessary imports in eagerly loaded modules. Developers must be diligent in scrutinizing imports and ensuring that only those that are needed for the initial render are bundled in the main chunk. For example, importing a service that is only used within a lazy-loaded module into an eagerly loaded module will inadvertently pull in additional code, inflating the initial bundle size.

Efficient code splitting is also heavily reliant on the proper use of dynamic imports. By strategically coding split points where the application's execution path can diverge, such as loading an admin panel only for authorized users, we ensure that users download only the code segments necessary for the current user journey. The dynamic import syntax used for lazy-loaded modules serves this purpose perfectly, enabling finer-grained bundle splitting.

Developers should constantly monitor their application's bundle size and structure, applying timely refactoring where needed to maintain optimal lazy loading and code splitting. Regularly performing bundle analysis can highlight areas that escape optimal tree shaking, thus making it easier to target and resolve such inefficiencies. The disciplined approach to import paths, use of dynamic imports, and a sound understanding of Angular's routing mechanisms are critical in harnessing the full potential of Ivy's runtime performance enhancements.

Troubleshooting and Optimizing Ivy Applications

Troubleshooting and optimizing applications powered by Angular's Ivy involves a keen understanding of the distinct features it provides and an analytical approach to performance profiling. A common pitfall many face is the mismanagement of component lifecycle hooks, which are often the culprits behind memory leaks. Careful cleanup within the ngOnDestroy hook, especially when it comes to observable subscriptions, is crucial. Given the following snippet, ask yourself: are you detaching all event listeners and unsubscribing from observables correctly?

export class MyComponent implements OnDestroy {
    private subscription: Subscription;

    constructor(private myService: MyService) {
        this.subscription = this.myService.dataObservable.subscribe(data => {
            // Process data

    ngOnDestroy() {

Performance can also be squandered by inefficient change detection workflows. With Ivy, employing OnPush change detection and utilizing trackBy functions in *ngFor directives can yield significant improvements. However, ensure that mutable data operations don't bypass OnPush's checks, leading to undetected changes in the UI. Have you audited your usage of change detection to minimize performance hits?

Debugging in Ivy can initially be daunting, yet simpler generated code and the ability to attach custom debug information to component instances streamline the process. Consider using NgProbe for debugging within the development console, allowing you to inspect the application state, and assess component trees and their corresponding change detection cycles. Reflect on this: how often do you leverage the development tools at your disposal for in-depth analysis during debugging sessions?

Optimization extends to thoughtful structuring and utilization of components and services. Do your components adhere to the Single Responsibility Principle, thereby supporting tree-shaking and reducing bundle sizes? Are they optimized for lazy-loading, ensuring that only the necessary code is loaded and not a byte more?

Finally, the impact of build configuration errors can be more profound than anticipated. A misplaced dependency or misconfigured loader might introduce performance regressions. Regular bundle analysis can prevent such oversights. Consider creating a checklist: does your build configuration align with performance benchmarks that you've set for your Ivy application? How can you streamline your configuration to avoid common pitfalls and promote application efficiency?


In this article, we explore Angular's Ivy compiler and its impact on modern web development. Ivy's core architecture and key concepts, including incremental DOM, locality, tree shaking, and incremental compilation, are discussed in detail. We delve into how Ivy translates templates into imperative JavaScript instructions, enhancing performance and readability. Change detection mechanisms in Ivy are also explained, highlighting the efficiency of the algorithm and the importance of using OnPush and immutable data structures. Additionally, we explore Ivy's runtime dynamics, such as lazy loading and code splitting, and provide insights into troubleshooting and optimizing Ivy applications. As a challenging task, readers are encouraged to analyze their application's bundle size and structure, apply proper lazy loading and code splitting techniques, and optimize their build configurations to ensure optimal performance and efficiency.

Don't Get Left Behind:
The Top 5 Career-Ending Mistakes Software Developers Make
FREE Cheat Sheet for Software Developers