1. Partial and Incremental Hydration: A Smarter Loading Strategy

The Angular team has continued to invest heavily in hydration improvements. While standard hydration has been available for some time, version 19 pushes things further with support for partial and incremental hydration. These approaches target developer experience by ensuring critical deferred components get loaded before anything else, which translates into better initial rendering performance. Learn more here

Incremental hydration goes beyond what partial hydration offers. With this technique, developers can hold off on loading specific parts of deferred components until certain triggers occur or users interact with the page. Because only the essential JavaScript ships upfront, additional functionality loads on demand—say, when someone hovers over an element or clicks a button. Users perceive the app as faster, and the overall experience feels more fluid.

2. Standalone Components: Now the Default

Standalone components are a solid choice when you want better code reuse and improved application throughput. Before Angular 14, every component had to live inside a module. That requirement produced quite a bit of repetitive boilerplate and generated avoidable overhead. Standalone components, introduced in that release, bundle both the component logic and its dependencies together, making module declarations unnecessary.

Angular 19 is expected to turn standalone into the default configuration. New components you generate will automatically be standalone unless you explicitly opt out. If you need a component tied to a module, you'll set standalone: false during creation. This change trims structural complexity and makes it easier to share components across different areas of your application.

3. Zoneless Change Detection

Change detection in Angular has evolved considerably over the years. Zone.js served well in the framework's early days, but it came with trade-offs—added performance costs and larger bundles. As an alternative, Angular is pushing forward with zoneless change detection, an experimental feature enabled through provideExperimentalZonelessChangeDetection(). Read more about it here.

Removing zone.js brings three noteworthy advantages:

  • Improved Performance: Anticipate quicker first paints and snappier application behavior overall.
  • Smaller Bundle Sizes: Less overhead means lighter payloads, which speeds up downloads.
  • Simpler Debugging: Without Zone.js in the picture, tracing and fixing issues becomes more straightforward.

4. linkedSignal: Reactivity Gets an Upgrade

linkedSignal introduces a new reactive primitive for Angular applications. It enables the creation of writable signals whose values automatically stay in sync with changes from a source signal. Data flow becomes more direct, and users enjoy a more responsive interface. The deep dive is covered in this article.

The expected API surface for Angular 19 includes several overloads:

  • linkedSignal with Source and Computation: Pair a source signal with a computation function that yields the linked signal's updated value.
  • linkedSignal Shorthand Version: A compact syntax for creating linked signals, keeping code shorter and easier to maintain.

5. Resource and rxResource APIs: Cleaner Data Handling

Dealing with asynchronous data often gets messy. Angular 19 brings experimental resource and rxResource APIs to improve this workflow. Both offer a common pattern for retrieving data, with promises used by resource and Observables for rxResource. Here's the breakdown:

Resource API: This interface exposes three core properties:

  • status: Describes the resource's present state (e.g., loading, success, or error).
  • value: Contains the data once the request completes successfully.
  • error: Holds an error callback for issues encountered during retrieval.

rxResource API: Built on Observables, this variant manages async retrieval well, simplifying data streams and providing clean error handling.

Collectively, these APIs aim to make working with asynchronous data in Angular feel much more natural.

Here you can find more information about resource and rxResource API.

The list above covers just a fraction of what Angular 19 has in store. With clear priorities on DX and performance, this release looks set to enhance developer workflows and deliver swifter, more responsive applications. Watch for the official release to see everything in action.