DEV Community: ng-news

Ng-News 26/16: OpenNG Foundation, spartan/ui

ng-news — Thu, 02 Jul 2026 21:47:45 +0000

OpenNG Foundation and spartan/ui 1.0 are the headline topics this week: a new home for libraries like Spectator and Elf, and spartan/ui, a stable shadcn-inspired component library for Angular.

Also in brief: Storybook's Angular modernization through AnalogJS, the end of ng-conf, and AI Dev Craft in Las Vegas.

OpenNG Foundation

Maintaining open-source libraries is hard work. Developers often do it in their spare time, committing to years of maintenance, adding new features, and responding to user requests.

Last episode, we reported that the ngneat organization was taken down for unknown reasons. While we still don't know why it happened, a new home has emerged for its popular libraries like Spectator and Elf: the OpenNG Foundation.

Gerome Grignon, known for CanIUseAngular and as the organizer of Ng-Baguette, announced the foundation, which is already hosting these libraries. Alongside Gerome, the current OpenNG team also includes Dominic Bachmann, organizer of Angular Lucerne and author of the angular-typed-router library.

OpenNG Foundation · GitHub

OpenNG Foundation has 8 repositories available. Follow their code on GitHub.

github.com

spartan/ui 1.0

spartan/ui has officially released its 1.0 version. It provides an "accessible, production-ready library of more than 55 components" with fully customizable styling.

After debuting in August 2023 with 30 primitives, it now reaches stable in 2026 with a modern architecture built around signals, standalone components, zoneless change detection, and SSR. Originally initiated by Robin Götz, a full team quickly formed around the project.

spartan/ui can be seen as the Angular equivalent to shadcn/ui, famous for its customizability. While similar open-source alternatives exist, spartan/ui was the pioneer and has a proven track record of active maintenance over the years.

Robin Goetz for Playful Programming Angular

Jun 24

Announcing spartan/ui 1.0

#angular #webdev

3 min read

AnalogJS in Storybook

Storybook’s Angular integration is getting a modernization, and it is all thanks to AnalogJS.

While modern versions of the Angular CLI use Vite under the hood as a development server, it remains a "black box." The Angular CLI is still the one managing the compilation. Because the CLI itself is not a Vite plugin, it cannot be easily plugged into other modern tools.

And that's the issue for Storybook, Vitest, but also others. They are designed to support any framework that presents itself as a Vite plugin.

AnalogJS, founded and maintained by Brandon Roberts, solves this by doing exactly that. It fully decouples Angular from the CLI's build pipeline and exposes it as a standard Vite plugin. Just activate it, and these modern tools can suddenly compile and serve Angular components out of the box without any Angular-specific configuration. It just works.

// Detect dark theme var iframe = document.getElementById('tweet-2067695792106705118-982'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2067695792106705118&theme=dark" }

ng-conf is ending

ng-conf is ending.

ng-conf was the first Angular conference, going back to 2014 with AngularJS, and it continued through to the modern Angular era all the way through 2025. This also means that there is no US-based Angular conference anymore.

In its place, a new conference called AI Dev Craft will debut in October in Las Vegas, with a call for speakers open.

// Detect dark theme var iframe = document.getElementById('tweet-2071616309742453054-891'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2071616309742453054&theme=dark" }

Ng-News 26/15: Angular 22

ng-news — Tue, 23 Jun 2026 19:13:29 +0000

Angular 22 stable resources and Signal Forms are the headline topics, together with new dependency injection APIs such as @Service and injectAsync. Also in brief: debounced(), Vitest migration support, ChangeDetectionStrategy.Eager, WebMCP, community write-ups, and the ng-neat recovery.

Stable resources and Signal Forms

Angular 22 is out. Probably the most outstanding feature is the stabilization of the resource and the Signal Forms. There's much more but let's start with these two.

Resources, that are three functions resource(), rxResource() and httpResource(), have been introduced during Angular 19. There were some significant changes in Angular 20, and then in Angular 21 we got the snapshot feature. Resources have been experimental all the time, and after almost 1.5 years, they leave experimental status and become stable.

Similar story for Signal Forms, but at a just faster pace. They were introduced in 21 and are now also stable, so no developer preview either.

So in some way, these are features we already knew and some of us were already using quite successfully.

And let's not forget, also @angular/aria, the headless design system also became stable.

blog.angular.dev

What's new in Angular 22.0? - Ninja Squad

Angular 22.0 is out!

blog.ninja-squad.com

`@Service`, `injectAsync`, and `debounced()`

But, there are new features as well.

For one, we have the @Service decorator. That means it is on one side a shortcut for @Injectable({ providedIn: 'root' }) and on the other prevents using dependency injection via the constructor. Instead of constructor-based DI, you should go with the inject function and there is a dedicated migration available (ng generate @angular/core:inject).

@Service()
export default class NewsletterClient {
  private httpClient = inject(HttpClient);

  send(email: string): Observable<boolean> {
    return this.httpClient.post<boolean>(
      'http://some.host.com/newsletter/subscribe',
      { email },
    );
  }
}

Another feature for dependency injection is the asynchronous injector. So the value returned by injectAsync is not the service instance itself - you call it when you need the service and await the result. Why do we need it? Well, same thing why we do lazy loading in the router. We only want to load when it is actually needed.

export class NewsletterPage {
  private readonly newsletterModel = signal({ email: '' });
  private readonly newsletterClient = injectAsync(
    () => import('./newsletter-client'),
  );

  protected readonly newsletterForm = form(
    this.newsletterModel,
    (path) => { },
    {
      submission: {
        action: async () => {
          const client = await this.newsletterClient();
          client.send(this.newsletterModel().email)
        },
      },
    },
  );
}

So you won't use injectAsync when you need the service immediately but more when a user clicks on something or some later events. The service needs to be providedIn: 'root'. So it's best if you already apply the new @Service decorator.

And we have a debounced function. You give it a signal and a debounce time, and you are getting back a resource. Debouncing means, when the signal's value changes, the value in the derived resource would wait for the defined period of time until a new value comes. If that's not the case, then the resource will take on that value, and if not, the debouncing starts again.

As every Signal has an initial value, the debouncing for the first value doesn't happen.

@Component({
  selector: 'app-debounced',
  template: `Value {{ debouncedCounter.value() }}`,
})
export class DebouncedPage {
  protected readonly counter = signal(1);

  protected readonly debouncedCounter = debounced(this.counter, 600);

  constructor() {
    setTimeout(() => this.counter.update((v) => v + 1), 500);
    setTimeout(() => this.counter.update((v) => v + 1), 1_000);
    setTimeout(() => this.counter.update((v) => v + 1), 1_500);

    effect(() => {
      console.log(`value updated ${this.debouncedCounter.value()}`);
    });
  }
}

debounced() is experimental. @Service and injectAsync are not.

angular.love

Angular 22: The Most Important New Features at a Glance - ANGULARarchitects

Angular 22 stabilizes the Resource API and Signal Forms, makes OnPush the default change detection strategy, and brings @Service, injectAsync, debounced, as well as numerous template and router improvements. This article shows the relevant updates using concrete examples.

angulararchitects.io

Vitest and change detection

In Angular 21, we've received Vitest as the new default testing framework. It was not possible to easily migrate because a lot of us were using fakeAsync or waitForAsync to manage asynchronous tasks in tests. With Angular 22, that is possible again, but remember, fakeAsync and waitForAsync depend on zone.js. So if you have plans to move to zoneless or are already there, it is not an option.

If you run ng update, your components which are not OnPush will get a ChangeDetectionStrategy.Eager. That's the new alias for the old Default value, because default is not OnPush. Speaking of zoneless, if you want to migrate, staying with zone.js and moving all your components to OnPush as an intermediate step is a good approach.

blog.angular.dev

WebMCP

Also in terms of AI, there is experimental support for WebMCP. That means an agent can connect to your web application and can execute certain tool calls. That means, you in Angular have to expose calls to services with a description and so on, and then if the browser supports it, the agent can call them. So it is not necessary anymore that the browser has to read and interact with the DOM.

WebMCP is still in development, but we can expect to hear more from it in the future. There is also a feature which sets up forms for WebMCP.

Community content

As always, there is a lot of community content out there. We had a release video, a release blog and Mark Thompson, Angular's DevRel, was also guest at the Angular Plus Show.

For this episode, we additionally used the blogs from Cedric Exbrayat from Ninja Squad, Manfred Steyer from Angular Architects, and Mateusz Stefańczyk from House of Angular.

What's new in Angular 22.0? - Ninja Squad

Angular 22.0 is out!

blog.ninja-squad.com

angular.love

Angular 22: The Most Important New Features at a Glance - ANGULARarchitects

angulararchitects.io

ng-neat GitHub

Last but not least, a very important information. Last weekend, the popular ng-neat organization was removed from GitHub. That contained widely used libraries, like Elf for state management and Spectator for testing. Before that, members of the organization were also removed. At the moment, we don't know why because there was no official communication from the owner.

What is important though, that most of the libraries have been recovered and found their way back to GitHub under a new organization called ngneat-archive. We will keep you updated on this topic.

Reddit thread

Ng-News 26/14: linkedSignal Write-Back, Error Boundaries

ng-news — Tue, 02 Jun 2026 20:55:34 +0000

Angular 22 stabilization (resources, Signal Forms, @angular/aria) and compiler ABI stability across patch versions for micro frontends are the headline items this week. Also in brief: linkedSignal's set option and NgRx's reverted delegatedSignal, plus error boundaries from Google I/O.

Angular 22 stabilization

The release of Angular 22 is getting closer, and we are also getting more and more information about the changes but also what awaits us beyond Angular 22.

We already know that Angular 22 will make a lot of features stable. That is resources, Signal Forms, but also @angular/aria. Stable means no breaking changes within majors.

Versioning and releases • Angular

The web development framework for building modern apps.

angular.dev

Compiler ABI and micro frontends

Another feature was announced, and it will be a happy message for anyone who's using micro frontends via Native Federation or Module Federation. Until now, whenever you loaded another Angular application/micro frontend during runtime, you had to make sure that it has been compiled with exactly the same version as the host application.

Why? Because the compiled Angular code was never part of the public API and didn't follow semantic versioning, which means the Angular team could introduce breaking changes within patch versions.

That is going to change. Breaking changes within a major can still happen in minors, but not in patch versions.

docs: establish compiler abi stability across patch versions #68623

alxhub posted on May 07, 2026

Define the new policy that the compiler ABI (the internal runtime APIs called by compiler-generated code) is stable across patch versions within the same minor version. This update unblocks microfrontend use cases and safer sharing of the Angular runtime across independent builds.

View on GitHub

linkedSignal `set` and delegatedSignal

In former episodes, we've already touched upon the need for a new Signal type, which is like linkedSignal, that derives the value from another Signal, but is not writable. At the same time though, it should be possible to have an option to write back to the original Signal.

That feature exists already for Signal Forms under the name DeepSignal, but it is only internal. And because there is a need for it for us as well, NgRx, a state management library, was about to introduce that as delegatedSignal in NgRx 22, but it is not going to happen and the existing commit was reverted.

linkedSignal itself will get a set option, which allows you to write back to the original Signal. So in some way what the delegatedSignal would have done will be part of the linkedSignal itself.

The PR has a label for minor version, which means Angular 22.1. Last summer, the difference between 20.0 and 20.1 was around 6 weeks. Given that Angular 22 will be released in the week of June 3rd, that means we are looking at a release of mid-July.

feat(core): add custom set option to linkedSignal #68708

alxhub posted on May 13, 2026

Introduce a custom set option in linkedSignal options to allow overriding and customizing the default write-back behavior of writable signals. This lets developers route updates back to the source of truth (e.g., converting Fahrenheit back to Celsius) or perform other side effects like updating properties inside a parent signal.

Additionally, the custom callback receives the standard signal setter as its second parameter (rawSet) to allow direct internal mutation if desired.

TAG=agy CONV=addbb5c4-4233-49e8-b844-6f732d7d5c72

PR Checklist

Please check if your PR fulfills the following requirements:

[ ] The commit message follows our guidelines: https://github.com/angular/angular/blob/main/contributing-docs/commit-message-guidelines.md
[ ] Tests for the changes have been added (for bug fixes / features)
[ ] Docs have been added / updated (for bug fixes / features)

PR Type

What kind of change does this PR introduce?

[ ] Bugfix
[ ] Feature
[ ] Code style update (formatting, local variables)
[ ] Refactoring (no functional changes, no api changes)
[ ] Build related changes
[ ] CI related changes
[ ] Documentation content changes
[ ] angular.dev application / infrastructure changes
[ ] Other... Please describe:

What is the current behavior?

Issue Number: N/A

What is the new behavior?

Does this PR introduce a breaking change?

[ ] Yes
[ ] No

Other information

View on GitHub

ngrx/platform#5157 — revert delegatedSignal (Angular linkedSignal set planned)

Ng-News 26/11: TypeScript 6, NgRx RFCs, delegatedSignal

Google I/O: error boundaries

Google's conference Google I/O also took place, and Mark Thompson, Angular DevRel, gave a talk where, among other things, he introduced an upcoming feature which is called error boundaries.

You can see it as an elegant try/catch block for the template. Similar to @defer you wrap parts of the template into @boundary and if an error occurs, the boundary will catch it and display a fallback. Mark also mentioned that there could be an option to define retry logic for the boundary.

That will also improve the DX with resources, which throw the error if you access its value.

It was the first time that we heard about this feature publicly. Mark said that they plan to make it available as developer preview in Q3 this year, which probably means Angular 23.

Ng-News 26/13: @Service, Native Federation, Angular Feature Lifecycles

ng-news — Tue, 05 May 2026 18:13:29 +0000

Angular 22's proposed @Service decorator and the likely stabilization of the resource API family. Also in brief: Angular feature lifecycle stages, Native Federation v4 changes, and fresh Oxc Angular compiler benchmark context.

Angular 22 preview: `@Service` and resource APIs

The release of Angular 22 comes closer, and we are also getting more and more information about the changes.

For example, we will get a new decorator for services, which will also be called @Service. What's the difference compared with the existing @Injectable decorator?

By default, @Service will automatically provide the service in root, and you cannot use constructor-based dependency injection anymore, but have to go via the inject function.

And another PR, which is still open, says the resource family, including httpResource, but also rxResource, will leave the experimental stage and become stable. So the developer preview gets skipped. One also has to say that we have had the resource APIs for almost 1.5 years now, so it is more than time.

feat(core): introduce @Service decorator #68195

crisbeto posted on Apr 14, 2026

These changes introduce the new @Service decorator which is a more ergonomic alternative to @Injectable. The reason we're adding a new decorator is that @Injectable has been around since the beginning of Angular and it has a lot of baggage that adds unnecessary overhead for users that generally want to define a singleton service, available in their entire app. The key differences between @Service and @Injectable are:

@Service is providedIn: 'root' by default. You can opt into providing the service yourself by setting autoProvided: false on it.
@Service doesn't allow constructor-based injection, only the inject function.
@Service doesn't support the complex type signature of @Injectable (useClass, useValue etc.). Instead it supports a single factory function.

Example:

import {Service} from '@angular/core';
import {HttpClient} from '@angular/common/http';
import {AuthService} from './auth';

@Service()
export class PostService {
  private readonly httpClient = inject(HttpClient);
  private readonly authService = inject(AuthService);

  getUserPosts() {
    return this.httpClient.get('/api/posts/' + this.authService.userId);
  }
}

View on GitHub

refactor(core): promote `resource`, `rxResource` & `httpResource` to stable #68253

JeanMeche posted on Apr 16, 2026

The time has come.

Note: #67382 introduced a breaking change where you could notice some sublte timing change on how value is set when using rxResource or a stream on a resource

View on GitHub

Feature lifecycle stages in Angular

Alejandro Cuba Ruiz wrote on the ng-conf Medium publication about what he calls the five lifecycle stages of an Angular feature: experimental, developer preview, stable, deprecated, and removed. The article is not a secret internal document; it lines up with what we occasionally also hear from the Angular team.

Experimental means the API can move under minors or patches, so the author argues to keep it out of production and to experiment in isolation. Developer preview is "we like the design, show us real-world pain" - safer than experimental, still not semver-frozen. Stable is the contract: breaking changes belong in majors, with migrations when possible. Deprecated gives you the familiar two-major-version runway, and removed is the point where the code is actually gone.

He also mentions tooling outside the official docs, for example a "Can I Use Angular Features" grid from Gerome Grignon, which can be handy if you support more than one Angular version.

Next to experimental, developer preview, and stable, there are also the deprecation and removal stages that Alejandro also covers.

So quite a sound guide to help you decide if and when you want to use a certain feature.

The 5 lifecycle stages of an Angular feature

Versioning and releases • Angular

The web development framework for building modern apps.

angular.dev

Native Federation v4 updates

Native Federation is next to Module Federation one of the most used libraries when it comes to building microfrontends in Angular. Native Federation version 4 was released and brings a bunch of updates, whereas the most visible one is a website with a lot of documentation. The GitHub repository was also moved to a new organization, the code is now split into multiple repositories, and an orchestrator that manages the microfrontends takes or will take over the old runtime.

Native Federation — Micro Frontends with Web Standards

A browser-native implementation of Module Federation for building Micro Frontends using web standards like ESM and Import Maps.

native-federation.com

Oxc Angular compiler benchmarks and caveats

In a former episode of ng-news, we've already covered Void Zero's experiments on writing the Angular compiler in the Oxidation Compiler, which is built on Rust.

There is now an official article where they publish official numbers and also give some background information on their development process, which is of course heavily AI-based.

They describe on the order of two months of work, mainly with Claude Code and Codex, under the steering of experienced engineers - not "the model wrote a compiler overnight," but agents doing large-scale porting and review work once the architecture and guardrails exist.

The headline numbers are eye-catching: they report on the order of six times faster compiles than the Angular CLI.

As always, be careful with those numbers, but they could be reasonable. Especially since they omitted some heavy tasks like template type-checking. They also admit that the non-existing type-check is a significant performance booster.

The compiler is available as a Vite plugin, @oxc-angular/vite.

VoidZero also writes that the repository will not be maintained long term. In parallel, they note that the Angular team has its own experiments with Oxc.

How we made the Angular Compiler faster using AI | VoidZero

How VoidZero built the Oxc Angular Compiler, an AI-powered Angular compiler that achieves up to 20x faster code compiling speed.

    <div class="color-secondary fs-s flex items-center">
        <img
          alt="favicon"
          class="c-embed__favicon m-0 mr-2 radius-0"
          src="https://voidzero.dev/favicon.svg"
          loading="lazy" />
      voidzero.dev
    </div>
  </div>
</div>

voidzero-dev/oxc-angular-compiler

Ng-News 26/12: Future of Selectorless, Skills vs. MCP, Zoneless Testing

ng-news — Fri, 10 Apr 2026 13:22:25 +0000

Ng-News 26/12 covers the Angular Q&A on selectorless and Skills versus MCP, then zoneless testing and auto tick from the Angular Plus Show.

Angular Q&A: selectorless and Skills vs MCP

The monthly Q&A session featured Mark Thompson as host and Alex Rickabaugh, tech lead of the Angular framework.

Alex explained why selectorless got downgraded. Selectorless was a planned feature that would have allowed referring to components in a template by using their class name. In the latest roadmap update, that feature was removed.

According to Alex, selectorless would have been a huge jump. The risk of an AI agent not being able to write modern Angular code was not worth the DX benefits from selectorless. Therefore, that feature is on hold and will be re-evaluated in the future.

Timestamp: 0:05:50

Skills and MCPs: According to Alex, Skills are starting to replace MCP tools, because a Skill can tell the agent about certain CLI commands, which can replace a dedicated MCP tool call.

Timestamp: 23:11

Zoneless testing and auto tick

The Angular Plus Show published an episode on zoneless testing with Andrew Scott (Angular team), @younesjd, and Rainer Hahnekamp.

Zoneless tests run outside Zone.js, which clarifies some patterns but means you cannot use fakeAsync or waitForAsync in that mode.

With zoneless, change detection in tests would be triggered like in the application, whereas in zone-based tests, users had to trigger it very often manually via ComponentFixture#detectChanges.

The panel also discussed auto tick, recently released around the time of recording and covered in a prior ng-news segment.

It can simplify async behavior when timer APIs are faked, but it is not always the first choice: mixing real and fake timers produces confusing failures, and faking timers overrides timing globally and can affect third-party code you do not control.

Upcoming Conferences

This is a new feature of ng-news. At the end of each article, we are listing all upcoming conferences.

NG Belgrade Conf 2026

NG Belgrade Conf 2026 is the largest Angular conference in the Balkans. It takes place in Belgrade, Serbia, including a Conference Day on May 7th and a Workshop Day on May 8th. Join us to explore the latest trends and best practices in Angular!

angularbelgrade.org

ngbaguette.angulardevs.fr

Ng-News 26/11: TypeScript 6, NgRx RFCs delegatedSignal, Resource Extensions

ng-news — Fri, 03 Apr 2026 17:43:23 +0000

Main topics: TypeScript 6.0 and NgRx (RFCs for delegatedSignal and resource extensions). Also in brief: Martina Kraus on security, debounce for async validators, Alfredo Perez on SpecKit, and Angular Graz on YouTube.

TypeScript 6.0

TypeScript 6.0 was released and it is going to be the last TypeScript version, written in TypeScript. Officially, TypeScript 6 is seen as the bridge between TypeScript 5 and TypeScript 7 (which will be written in Go). First of all, TypeScript 6 is not yet part of Angular. So you can't make use of those changes yet. Angular 21 supports TypeScript 5.9, but 22 will support TypeScript 6.

In order to prepare for version 7, TypeScript 6 comes primarily with a lot of deprecations and new default settings, which pay tribute to the modern TypeScript ecosystem.

For example, ESM is now default module system, the strict mode is enabled and the target is the ECMAScript version with the number of the current last year. By now, that would be ECMAScript 2025.

When it comes to the deprecation. Target ES5, which was the last version of JavaScript without the class syntax, lambda expressions, Promises, let or const, string interpolation, and much more got deprecated.

What also went away is the baseUrl property in the tsconfig.json file, support for the module systems amd, umd, and systemjs (not sure if our younger colleagues still know what that is) has also gone. You can of course also revert those deprecations, but be aware that in TypeScript 7, that means game over.

There is an automatic migration tool available, which is marked as experimental.

Announcing TypeScript 6.0 - TypeScript

TypeScript 6.0 is now available! TypeScript 6 is a stepping-stone release, aligning with the upcoming native-speed 7.0 release.

devblogs.microsoft.com

There are also new features, and the most prominent one is the introduction of the Temporal API.

This is a new, built-in date and time API in JavaScript, which can be seen as a full replacement for the old Date object. As that, it provides way more functionality for example handling timezones, a calendar which can be used to reflect Chinese or other calendar systems, immutability and a range of utility functions.

Some veterans of us might remember the switch to the Date-time API in Java more than 10 years ago. It kind of did the same thing.

Temporal API has reached stage 4 of the TC39 process, which means it is standardized, finished. That doesn't mean that each platform supports it. The latest version of Chrome, Firefox supports it, but not Safari and also Node.js which means if you use it, you should secure your code with polyfills.

typescriptlang.org

const today = Temporal.Now.plainDateISO();
const startOfYear = today.with({ month: 1, day: 1 });
const diff = startOfYear.until(today);

console.log(`${diff.days} days have passed`);

NgRx RFCs

NgRx is the most used library for state management in Angular and official work has begun on supporting resources but also forms. Two RFCs for that have landed.

`delegatedSignal()`

The first RFC is related to supporting Signal Forms and it introduces a new Signal type called delegatedSignal. To the outside it is a writable Signal, but it doesn't store a value. Instead it writes and reads to another Signal. What's the use of it?

Let's say we have a user object in a Signal, that has two nested properties: name and address. name has firstName and lastName, and address has street and city, like this:

const user = signal({
  name: { firstName: 'John', lastName: 'Doe' },
  address: { street: '123 Main St', city: 'Anytown' }
});

If we have a form, which requires a flattened version of the user object, we would usually create a linkedSignal. The problem is that changes in the form might be synchronized back to the original Signal. At the moment, the only way would be to use an effect.

@Component({
  template: ``
})
export class UserPage {
  user = signal({
    name: {
      firstname: "John",
      lastname: "Doe"
    },
    address: {
      street: 'Main Street',
      city: 'London'
    }
  })

  userFormModel = linkedSignal(() => ({
    firstname: this.user().name.firstname,
    lastname: this.user().name.lastname,
    city: this.user().address.city,
    street: this.user().address.street,
  }))

  userForm = form(this.userFormModel);

  syncEffect = effect(() => {
    const { firstname, lastname, street, city } = this.userFormModel();

    this.user.set({
      name: { firstname, lastname },
      address: { street, city }
    })
  })
}

delegatedSignal solves this problem by writing synchronously back to the original Signal.

// PROTOTYPE!!!
export function delegatedSignal<T>(config: {
  computation: () => T,
  update: (value: T) => void
}
): WritableSignal<T> {
  const delegated = linkedSignal(config.computation);

  delegated.set = (value: T) => config.update(value);
  delegated.update = (updateFn: (value: T) => T) => updateFn(delegated())

  return delegated;
}


@Component({
  template: ``
})
export class UserPage {
  user = signal({
    name: {
      firstname: "John",
      lastname: "Doe"
    },
    address: {
      street: 'Main Street',
      city: 'London'
    }
  })

  userFormModel = delegatedSignal({
    computation: () => {
      const { 
        name: { firstname, lastname }, 
        address: { city, street } 
      } = this.user();
      return { firstname, lastname, street, city }
    },
    update: ({ firstname, lastname, street, city }) => {
      this.user.set({
        name: { firstname, lastname },
        address: { street, city }
      })

    }
  })

  userForm = form(this.userFormModel);
}

The delegatedSignal can be used for different use cases. Not just forms. Regarding the SignalStore, you could connect a Signal Form and a SignalStore together, where each change in the form is directly written to the SignalStore.

You can see the delegatedSignal as a linkedSignal which doesn't create a clone, but just writes directly back to the original Signal. delegatedSignal exists already in the Angular framework (slightly differently as deepSignal), but is not exposed publicly. Angular uses it for the Signal Forms:
https://github.com/angular/angular/blob/394ad0c2a26eec8a8f7136b1b7971420b30a117e/packages/forms/signals/src/util/deep_signal.ts#L21

ngrx/platform#5121 — RFC delegatedSignal

Resource Extensions

And the second RFC is related to resources. It allows to extend the resources which goes beyond the possibilities of the current snapshot function. For example, an extension would change the behavior of a resource in an error state, where an access to the value does not throw. Custom extensions are possible as well and there is even the option to define default extensions.

All two issues were created by @markostanimirovic and if the same Marko was also guest at a previous episode of the Angular Plus show. So if you are interested to hear more about state management and SignalStore specifically, you should check out the episode.

ngrx/platform#5126 — RFC resource extensions

Martina Kraus on security (Angular Plus Show)

In other news, the Angular Plus Show also had Martina Kraus as guest, which usually means the topic is about security.

Together with the three hosts, Lara Newsom, Brooke Avery, and Jan-Niklas Wortmann, they discussed a whole portfolio of security. Be it trusted types, Sanitization, attacks like XSS and CSRF, but also content policies and the increased risk that comes with AI.

At the end, Martina gave some tips where to start with security and she also highlighted the OWASP juice shop, which is written in Angular and is a playground to try out different vulnerabilities.

And by the way, you should not store your access token in local storage.

OWASP Juice Shop | OWASP Foundation

Probably the most modern and sophisticated insecure web application for security trainings, awareness demos and CTFs. Also great voluntary guinea pig for your security tools and DevSecOps pipelines!

owasp.org

Form validation: debouncing async validators

And we have a third debounce option in Angular. For Signal Forms, there is a debounce function, which debounces the synchronization of a form field with the underlying model. The second is a debounced function, scheduled for Angular 22 and is meant for any Signal type out there. The new one, is debouncing for asynchronous validators in Signal Forms. That allows you to have "undebounced" synchronous validators, but debouncing an asynchronous validator.

That feature has been merged into the 22 version branch, but didn't make it into the latest 21.2.7 version. So it seems, we have to wait for Angular 22.

angular/angular@24e52d4 — debounce on validateAsync / validateHttp

Alfredo Perez: SpecKit and SpecKit Companion

@alfredoperez published a three-article series about a Spec-driven development process with AI. The most prominent tool in that spectrum is GitHub's SpecKit, which Alfredo describes. Additionally, he has created a VSCode extension, called SpecKit Companion, not just to visualize but also to edit and execute that specification.

Since GitHub's SpecKit is not the only tool out there, Alfredo also shows alternatives and how SpecKit Companion can be configured to support those tools as well.

https://medium.com/ngconf/speckit-companion-e4fc99d1e061

https://medium.com/ngconf/custom-workflows-in-speckit-companion-266fda3b5eec

https://medium.com/ngconf/build-your-own-sdd-workflow-daa3fc1ae673

https://marketplace.visualstudio.com/items?itemName=alfredoperez.speckit-companion

Angular Graz Meetup videos

Finally, the recordings of the Angular Graz Meetup are available on YouTube. They are published not at once but in a regular interval.

Ng-News 26/10: Signality, Vitest 4.1, Angular Skills

ng-news — Fri, 27 Mar 2026 18:56:51 +0000

This week's ng-news covers ngxtension on Angular Space, Signality's signal-first utilities inspired by VueUse, and Vitest 4.1 fake-timer improvements for Angular tests. We also look at official Angular agent skills.

Angular Space and ngxtension

ngxtension, a set of utility functions, was the topic on the Angular Space live stream. The hosts were - as always - Armen Vardanyan and Enea Jahollari, the maintainer of ngxtension; Enea joined the stream after a few minutes.

They discussed several main features. For example, injectParams, which a former episode of ng-news covered already, and the on helper, which offers strong developer experience for explicit effects but can also be used for explicit signal tracking in computed, resources, or linkedSignal.

ngxtension.dev

Signality

Another promising library that offers utility functions - this time only signal-based - was published. Signality is its name, and according to its author, Vyacheslav Borodin, it is heavily inspired by VueUse, a popular library of utilities for Vue.js. Although Signality was released at version 0.1, the number of functions is already quite impressive.

Getting started | Signality

Comprehensive library of signal-first utilities for Angular. SSR-ready, type-safe, and designed for seamless reactive composition and DI-interop.

signality.dev

Vitest 4.1 fake timers

Vitest, Angular's default testing framework for new projects, was released in version 4.1 and gained a major improvement in handling asynchronous timers. Fake timers gained an automatic tick mode.

In the past, when code used a delayed timer - for example because of debounceTime - you often had to advance those timers manually in tests. Now there is a mode that advances scheduled timers asynchronously without you hard-coding each delay. You no longer need to remember whether it was 100 ms, 200 ms, or something else. It does not remove asynchronicity, but it runs the deferred work on a short tick - roughly speaking, along the lines of setTimeout(() => void true, 0).

@younesjd added a section about that feature to his cookbook, and the Vitest documentation has more detail.

Vi | Vitest

Next generation testing framework powered by Vite

main.vitest.dev

Controlling Time in Tests | Marmicode Cookbook

Understand why time-based behavior is challenging to test and how fake timers and dynamic timing configuration address different scenarios.

cookbook.marmicode.io

Official Angular agent skills

Official Angular skills have landed. You can install them now with npx skills add angular/skills. After that, your agent should pick them up whenever the LLM decides to use them.

Skills are text content that explains to the LLM - for example, how Signal Forms work or how Angular's dependency injection works. The main distinction from MCP servers, basic rules, custom instructions, or whatever term your agent uses, is that skills are not loaded automatically up front. A skill starts with a short description of what it covers, which does not overload context, and - as noted above - when the LLM decides it is time to use one, it can load the full body on demand.

That pattern lets you keep many skills available without bloating every prompt.

Angular skills are not new. Ng-News already covered the Analog.js skills, which were created in January. As their author Brandon Roberts confirmed, now that official Angular skills exist, the Analog.js skills are deprecated.

angular/skills (GitHub)

// Detect dark theme var iframe = document.getElementById('tweet-2036184874898321635-415'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2036184874898321635&theme=dark" }

Ng-News 26/09: AI & Angular, debounced() in v22, Oxidation Compiler in Analog

ng-news — Thu, 19 Mar 2026 20:43:38 +0000

Ng-News 26-09 features three topics: the new Signal-based debounced API, the Oxidation compiler benchmark in Analog.js, and AI & Angular.

Angular XSS Advisory

A Cross-Site Scripting (XSS) vulnerability was discovered in Angular. If you use Angular i18n and apply it to HTML attributes, their values are not sanitized. The fix was applied to the supported versions Angular 19, 20, and 21.

Angular security advisory (GitHub)

Ng-Asia with Mark Thompson

Mark Thompson, Angular DevRel, was guest at Ng-Asia hosted by Ilyoskhuja Ikromkhujaev. The session was a mix between presentation and Q&A.

For example, Mark presented his view on how AI will shape the way development will work for us. He doesn't expect a replacement a software developers, but - as many people would agree - a shift in terms of activities/competencies.

He also explained what AI means for future applications, where the UI is highly responsive and can be seen as just another AI tool, instrumented by an LLM. There are libraries that support that use case already, like HashBrown.

Angular Q&A with Mark Thompson

Mark Thompson also hosted the monthly Angular Q&A session. His guest was Alan from the Angular team and the main topic was AI - specifically Angular's MCP server combined with Chrome's MCP server. MCP allows LLMs to perform actions, not just return text. Angular's MCP server provides up-to-date documentation on best practices, can help migrate to zoneless, or act as a tutor. Together with Chrome's MCP server, it allows the LLM to verify its generated code automatically and fix it.

Two answers stood out. First, a nice analogy on how skills and MCP tools differentiate. According to Mark, a tool's execution is more deterministic, whereas a skill is still text, which needs to be processed by the LLM, and could therefore cause non-deterministic, but better or different results, than an MCP tool's author could achieve.

He compared it with playing a piece of music on a guitar. In the case of an MCP tool and if the LLM would be an artist, then the LLM would play a piece always in the same way - without even knowing how or what it is doing.
In the context of a skill, it would learn how to play the guitar and could probably identify certain things that the tool would have oversawn.
For example Mark mentioned, that there could a first part of a piece, which the tool was not aware of, but the skill would cover it.

Second, why is Angular investing so much in AI? According to Mark, if you have a framework without AI support, many developers will say that it is not ready for the future and will switch to others. Given AI's omnipresence, having an AI-ready framework is a reasonable choice.

Timestamp 41:20.

Oxidation Compiler and Analog

As mentioned in a previous episode, there is an experimental Angular compiler, which is developed by Void Zero and is called the Oxidation compiler (Oxc).
The interesting thing is that it is written in Rust, and not in Go, which is the language of choice for the upcoming official TypeScript rewrite.

Brandon Roberts, who is well known in the Angular community, has integrated the Oxidation compiler into Analog.js, the most popular meta-framework for Angular, which supports building Angular with Vite. Brandon posted a benchmark stating that build time with Angular's esbuild dropped from 47 seconds to 1.5 seconds - a roughly 97% improvement.

// Detect dark theme var iframe = document.getElementById('tweet-2029653775330292103-98'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2029653775330292103&theme=dark" }

Angular Roadmap Update

Angular's roadmap got a major update, or one could say a reprioritization. In short, AI is king: topics like a new authoring format, streaming for server-side rendering, or improvements to the TestBed were removed. That does not mean these topics will never be worked on, but they are deprioritized for now.

Angular roadmap change (GitHub commit)

Angular NPM Downloads

If you are a fan of download numbers: despite the results of the State of JavaScript survey, Angular appears to be in a strong position. In May 2025, weekly downloads exceeded 4 million for the first time. In the week of March 9th they were above 5 million - roughly a 25% increase within a year. For reference, Angular passed 3 million weekly downloads in February 2022.

@angular/core | npm trends

Comparing trends for @angular/core 21.2.6 which has 5,338,072 weekly downloads and 100,138 GitHub stars.

npmtrends.com

Debounced API

Fatima Amzil published an article about a new Signal-based function called debounced. Do not confuse it with the debounce function in Signal Forms: that one is limited to Signal Forms and debounces the synchronization of a form field with the underlying model. The new debounced is meant for any Signal - you can use it to debounce a resource's value, a computed, a linkedSignal, or a function that returns a value (which will be automatically tracked). The return value is not another Signal but a resource. debounced is targeted for Angular 22.

Michael Small also contributed a post on Bluesky with a GIF demonstrating the new function.

https://famzil.medium.com/angular-22-the-power-of-debound-and-debounced-apis-c41e33c0a18e

Just landed in the Angular nightly: debouncing signals. Photo of code snippet + link to PR in this thread github.com/angular/angu...
— Michael Small (@michaelsmalldev.bsky.social) 2026-03-09T22:14:51.079Z

Angular Vienna and Code Magazine

In other news, the Angular Vienna meetup took place and the recording of the live stream is available on YouTube. At the meetup, Dmytro Mezhenskyi from Decoded Frontends gave his first public talk. Other speakers were Matthieu Riegler from the Angular team on JavaScript in general and the upcoming changes in Angular due to the TypeScript rewrite in Go, Manfred Steyer on AI in Angular, and Daniel Szendrei on Angular hacks.

Sonu Kapoor published an in-depth article on the evolution of Angular forms in Code Magazine. The article contains almost 15,000 words.

From Template-Driven to Signal-Driven: The Complete Evolution of Angular Forms

Sonu Kapoor's article, "From Template-Driven to Signal-Driven: The Complete Evolution of Angular Forms," provides a comprehensive exploration of Angular's evolving form APIs, tracing their journey ...

codemag.com

Ng-News 26/08: Angular 21.2

ng-news — Thu, 12 Mar 2026 17:54:46 +0000

The release of Angular 21.2 introduced several significant features - most notably for Signal Forms - while also delivering key enhancements across the broader framework.

Angular 21.2 was released. According to the plan, that was the last minor release in the 21.x series. The next major release will be Angular 22 in May. According to schematic versioning, a minor brings only bug fixes and small features, but there is quite a lot in this release.

Signal Forms

Signal Forms have picked up several useful features that round it out and suggest it is moving toward stability or developer preview.

Form Submission

For example, the need to manually disable form submission is now handled in a simple way. You no longer have to wire this yourself: add the formRoot directive to the form and it turns off the browser default submit behavior (e.g. full page reload).

You configure the submit handler via the submission option of the form() function. That handler runs only when the user actually submits (e.g. Enter or the submit button) and when the form is not invalid.

By default, that means submit can run even while asynchronous validators are still pending.

While an async validator is running, it keeps {invalid: false, valid: false}.

Submit only happens if the invalid is true, so pending validators do not block submission.

You can change this with ignoreValidators: 'none' if you want to wait until all validators, including async, have finished.

The default is permissive because the server will validate again on submit anyway, so there is no need to wait for client-side async validators before allowing the request.

import { bootstrapApplication } from '@angular/platform-browser';
import { 
  Component, computed, inject, Injectable, signal 
} from '@angular/core';
import {
  form,
  FormField,
  FormRoot,
  submit,
  validateAsync,
  validateStandardSchema,
} from '@angular/forms/signals';

@Injectable({ providedIn: 'root' })
export class UserService {
  save(user: { firstName: string; lastName: string }) {
    return Promise.resolve(undefined);
  }
}

@Component({
  selector: 'app-root',
  imports: [FormField, FormRoot],
  template: `
    <form [formRoot]="userForm">
      <input [formField]="userForm.firstName" />
      <input [formField]="userForm.lastName" />
    </form>
  `,
})
export class App {
  private readonly user = signal({
    firstName: '',
    lastName: '',
  });

  protected readonly userForm = form(this.user, {
    submission: {
      action: () => this.userService.save(this.user()),
    },
  });

  protected readonly userService = inject(UserService);
}

bootstrapApplication(App);

Code Example on Stackblitz

Custom Control

For custom controls, we now have the ability to use the transformedValue utility for formatting and parsing.

For example, it can be used for input fields with non-English number or date formats.

import { bootstrapApplication } from '@angular/platform-browser';

import { Component, model, signal } from '@angular/core';
import {
  form,
  FormField,
  FormRoot,
  FormValueControl,
  transformedValue,
} from '@angular/forms/signals';
import { JsonPipe } from '@angular/common';

@Component({
  selector: 'app-german-number-field',
  template: `<p><ng-content /></p>
      <input
        matInput
        [value]="rawValue()"
        (input)="rawValue.set($event.target.value)"
      />`,
  imports: [],
})
export class GermanNumberField implements FormValueControl<number> {
  readonly value = model.required<number>();

  readonly rawValue = transformedValue(this.value, {
    parse: (value: string) => ({ value: Number(value.replace(',', '.')) }),
    format: (value) => String(value).replace('.', ','),
  });
}

@Component({
  selector: 'app-root',
  imports: [FormField, FormRoot, GermanNumberField, JsonPipe],
  template: `
    <form [formRoot]="userForm">
    <app-german-number-field [formField]="userForm.heightInMeter">Height in Meters</app-german-number-field>
    {{user() | json}}
    </form>
  `,
})
export class App {
  protected readonly user = signal({
    heightInMeter: 1.75,
  });

  protected readonly userForm = form(this.user);
}

bootstrapApplication(App);

Code Example on Stackblitz

SignalFormControl

Although the improved form submission and the advanced features for custom controls are really great, most of us work with an existing Angular application.

For us, the most important new feature is SignalFormControl. It allows you to introduce a FormControl into Reactive Forms that supports, for example, the advanced validation rules from Signal Forms.

That makes the migration to Signal Forms much easier.

import { bootstrapApplication } from '@angular/platform-browser';

import { Component, inject, resource } from '@angular/core';
import { required, debounce, validateAsync } from '@angular/forms/signals';
import { SignalFormControl } from '@angular/forms/signals/compat';
import { FormBuilder, ReactiveFormsModule } from '@angular/forms';

@Component({
  selector: 'app-root',
  imports: [ReactiveFormsModule],
  template: `
    <form [formGroup]="userForm">
      <input formControlName="email" />
    </form>
  `,
})
export class App {
  protected readonly userForm = inject(FormBuilder).nonNullable.group({
    email: new SignalFormControl<string>('user@host.com', (path) => {
      required(path, { message: 'Email is reqired' });
      debounce(path, 500);
      validateAsync(path, {
        params: (ctx) => ctx.value(),
        factory: (params) => {
          return resource({
            params,
            loader: () => Promise.resolve(true),
          });
        },
        onSuccess: () => undefined,
        onError: () => ({ kind: 'networkError' }),
      });
    }),
  });
}

bootstrapApplication(App);

Code Example on Stackblitz

`ResourceSnapshot`

The Resource Snapshot API was finally released. That is a feature that was expected to land in Angular 21 already; it was in the main branch but got reverted.

In short, Resource Snapshots allow you to map one resource to another or use them for compositional tasks.

The example given in the docs changes the default behavior of setting the value to undefined during loading to keeping the original value. In Angular's codebase, the snapshot is used for testing, where it acts as a convenient resource factory function. We will see what use cases are possible.

The example below shows an error handler, which can be used to avoid the error status.

import { bootstrapApplication } from '@angular/platform-browser';
import {
  Component,
  computed,
  Resource,
  resource,
  resourceFromSnapshots,
  signal,
} from '@angular/core';
import { JsonPipe } from '@angular/common';
import { FormField, FormRoot, form } from '@angular/forms/signals';

function withErrorHandler<T>(
  resource: Resource<T>,
  errorHandler: (error: Error) => T
) {
  const res = computed(() => {
    const snap = resource.snapshot();
    if (snap.status === 'error') {
      try {
        return { status: 'resolved' as const, value: errorHandler(snap.error) };
      } catch (error) {
        if (error instanceof Error) {
          return { status: 'error' as const, error };
        }
      }
    }
    return snap;
  });

  return resourceFromSnapshots(res);
}

@Component({
  selector: 'app-root',
  imports: [FormRoot, FormField, JsonPipe],
  template: `
    <form [formRoot]="idForm">
      <input [formField]="idForm.id" type="number"/>

      <pre>{{safeUser.value() | json}}</pre>
      <pre>{{unsafeUser.value() | json}}</pre>
    </form>
  `,
})
export class App {
  idForm = form(signal({ id: 0 }));

  unsafeUser = resource({
    params: () => this.idForm.id().value(),
    loader: ({ params: id }) => {
      if (id < 0) {
        throw new Error('no negative users ;)');
      }

      return Promise.resolve({ id, name: 'John Doe' });
    },
  });

  safeUser = withErrorHandler(this.unsafeUser, () => ({
    id: 0,
    name: 'John Undefined',
  }));
}

bootstrapApplication(App);

Code Example on Stackblitz

CLI - Prettier Integration

As the CLI already provides full integration of Tailwind CSS, Angular 21 also integrates Prettier as a first-class citizen.

Lambdas in Templates

The syntax in the template, which is not native JavaScript, has been extended with two new features. We can now use lambda functions directly in templates.

The favored use case is to call the update method on a signal.

In general, logic should stay out of the template, so do not overuse this feature.

import { bootstrapApplication } from '@angular/platform-browser';
import { Component, signal } from '@angular/core';

@Component({
  selector: 'app-root',
  template: `
  <p>Current Value: {{counter()}}</p>
  <button (click)="counter.update((value) => value + 1)">Increment</button>
  `,
})
export class App {
  counter = signal(0);
}

bootstrapApplication(App);

Code Example on Stackblitz

Exhaustive Checks

The @switch statement now supports exhaustive checking: the compiler verifies that all possible cases are covered when you use @default never.

import { bootstrapApplication } from '@angular/platform-browser';
import { Component, signal } from '@angular/core';

type UserType = 'admin' | 'anonymous';

@Component({
  selector: 'app-root',
  template: `
@switch(userType) {
  @case('anonymous') {
    <p>Welcome Visitor</p>
  }
  @case('admin') {
    <p>Welcome admin</p>
  }
  @default never;
}

  `,
})
export class App {
  userType: UserType = 'admin';
}

bootstrapApplication(App);

Code Example on Stackblitz

ChangeDetectionStrategy.Eager

As already announced, ChangeDetectionStrategy.Default was renamed to ChangeDetectionStrategy.Eager. The reason is that in Angular 22, in May, the default will become OnPush, and because it does not make sense to call the non-default option "default", its new name is Eager.

You do not have to change anything. If you explicitly use ChangeDetectionStrategy.Default, you can remove that setting or, even better, migrate to OnPush.

You are not forced to change anything. When Angular 22 is released, the update scripts will explicitly set existing implicit or explicit components with ChangeDetectionStrategy.Default to ChangeDetectionStrategy.Eager.

Sources and Thanks

For further information, check out the official changelog and a big thanks to Cedric Exbrayat

His article was the main source for this episode.

Merci beaucoup Cedric!

What's new in Angular 21.2? - Ninja Squad

Angular 21.2 is out!

blog.ninja-squad.com

Angular CHANGELOG (GitHub)

Ng-News 26/07: Angular's Router, Vitest, Hashbrown, History & Popularity

ng-news — Tue, 24 Feb 2026 23:24:05 +0000

Andrew Scott on Angular's Router, Vitest with Younes Jaadi, Hashbrown and AI, State of JS and 100k stars, Maximilian's Angular retrospective, ngxtension 7.1 and ngDiagram 1.0.

Andrew Scott on Angular's Router

Andrew Scott, member of the Angular team, was a guest on Armen Vardanyan's podcast at Angular Space, and they discussed a wide range of topics.

They talked about a potential integration of resources into the router, where the router would know exactly what kind of data needs to be loaded and the loading could also be done in parallel. Right now we have a waterfall effect, where each segment with its resolvers needs to be loaded sequentially.

On RxJS, it is still going to become optional in the future, but that does not have the highest priority at the moment.

Another topic was the relationship between community libraries and Angular. For example, ngxtension has a lot of useful utility functions for the router, which would make sense to be part of the framework. Andrew meant that the framework should provide the building blocks and the community should build certain features on top of it.

The TypeScript rewrite in Go was also discussed. A lot of the Angular team's time is currently going into preparing for that rewrite.

Theoretically, a mixed approach might also be possible. Alex Rickabaugh, lead of the Angular framework, was not on the podcast, but he posted that they are looking into using Rust in some parts of Angular's compilation process.

// Detect dark theme var iframe = document.getElementById('tweet-2024164838688379157-601'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2024164838688379157&theme=dark" }

Younes Jaadi on Vitest

Younes Jaadi posted a video about Vitest, which is Angular's default testing framework since Angular version 21.

His main focus was on the so-called browser mode, which uses an E2E-style runner such as Playwright or WebdriverIO to interact with the DOM. He shared technical insights and pragmatic tips on how to use Vitest.

Younes is highly respected in the Angular community and has been promoting Vitest in Angular before it became the official testing framework.

Manfred Steyer on Hashbrown and AI in Angular

AI shows up in many places, including Angular, where it can generate dynamic components, accept prompts, and call tools on the fly. A prominent library for this is Hashbrown.

Manfred Steyer has written a three-article series on the topic: basic setup, integrating a prompt, connecting with your application, and more advanced features such as dynamic components or letting Hashbrown execute code in the browser.

Dynamic Reports: Natural Language Queries with On-the-Fly Code Generation - ANGULARarchitects

angulararchitects.io

State of JavaScript and Angular's popularity

State of JavaScript released the results from last year. Angular saw a rise in 2024 in metrics around popularity and satisfaction, and a small decline in 2025, with some gap to 2023. The survey's sample is often said to be not representative, so the numbers may not reflect the broader population.

State of JavaScript

stateofjs.com

Angular's repository on GitHub has reached 100,000 stars. For comparison, React has about 240,000 and Vue about 53,000. Enea Jahollari posted about a Reddit thread on the webdev subreddit where someone asked if Angular is still used; as Enea put it, there were some good comments about Angular.

// Detect dark theme var iframe = document.getElementById('tweet-2024897592006422590-594'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2024897592006422590&theme=dark" }

Maximilian Schwarzmüller – 10 Years of Angular

Maximilian Schwarzmüller is a well-known name in Angular. His Udemy course has been the door opener for many Angular developers since 2016. He published a video titled "Looking back at 10 years of Angular - and into its future", covering the early days, milestones, and where we are now. If you want nostalgia or a brief overview of Angular's history, it's a good watch.

Also in the News

Ngxtension 7.1 brought injectParams.global(), which gives you one signal with all the parameters of the current route hierarchy.

ngxtension.dev

ngDiagram had its first stable release with version 1. It has zero dependencies, is based on modern Angular, and lets you create interactive diagrams. It looks very promising.

ngdiagram.dev

If you use VS Code, check out the latest Angular VS Code extension; it includes some new goodies.

https://github.com/angular/angular/releases/tag/vsix-21.2.0/

Ng-News 26/05: OnPush as Default, Agent Skills, Q&A

ng-news — Wed, 11 Feb 2026 08:00:00 +0000

Agent Skills are landing for Angular. This episode also covers the January Angular Q&A (Jeremy Elbourn leaving, markForCheck discussion, Dart's legacy) and Mark Thompson's RFC to make OnPush the default.

Skills landing in Analog first, and now in Angular

The AI world continues to evolve, and things that were top notch yesterday are already outdated today. When it comes to teaching AI how to write proper and modern Angular code, the answer in 2025 was the Angular CLI's built-in MCP server. In 2026, the answer is Skills.

With MCP, we have the issue that they overload the context size of the LLM, because the tools' manifest has to be loaded always. Skills, on the other hand, are lightweight. They are not loaded automatically - only a small amount of metadata. The whole content is only loaded once on demand, namely when the LLM decides that it is now time to use it.

Skills, like MCP, were introduced by Anthropic, which stands behind Claude Code. They first introduced them in October last year and in December standardized them as Agent Skills. To use them, you usually need one of the common IDEs that are good at AI integration, and you are not limited to Claude's models; it also works with others like GPT or Gemini.

Brandon Roberts posted that he added skills to Analog.js, which is a meta-framework for Angular. One week later, Angular reacted as well: Mark Thompson confirmed and created a PR so that Skills land officially in Angular.

// Detect dark theme var iframe = document.getElementById('tweet-2014895426088919431-979'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2014895426088919431&theme=dark" }
Angular PR #66834

claude.com

Overview - Agent Skills

A simple, open format for giving agents new capabilities and expertise.

agentskills.io

Angular Q&A with the Angular team

We had the January Angular Q&A with the Angular team. As usual, Mark Thompson and Jeremy Elbourn were there, but this time they were joined by Doug Parker, the lead of the Angular CLI team. Unfortunately, it was also the last appearance of Jeremy Elbourn. He announced that he is leaving Google already in February. Jeremy Elbourn is the current Angular uber lead, which means he presides over the Angular projects - Material, framework, and the CLI. A successor has not been announced yet.

A very interesting side note: Jeremy was discussing the behavior of markForCheck on event listeners. So at the moment, a handled DOM event triggers change detection, and there was an internal discussion about changing that. The outcome was not to do it now, but to integrate that change once the "legendary" Signal Components come out. Signal Components were announced as a requirement for zoneless and were planned to land in Angular 17. But in the end, zoneless could be done without those kinds of changes, and Signal Components lost in terms of priority.

Using Dart in Angular had some negative consequences. It was there in the beginning but did not have the best impact on Angular's API. For example, Dart does not have types for DOM elements, and that's why nativeElement is any. Dart also does not have undefined, and that's why null shows up often in the older API.

ChangeDetection OnPush should become the default for Angular

Mark Thompson has published an RFC to set Angular's default change detection strategy to OnPush. The current one is called Default - probably not the best name.

OnPush means that when Angular synchronizes the state of our application with the DOM, a component under OnPush has to be marked as dirty in order to be checked for actual change. That dirty marking only happens if you have a handled user event, run markForCheck manually, use the async pipe, or - of course - if a Signal changes. A component that is not dirty also excludes its children from the change detection process.

Since Default is not the best name, it will get an alias called Eager, and that is already going to happen in Angular 21.2, which will be released later this month. The actual switch to OnPush as the default will happen in Angular 22.

As always, existing codebases will not be modified - safety first. As it was when standalone became the default, existing apps will get the explicit setting to ChangeDetectionStrategy.Eager (aka Default) via automatic migration.

RFC Discussion #66779

Ng-News 26/04: Micro Frontends at Google

ng-news — Sun, 08 Feb 2026 23:38:00 +0000

Doug Parker from the Angular team shared insights on Micro Frontends at Google — isolation, Protocol Buffers, and when to avoid the approach. This episode also covers the TypeScript Go rewrite progress, and Angular DevTools Signal Graph updates.

Micro Frontends at Google

Doug Parker was a guest at the Angular Meetup Graz, which was this time more a podcast. Doug is a member of the Angular team, focuses on the CLI, and talked about Micro Frontends at Google.

A little bit of context. Google has a monorepo, which means all applications are within one repository. That does not mean they use Micro Frontend architectures. In fact, there has been some information (also on ng-news) where we shared the Micro Frontend approach of Google's Cloud Console, which is based on a huge micro frontend architecture using an iFrame approach, which is not used anymore.

Instead, the new concept is to do Micro Frontends in complete isolation. In order to avoid collisions with shared dependencies, Google plays it safe. They do not share anything at all. So a very autonomous solution. When it comes to shared logic, they use Protocol Buffers, where a service is not really shared between micro frontends but more a messaging infrastructure. Another requirement is that they have the need to combine multiple frameworks together.

Doug's approach is to see Micro Frontends as a contract between apps. In the end, there is an interface that needs to be implemented and the infrastructure takes care of the integration.

There are no plans to open source the solution once it is finished.

When should Micro Frontends be used? Whenever the underlying problem could be solved in a different way, then try out that approach before Micro Frontends. For example build times could be improved in different ways.

If there are hard UX requirements, a micro-frontend approach might be hard to implement.

Lastly, very often Micro Frontends are used to reduce the communication between teams. One has to ask first, if this is actually the goal, or if the opposite approach, namely, where people need to talk with each other more, should be achieved.

Status Update on Go Rewrite of TypeScript

Last year, TypeScript announced that they are going to rewrite the compiler in Go, which should bring performance improvements that might be an order of magnitude, so about 10 times.

This undertaking takes some time and consumes obviously all the resources of the team. Push-based posted about the current state. We are coming closer and the upcoming version of TypeScript 6.0 will be the last one written in TypeScript.

The Angular team follows and has already started to make their codebase ready for v6 as well.

#angular #typescript #js | PushBased

TypeScript is changing forever! v6.0 will be the last JS-based release before the complete native Go rewrite in v7.0. TS Team is officially transitioning v6.0 into "Maintenance Mode" to focus on the port. 🔥 Major Breaking Changes to prepare for: - Strict by Default: 𝘀𝘁𝗿𝗶𝗰𝘁: 𝘁𝗿𝘂𝗲 is finally the default. - No More Legacy Modules: Support for 𝗮𝗺𝗱, 𝘂𝗺𝗱, and 𝘀𝘆𝘀𝘁𝗲𝗺𝗷𝘀 is being removed. - Modern Targets: 𝘁𝗮𝗿𝗴𝗲𝘁 defaults to 𝗲𝘀<𝗰𝘂𝗿𝗿𝗲𝗻𝘁 𝘆𝗲𝗮𝗿> (Evergreen). - Faster Builds: 𝘁𝘆𝗽𝗲𝘀 defaults to [ ] (stops auto-including every @𝘁𝘆𝗽𝗲𝘀 package). - Enum Merging: Removed. - Side Effects: 𝗻𝗼𝗨𝗻𝗰𝗵𝗲𝗰𝗸𝗲𝗱𝗦𝗶𝗱𝗲𝗘𝗳𝗳𝗲𝗰𝘁𝗜𝗺𝗽𝗼𝗿𝘁𝘀 defaults to 𝘁𝗿𝘂𝗲. The Goal? A 10x faster compiler, but it requires shedding legacy weight. Links: - Maintenance Mode (TS #62963): https://buff.ly/BRBTweG - Deprecation List (TS #54500): https://buff.ly/Tb7QyGl The Angular Team has started preparing for it too: https://buff.ly/Tb5KSBS #angular #typescript #js

linkedin.com

Angular PR #66578

Miscellaneous

The Angular DevTools provide a visualization of the Signal Graph. The latest version received an update and now gives a much better view on the resource, which in the end is a group of different Signals belonging together.

// Detect dark theme var iframe = document.getElementById('tweet-2015832104722911325-347'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2015832104722911325&theme=dark" }

New Conferences

Last but not least, ticket sales for Ng-India, India's largest Angular conference, have started.

ng-ind.com

And again, if you are organizing a conference, please reach out to us so that we can promote it here.

DEV Community: ng-news

Ng-News 26/16: OpenNG Foundation, spartan/ui

OpenNG Foundation

spartan/ui 1.0

AnalogJS in Storybook

ng-conf is ending

Ng-News 26/15: Angular 22

Stable resources and Signal Forms

@Service, injectAsync, and debounced()

Vitest and change detection

WebMCP

Community content

ng-neat GitHub

Ng-News 26/14: linkedSignal Write-Back, Error Boundaries

Angular 22 stabilization

Compiler ABI and micro frontends

linkedSignal set and delegatedSignal

PR Checklist

PR Type

What is the current behavior?

What is the new behavior?

Does this PR introduce a breaking change?

Other information

Google I/O: error boundaries

Ng-News 26/13: @Service, Native Federation, Angular Feature Lifecycles

Angular 22 preview: @Service and resource APIs

Feature lifecycle stages in Angular

Native Federation v4 updates

Oxc Angular compiler benchmarks and caveats

Ng-News 26/12: Future of Selectorless, Skills vs. MCP, Zoneless Testing

Angular Q&A: selectorless and Skills vs MCP

Zoneless testing and auto tick

Upcoming Conferences

Ng-News 26/11: TypeScript 6, NgRx RFCs delegatedSignal, Resource Extensions

TypeScript 6.0

NgRx RFCs

delegatedSignal()

Resource Extensions

Martina Kraus on security (Angular Plus Show)

Form validation: debouncing async validators

Alfredo Perez: SpecKit and SpecKit Companion

Angular Graz Meetup videos

Ng-News 26/10: Signality, Vitest 4.1, Angular Skills

Angular Space and ngxtension

Signality

Vitest 4.1 fake timers

Official Angular agent skills

Ng-News 26/09: AI & Angular, debounced() in v22, Oxidation Compiler in Analog

Angular XSS Advisory

Ng-Asia with Mark Thompson

Angular Q&A with Mark Thompson

Oxidation Compiler and Analog

Angular Roadmap Update

Angular NPM Downloads

Debounced API

Angular Vienna and Code Magazine

Ng-News 26/08: Angular 21.2

Signal Forms

Form Submission

Custom Control

SignalFormControl

ResourceSnapshot

CLI - Prettier Integration

Lambdas in Templates

Exhaustive Checks

ChangeDetectionStrategy.Eager

Sources and Thanks

Ng-News 26/07: Angular's Router, Vitest, Hashbrown, History & Popularity

Andrew Scott on Angular's Router

Younes Jaadi on Vitest

Manfred Steyer on Hashbrown and AI in Angular

State of JavaScript and Angular's popularity

Maximilian Schwarzmüller – 10 Years of Angular

Also in the News

Ng-News 26/05: OnPush as Default, Agent Skills, Q&A

Skills landing in Analog first, and now in Angular

Angular Q&A with the Angular team

ChangeDetection OnPush should become the default for Angular

Ng-News 26/04: Micro Frontends at Google

Micro Frontends at Google

`@Service`, `injectAsync`, and `debounced()`

linkedSignal `set` and delegatedSignal

Angular 22 preview: `@Service` and resource APIs

`delegatedSignal()`

`ResourceSnapshot`