![Rachel Andrew](https://web.dev/images/authors/rachelandrew.jpg) Rachel Andrew Technical Writer [GitHub](https://github.com/rachelandrew) [LinkedIn](https://www.linkedin.com/in/rachelandrew) [Mastodon](https://front-end.social/@rachelandrew) [Bluesky](https://bsky.app/profile/rachelandrew.bsky.social) [Homepage](https://rachelandrew.co.uk)

<br />


Published: December 3, 2025

<br />

Unless otherwise noted, the following changes apply to the latest Chrome beta
channel release for Android, ChromeOS, Linux, macOS, and Windows. To learn more
about these features, see the provided links or the list on ChromeStatus.com.
Download the latest version from
[Google.com](https://www.google.com/chrome/beta/) for desktop or from Google
Play Store on Android.

## CSS and UI

### CSS anchor positioning with transforms

If an anchor-positioned element is tethered to an anchor that has a transform
(or is contained by an element with a transform), the browser resolves
`anchor()` and `anchor-size()` functions against the bounding box of the
transformed anchor.

### CSS find-in-page highlight pseudos

Exposes *find-in-page* search result styling as the `::search-text`
pseudo-element, which is a highlight pseudo-element like those used for
selection and spelling errors. This lets you change the foreground and
background colors or add text decorations. This is especially useful if the
browser defaults have insufficient contrast with the page colors or are
otherwise unsuitable.

Learn more on the Igalia blog in [Find-in-Page Highlight
Styling](https://blogs.igalia.com/schenney/find-in-page-highlight-styling/).

### Don't use `aria-details` for anchor positioning

The code to create `aria-details` relationships for non-popover use cases of
anchor positioning was likely a mistake. Since popovers and other semantic
relationships *do* create `aria-details`, and the remaining use cases are likely
non-semantic, Chrome now doesn't create these relationships in the non-semantic
cases.

### `@scroll-state` scrolled support

Lets you style descendants of containers based on the most recent scrolling
direction.

Example:

```css
.scrolling-up {
  translate: 80px 0;
  transition: 0.4s translate;
}

html {
  container-type: scroll-state;
}

@container scroll-state(scrolled: top) {
  .scrolling-up { translate: 0 0; }
}
```

### Respect `overscroll-behavior` for keyboard scrolls

When you set `overscroll-behavior` to a value other than `auto`, the browser
shouldn't perform scroll chaining. Chrome respects this for mouse or touch
scrolling; however, keyboard scrolls ignored it. This change ensures keyboard
scrolling also respects `overscroll-behavior`.

### Respect `overscroll-behavior` on non-scrollable scroll containers

The `overscroll-behavior` property applies to all scroll container elements,
regardless of whether those elements have overflowing content or are user
scrollable. You can use `overscroll-behavior` to prevent scroll propagation on
an `overflow: hidden` backdrop or an `overflow: auto` element without needing to
consider whether it is overflowing.

### Non-tree-scoped `container-name` matching

The browser ignores tree-scope when matching `container-name` for `@container`
queries.

Previously, `container-name` matching for `@container` queries used tree-scoped
names or references. This meant the same name wouldn't match if the `@container`
rule and the `container-type` property originated from different trees, for
example, if the `container-type` declaration came from an inner shadow tree.

With this change, `container-name` values match regardless of the `@container`
rule or `container-type` declaration origins.

### SVG2 CSS cascading

Aligns the Chrome implementation with the SVG2 specification for matching CSS
rules in `<use>` element trees.

Selectors match against the `<use>` instantiation elements instead of the
originating element subtree. This means selectors no longer match ancestor and
sibling elements outside the cloned subtree. More importantly, state selectors
like `:hover` now match in `<use>` instances.

## Web APIs

### `XRVisibilityMaskChange`

Adds an `XRVisibilityMaskChange` event that provides a list of vertices and
indices to represent the mesh of the visible portion of the user's viewport.
This data can be used to confidently limit the amount of the viewport drawn to,
which improves performance. To better support this event, `XRView` objects are
also given unique identifiers to enable easier pairing with the associated
masks. This is an extension to the core WebXR specification.

### Expose `onanimationcancel` event to `GlobalEventHandlers`

CSS Animations Level 1 extends the `GlobalEventHandlers` interface, defined in
the HTML specification, by declaring four new event handlers:
`onanimationstart`, `onanimationiteration`, `onanimationend`, and
`onanimationcancel`.

Only the `onanimationcancel` event handler was missing from the
`GlobalEventHandlers` IDL.

For more information, see the [CSS Animations Level 1
specification](https://drafts.csswg.org/css-animations/#interface-globaleventhandlers)
and the [HTML specification's GlobalEventHandlers
section](https://html.spec.whatwg.org/multipage/webappapis.html#globaleventhandlers).

### View Transitions `waitUntil()` method

The `ViewTransition` automatically constructs a pseudo-element tree to display
and animate participating elements in the transition. Per the specification,
this subtree is constructed when the view transition starts animating and is
destroyed when the animations associated with all view transition
pseudo-elements are in the finished state (or more precisely, in a non-running,
non-paused state).

This works for a majority of cases and provides a seamless experience for
developers. However, for more advanced cases, this is insufficient because
developers sometimes want the view transition pseudo-tree to persist beyond the
animation finish state.

One example is tying view transitions with Scroll-Driven Animations. When the
animation is controlled by a scroll timeline, the subtree shouldn't be destroyed
when the animations finish because scrolling back can still animate the pseudo
elements.

To enable advanced uses of view transition, this intent adds a `waitUntil()`
function on the `ViewTransition` object that takes a promise. This promise
delays destruction of the pseudo-tree until it is settled.

### The `<geolocation>` element

Introduces the `<geolocation>` element, a declarative, user-activated control
for accessing the user's location. It streamlines the user and developer journey
by handling the permission flow and directly providing location data to the
site, often eliminating the need for a separate JavaScript API call.

This addresses the long-standing problem of permission prompts triggered
directly from JavaScript without a strong signal of user intent. By embedding a
browser-controlled element in the page, the user's click provides a clear,
intentional signal. This provides a better prompt user experience and,
crucially, a recovery path for users who have previously denied the permission.

> [!NOTE]
> **Note:** This feature was previously developed and tested in an [origin
> trial](https://developer.chrome.com/blog/rethinking-web-permissions) as the more generic `<permission>` element. Based on feedback from developers and other browser vendors, it has evolved into the capability-specific `<geolocation>` element for a more tailored and powerful developer experience.

### WebGPU: `subgroup_id` feature

The `subgroup_id` and `num_subgroups` built-in values are available when the
subgroups extension is enabled.

### WebGPU: Uniform buffer standard layout

Uniform buffers declared in WGSL shaders are no longer required to have 16-byte
alignment on array elements or to pad nested structure offsets to a multiple of
16 bytes.

### The Temporal API

The [Temporal API](https://github.com/tc39/proposal-temporal) in `ECMA262`
provides standard objects and functions for working with dates and times. `Date`
has been a long-standing issue in ECMAScript. `Temporal`, a global `Object` that
acts as a top-level namespace (for example, `Math`), bringing a modern date and
time API to the ECMAScript language. For a detailed breakdown of motivations,
see [Fixing JavaScript Date: Getting
Started](https://maggiepint.com/2017/04/09/fixing-javascript-date-getting-started/).

### Support `ping`, `hreflang`, `type` and `referrerPolicy` for `SVGAElement`

Adds support for `ping`, `hreflang`, `type`, and `referrerPolicy` attributes on
`SVGAElement`, aligning its behavior with `HTMLAnchorElement` for consistent
link handling across HTML and SVG.

### The `clipboardchange` event

The `clipboardchange` event fires whenever the system clipboard contents are
changed by a web app or any other system application. This lets web apps, for
example, remote desktop clients, keep their clipboards synchronized with the
system clipboard. It provides an efficient alternative to polling the clipboard
(using JavaScript) for changes.

### User-Agent Client Hints `ch-ua-high-entropy-values` permissions policy

Adds support for a `ch-ua-high-entropy-values` Permissions Policy that lets a
top-level site restrict which documents can collect high-entropy client hints
using the `navigator.userAgentData.getHighEntropyValues()` JavaScript API.

Restricting collection of high-entropy hints over HTTP is already possible with
existing per-client-hint Permissions Policies.

### Mirroring of RTL MathML operators

Adds support for character-level and glyph-level mirroring when rendering MathML
operators in RTL mode.

When using RTL mode, some operators can be mirrored by changing them to another
code point (for example, a right parenthesis becomes a left parenthesis). This
is character-level mirroring, with equivalences defined by Unicode's
`Bidi_Mirrored` property.

Some operators have no appropriate mirroring character. Glyph-level mirroring
applies in this case, with the `rtlm` font feature, where another glyph can
replace it in a mirrored context. Some existing implementations mirror the
original glyph directly, but this might change the meaning for asymmetrical
characters, such as the clockwise contour integral.

### Multicast Support for the Direct Sockets API for Isolated Web Apps

This feature lets Isolated Web Apps subscribe to multicast groups, receive UDP
packets from them, and specify additional parameters when sending UDP packets to
multicast addresses.

### Performance and Event Timing: `InteractionCount`

The Event Timing API is part of the Performance Timeline and measures the
performance of user interactions. Certain events have an `interactionId` value
assigned, which is useful for grouping related interactions based on common
physical user inputs or gestures.

This feature adds `performance.interactionCount`, which is the total number of
interactions that have occurred on the page.

In particular, this feature is useful for computing the Interaction to Next
Paint (INP) metric value, which requires knowing the total number of
interactions to compute a high percentile score (p98 for pages with more than 50
total interactions).

This feature has been specified for a long time, was prototyped in Chromium
previously but never shipped, is part of Interop 2025, and is already available
in other browsers.

> [!NOTE]
> **Note:** There is already a more powerful `performance.eventCounts` map for specific events, but it is not possible to accurately map event counts to interaction counts.

### Interoperable pointer and mouse boundary events after DOM changes

After an event target is removed from the DOM, the logical target of the
pointer, as implied by the Pointer and Mouse boundary events (that is, `over`,
`out`, `enter`, and `leave` events), must be the nearest ancestor still attached
to the DOM.

Chrome has been tracking a node even after it is removed from the DOM. As a
result, if the pointer moves to a new node B after the hit-test node A is
removed from the DOM, the boundary event sequence (`pointerover`, `pointerout`,
`pointerenter`, `pointerleave` events, and the corresponding mouse events)
implied a pointer movement from A to B. Per the new consensus, the event
sequence implies a pointer movement from the "parent of A" to B.

### Pointer Lock on Android

Provides access to raw mouse movement by locking the target of mouse events to a
single element and hiding the mouse cursor. The Pointer Lock API is already
supported on desktop, this launch is for support on Android.

### `RTCDegradationPreference` enum value `maintain-framerate-and-resolution`

`maintain-framerate-and-resolution` disables WebRTC's internal video adaptation.
This lets the application implement its own adaptation logic and prevents
interference from the internal adaptation.

### WebAuthn Signal API on Android and iOS

Allow WebAuthn relying parties to report information about existing passkeys
back to credential storage providers, so that incorrect or revoked credentials
can be updated or removed from provider and system UI.

This feature was already available on desktop, and is now shipping on Android
and iOS.

Also, the signal API now supports a safety mechanism for Google Password Manager
passkeys on all supported platforms. Previously, when a relying party signaled
that a credential was unknown or removed, the passkey was permanently deleted.
Now, Google Password Manager hides the passkey instead of deleting it. Passkeys
can be recovered by calling `signalAllAcceptedCredentials` with a list of
previously hidden passkeys.

## New origin trials

In Chrome 144, you can opt into the following [origin
trials](https://developer.chrome.com/docs/web-platform/origin-trials).

### Enhanced Canvas TextMetrics

Expands the `TextMetrics` Canvas API to support selection rectangles, bounding
box queries, and glyph cluster-based operations.

This functionality enables complex text editing applications with accurate
selection, caret positioning, and hit testing. Additionally, cluster-based
rendering facilitates sophisticated text effects, such as independent character
animations and styling.

## Deprecations and removals

This version of Chrome introduces the deprecations and removals listed in this
section. Visit ChromeStatus.com for lists of planned deprecations, current
deprecations, and previous removals.

### Deprecate the Topics API

The Topics API is an API to enable ad-targeting based on a user's general
browsing interests, without exposing their exact browsing history.

Following the
[announcement](https://privacysandbox.com/news/update-on-plans-for-privacy-sandbox-technologies/)
that Chrome will maintain its current approach to third-party cookies, we are
now deprecating and planning to remove the Topics API (along with certain other
technologies, as outlined on the [Privacy Sandbox feature status
page](https://privacysandbox.com/news/privacy-sandbox-next-steps/)).

### Deprecate the Protected Audience API

The Protected Audience API provides a method of interest-group advertising
without third-party cookies or user tracking across sites.

Following the
[announcement](https://privacysandbox.com/news/update-on-plans-for-privacy-sandbox-technologies/)
that Chrome will maintain its current approach to third-party cookies, we are
now deprecating and planning to remove the Protected Audience API (along with
certain other technologies, as outlined on the [Privacy Sandbox feature status
page](https://privacysandbox.com/news/privacy-sandbox-next-steps/)).

### Deprecate the Shared Storage API

The Shared Storage API is a privacy-preserving web API to enable storage that is
not partitioned by first-party site.

Following the
[announcement](https://privacysandbox.com/news/update-on-plans-for-privacy-sandbox-technologies/)
that Chrome will maintain its current approach to third-party cookies, the team
is deprecating and planning to remove the Shared Storage API (along with certain
other technologies, as outlined on the [Privacy Sandbox feature status
page](https://privacysandbox.com/news/privacy-sandbox-next-steps/)).

### Deprecate the Attribution Reporting API

The Attribution Reporting API is an API designed to measure ad conversions
without third-party cookies or user tracking across sites.

Following the
[announcement](https://privacysandbox.com/news/update-on-plans-for-privacy-sandbox-technologies/)
that Chrome will maintain its current approach to third-party cookies, the team
is planning to deprecate and remove the Attribution Reporting API (along with
other Privacy Sandbox APIs).

### Deprecate the Private Aggregation API

The Private Aggregation API is a generic mechanism for measuring aggregate,
cross-site data in a privacy-preserving manner. It was originally designed for a
future without third-party cookies.

Following the
[announcement](https://privacysandbox.com/news/update-on-plans-for-privacy-sandbox-technologies/)
that Chrome will maintain its current approach to third-party cookies, the team
is deprecating and planning to remove the Private Aggregation API (along with
certain other technologies, as outlined on the [Privacy Sandbox feature status
page](https://privacysandbox.google.com/overview/status)). This API is only
exposed through the Shared Storage and Protected Audience APIs, which are also
planned for deprecation and removal. Therefore, no additional work is required
for Private Aggregation.

### Deprecate Related Website Sets

Related Website Sets provide a framework for developers to declare relationships
among sites, to enable limited cross-site cookie access for specific,
user-facing purposes. This is facilitated through the use of the Storage Access
API and `document.requestStorageAccessFor` (see next section).

Following the
[announcement](https://privacysandbox.com/news/update-on-plans-for-privacy-sandbox-technologies/)
that Chrome will maintain its current approach to third-party cookies, we are
now deprecating and planning to remove Related Website Sets (along with certain
other technologies, as outlined on the [Privacy Sandbox feature status
page](https://privacysandbox.com/news/privacy-sandbox-next-steps/)).

### Deprecate document.requestStorageAccessFor

The `requestStorageAccessFor` API is an extension to the Storage Access API that
allows a top-level site to request access to unpartitioned ("first-party")
cookies on behalf of embedded sites. Browsers would have discretion to grant or
deny access, with mechanisms like Related Website Sets membership as a potential
signal. This would allow for use of the Storage Access API by top-level sites.

Following the
[announcement](https://privacysandbox.com/news/update-on-plans-for-privacy-sandbox-technologies/)
that Chrome will maintain its current approach to third-party cookies, we are
now deprecating and planning to remove `requestStorageAccessFor` (along with
certain other technologies, as outlined on the [Privacy Sandbox feature status
page](https://privacysandbox.com/news/privacy-sandbox-next-steps/)).

### Deprecate `savedTabGroups` as individual value in `SyncTypesListDisabled`

The
[SyncTypesListDisabled](https://chromeenterprise.google/policies/#SyncTypesListDisabled)
enterprise policy lets administrators disable the synchronization of the
`savedTabGroups` data type on desktop platforms. On mobile platforms, however,
Tab Groups synchronization is already managed by the `tabs` data type. To align
desktop behavior with mobile and simplify sync management, the individual
`savedTabGroups` data type is deprecated and is no longer an individually
customizable value within the
[SyncTypesListDisabled](https://chromeenterprise.google/policies/#SyncTypesListDisabled)
policy.

> [!WARNING]
> **Warning:** From Chrome 144, if your `SyncTypesListDisabled` policy disables either `tabs` or `savedTabGroups`, both data types are considered disabled. The `savedTabGroups` value is entirely removed from the list of supported data types for this policy. For administrators who have saved tab groups disabled and intend to keep this behavior, explicitly disable the `tabs` data type.

### Externally loaded entities in XML parsing

Chrome synchronously fetches external XML entities or DTDs and incorporates them
into parsing under specific circumstances. This functionality will be removed.

`http/tests/security/contentTypeOptions/xml-external-entity.xml` provides an
example: External entities can be defined in the trailing part of the `DOCTYPE`
statement and refer to resources that are synchronously loaded and included as
context when parsing XML.

Another syntax example is a `DOCTYPE` that, using the `SYSTEM` keyword followed
by a URL pointing to a DTD, contains additional entity definitions.

Such external load requests are passed up from the parser.

According to the [W3C XML specification](https://www.w3.org/TR/xml/#proc-types),
non-validating processors are not required to read external entities.

The team plans to deprecate loading of external entity definitions in XML
documents that don't use XSLT.