Ng-News: Angular in 2025

At the forefront this year were the refinement of the Signal ecosystem—particularly the Resource API and Signal Forms—alongside the significant push into AI.

On top of that, we introduced a fresh format for this episode. Share your thoughts with us in the comment section on YouTube or right here.

Signal Forms

The big headline is Signal Forms, and they're still quite new on the scene. Announced back at ng-Poland in 2024, a whole year went by before they finally shipped in Angular 21.

The anticipation for Signal Forms was significant. Forms are crucial for enterprise apps; one could argue that a frontend is essentially a bunch of forms stitched together.

Both template-driven and Reactive forms are replaced by Signal Forms. They bring together the strengths of the prior approaches but with a contemporary, signal-driven twist. In the old template-driven setup, the form would alter the data structure you supplied directly. With Signal Forms, that data now has to live inside a Signal.

Validation follows the Reactive forms pattern: it's set up in TypeScript. Yet, this new validation system outshines its predecessor dramatically. There's virtually no restriction on what you can accomplish with it.

Handling custom controls becomes simpler, too. The awkward ControlValueAccessor interface is a thing of the past. Instead, you wire up a value property through the model function, and you're done.

Although Signal Forms carry the experimental label, the Angular team has indicated that this status will be lifted in the near future.

Below is a full demonstration

type UserData = {
  id: number;
  firstname: string;
  lastname: string;
  subscribe: false;
};

@Component({
  selector: 'app-button-checkbox',
  template: `
    @if (value()) {
      <button (click)="value.set(true)">Subscribe to Newsletter</button>
    } @else {
      <button (click)="value.set(false)">Unsubscribe from Newsletter</button>
    }
  `,
})
export class ButtonCheckbox implements FormValueControl<boolean> {
  value = model.required<boolean>();
}

@Component({
  template: `<form>
    <input [field]="userForm.id" type="number" />
    <input [field]="userForm.firstname" />
    <input [field]="userForm.lastname" />
    <app-button-checkbox [field]="userForm.subscribe" />
  </form>`,
  imports: [Field, ButtonCheckbox],
})
export class UserForm {
  private readonly userData = signal<UserData>({
    id: 1,
    firstname: 'John',
    lastname: 'Smith',
    subscribe: false,
  });
  protected readonly userForm = form(this.userData, (path) => {
    required(path.id, { message: 'Id is required' });
    required(path.firstname, { message: 'Firstname is required' });
    required(path.lastname, { message: 'Lastname is required' });
  });
}

The Resource API

The resource function made its debut in version 19 (late 2024), yet it wasn't until the 19.2 minor update that we saw the arrival of the third primitive: httpResource.

Whenever a Signal hinges on an asynchronous operation, the resource steps in to fill the void. Since that operation is frequently an HTTP Request, the httpResource becomes indispensable.

Under the hood, httpResource relies on the HttpClient — so all interceptors function exactly as they always have. That doesn't imply everyone is tied to the HttpClient, though. When you're working with a data client service (generated via OpenAPI) that exposes an Observable, rxResource is your go-to alternative.

Angular 20 brought a final polish to these resources. Now, accessing a value while in an error state triggers an error, and the status values have been tightened into strict union types. Much like Signal Forms, the resources remain in an experimental phase. The hope is that this changes soon — possibly even with a minor release of version 21.

const page = signal(0);
const pageSize = signal(10);

const holidays = httpResource(
  () => ({
    url: '/holidays',
    params: { page: page(), pageSize: pageSize() },
  }), // similar to httpClient.get('/holidays', { params: { ... } })
  {
    defaultValue: [],
    parse: parseHolidays,
  },
);

AI

Naturally, there was a substantial surge of effort in this area.

At its core, we received an MCP Server, one that consistently gets better with every iteration. Its key function is to give the LLM guidance for creating up-to-date Angular code—incorporating Signals, template control syntax, and standalone components.

The connection goes beyond that, though. The team is investigating what a next-gen framework must offer to support an "AI-ready" ecosystem. This means making APIs easier for agents to navigate, not just for developers. To track progress, they've adopted several evaluation methods and built a dedicated Codegen Scorer.

Another plus was the major progress Gemini (Google’s own language model) has demonstrated recently. For the Angular team, being situated within a larger organization that prioritizes AI provides strategic advantages and easy access to the tools and resources needed for collaboration.

On the flip side, focusing so heavily on AI means that some other features may have received less attention than we might have hoped.

Miscellaneous

Zoneless

Beyond the headline features, there were more updates. Zoneless didn't just reach stability—it also became the default in Angular 21. Looking at the journey from initial developer experience to a stable default, it all happened within a single major release.

Vitest

Speed was also the theme for Vitest, which bypassed both "developer preview" and "stable" stages, going straight from experimental to default in Angular 21. This means we finally have a serious testing tool and no longer need to envy other frameworks.

@angular/aria

Next, there was @angular/aria. It fits with the current push for owning your UI components while still relying on the framework for behavioral details. That is precisely what @angular/aria delivers—a collection of directives ensuring solid accessibility out of the box.

Deprecation of @angular/animations

Wrapping up the changes, we saw a deprecation for @angular/animations. There is no longer any need for a dedicated package or that intricate DSL. Simpler animation capabilities are now built into the template itself, using animate.enter and animate.leave for entry and exit transitions directly alongside your markup.

Statistics & Perception

Looking at download numbers, the so-called "Angular Renaissance" has not produced any sudden surge. While downloads are climbing, the growth is gradual.

Overall, community sentiment around Angular has flipped back to favorable. But lasting effects won't be immediate. Our primary audience, enterprises, are cautious adopters. Many are holding off on upgrades until "Modern Angular" is fully fleshed out.

Outlook 2026

That leads us to looking ahead. So, what's on the table for 2026?

My hope and expectation is that Signal Forms and the Resource API will both reach stable release.

A year ago, I predicted Selectorless components and a fresh Authoring Format. Since 2025 didn't deliver either, I'm carrying those predictions forward. With "Selectorless," you'd reference a component class directly in the template with just one import. As for the authoring format—there's no clear answer yet. It might turn out to be Signal Components, a pivot from classes to functions, or something we haven't considered. Time will tell.

Ng-News in Spanish and Portuguese

Finally, ng-news is now offered in Spanish and Brazilian Portuguese. I'm thrilled that creators from Latin America reached out and joined the effort. These are dedicated YouTube channels, and I'm optimistic about adding more languages in the coming year.

https://www.youtube.com/@ng-news-es

https://www.youtube.com/@ng-news-BRAZIL

With that, another year of ng-news looks promising. A big thank you—especially for those who share, like, and recommend it to their peers. That support is what keeps ng-news going.

Wishing you all a prosperous and healthy New Year.