Published: April 8, 2026
Unless otherwise noted, the following changes apply to the newest Chrome beta channel release for Android, ChromeOS, Linux, macOS, and Windows. Learn more about these features by using the provided links or by visiting ChromeStatus.com. Chrome is in beta as of this release. You can download the latest beta version from Google.com for desktop or from Google Play Store on Android.
CSS and UI
Name-only container queries in CSS
You can now query a CSS container based only on its container-name
without setting a container-type on the element.
#container {
container-name: --foo;
}
@container --foo {
input { background-color: green; }
}
<div id="container">
<div><input></div>
</div>
Clip text overflow on user interaction
When a user interacts (for example, by editing or using caret navigation) with
text that has text-overflow: ellipsis set, the text temporarily switches from
ellipsis to clip. This lets the user see and interact with the hidden overflow
content. This feature applies to all editable and non-editable elements. For
form controls, such as <textarea> and <input>, this behavior is already
supported.
Correctly set dropEffect for dragEnter, dragLeave, and dragOver events
The drag and drop specifications require the dataTransfer object's
dropEffect attribute to have certain predetermined values on dragEnter,
dragOver, and dragLeave. dragEnter and dragOver should have a
dropEffect based on the current effectAllowed. dragLeave should always
have a none dropEffect. Currently, Chrome doesn't adhere to these rules.
From Chrome 148, Chrome will respect the specification and
assign the correct values to this attribute.
Lazy load video and audio elements
This feature adds the loading attribute to <video> and <audio> elements.
This lets developers defer media resource loading until the element is near the
viewport by using loading="lazy". This matches the existing lazy loading
behavior for <img> and <iframe> elements, which improves page load
performance and reduces data usage.
CSS at-rule() function for feature detection
This feature adds an at-rule() function to CSS @supports, which lets authors
feature-detect support for CSS at-rules.
Add the revert-rule keyword
The revert-rule keyword rolls back the cascade to the previous rule, similar
to how revert-layer rolls back the cascade to the previous layer. For example:
div { color: green; }
div { color: revert-rule; /* Effectively green */ }
This is especially useful with conditionals because it lets you eliminate the current rule if a condition is not met:
div {
display: if(style(--layout: fancy): grid; else: revert-rule);
}
Support text-decoration-skip-ink: all
This feature adds support for the all value for the CSS
text-decoration-skip-ink property.
The text-decoration-skip-ink property already supports auto and none. The
all value extends this by unconditionally applying ink-skipping to all glyphs,
including CJK characters. In contrast, auto leaves CJK characters un-skipped
because ink-skipping tends to produce undesirable visual results for ideographic
scripts at typical underline positions. With text-decoration-skip-ink: all,
authors who have adjusted text-underline-position or text-underline-offset
to avoid clashing with CJK glyphs can explicitly opt in to ink-skipping for
those characters.
Web APIs
Localize manifest members
This feature supports localization of manifest members, which lets apps adapt their names, descriptions, icons, and shortcuts to the user's language and region. Developers provide localized values in the web app manifest. The browser automatically selects the appropriate resources based on the user's language settings, which introduces language support across different markets.
Support Open Font Format avar2 for text shaping and glyph rendering
Version 2 of the avar (Axis Variations) table lets font designers create
variable fonts with better control over interpolation. While the original
variable font specification handles axes independently, avar2 lets axes
influence one another. This results in fonts that are easier for content authors
to use and enables compact storage.
Avar2 works by using the same familiar concepts of font variations, but it
lets you apply variable delta values to the design axes themselves. You can do this over a range of multiple axes.
For example, you can create meta sliders that control multiple variation axes at once. This alleviates the user from fine-tuning and finding a useful corner of the font's design space.
Avar2 gives font designers better control over the usable variation space of
their font and lets them coordinate the adjustment of design axes across several
axes. By defining the relationships between axes mathematically within the avar
version 2 table, fonts can achieve complex designs with fewer masters. This
leads to smaller file sizes because the interpolation is stored more
efficiently.
Web Authentication Immediate UI mode
This new mode for navigator.credentials.get() causes the browser sign-in UI to
display to the user if a passkey or password for the site is immediately known
to the browser. Otherwise, it rejects the promise with NotAllowedError if no
such credential is available. This lets the site avoid showing a sign-in page if
the browser can offer a choice of sign-in credentials that are likely to
succeed. It still allows a sign-in page flow for cases where no such
credentials exist.
Web Serial API support on Android
The Web Serial API provides an interface for connecting to serial devices. These devices can connect through a serial port on the user’s system or through removable USB and Bluetooth devices that emulate a serial port. The API is now supported on Android.
Users, especially in the educational, hobbyist, and industrial sectors, connect peripheral devices to their computers that require custom software to control. For example, robotics are often used to teach computer programming and electronics in schools. This requires software that can upload code to a robot or control it remotely. In an industrial or hobbyist setting, a piece of equipment, such as a mill, laser cutter, or 3D printer, is controlled by a program running on a connected computer. These devices are often controlled by small microcontrollers through a serial connection.
WebGPU linear_indexing feature
This functionality adds two new compute shader built-in values to improve user experience. These values are implemented for all backends (as polyfills of existing built-in values).
SharedWorker support on Android
For a long time, SharedWorker has been disabled on Android due to concerns
about its unpredictable process lifecycle. Chrome developers believed that
SharedWorker instances might terminate unexpectedly without notifying users or
web developers. This was considered unacceptable.
However, a recent discussion on GitHub
suggests that the unpredictable
nature of SharedWorker's process lifecycle might not be as significant an
issue as previously thought. Based on this, Chrome is re-enabling
SharedWorker on Android while simultaneously investigating this behavior to
ensure a stable and reliable experience.
Extended lifetime for shared workers
This update adds a new option, extendedLifetime: true, to the SharedWorker
constructor. This requests that the shared worker remains active even after all
current clients have unloaded. The primary use case is to let pages perform
asynchronous work that requires JavaScript after a page unloads, without needing
to rely on a service worker.
Prompt API
The Prompt API gives web developers direct access to a browser-provided on-device AI language model. The API design offers fine-grained control, aligned with cloud API shapes. This lets you progressively enhance sites with model interactions tailored to individualized use cases. This complements task-based language model APIs (for example, Summarizer API) and varied APIs and frameworks for generalized on-device inference with developer-supplied ML models. The initial implementation supports text, image, and audio inputs, as well as response constraints that ensure generated text conforms with predefined regular expression and JSON Schema formats.
This supports a variety of use cases. For example, it can generate image captions, perform visual searches, transcribe audio, classify sound events, generate text following specific instructions, and extract information or insights from multimodal source material.
This API has already been shipped in Chrome Extensions. This intent tracks the
shipping on the web. An enterprise policy,
GenAILocalFoundationalModelSettings, is available to disable the underlying
model downloading, which renders this API unavailable. Enterprise admins can
also set the BuiltInAIAPIsEnabled policy to block Built-In AI API usage while
still permitting other on-device GenAI features.
Language support log:
- Chrome 139 and earlier supported only English (
'en') - Chrome 140 added support for Spanish and Japanese (
'es'and'ja')
Get Secure Payment Confirmation capabilities
This feature adds a new static method to the Payment Request API that lets web developers get the capabilities of the browser's implementation of Secure Payment Confirmation. This helps web developers know what capabilities are available for Secure Payment Confirmation. They can then decide whether to use Secure Payment Confirmation with those capabilities.
IDNA ContextJ rules
IDNA is the mechanism for non-ASCII characters in domain names. It encodes a URL
like http://네이버.한국/ as http://xn--950bt9s8xi.xn--3e0b707e/ (a redirect to
naver.com).
The URL specification sets the CheckJoiners flag, which enables the ContextJ
rules in IDNA2008. This disallows ZWNJ (U+200C ZERO WIDTH NON-JOINER) and ZWJ (U+200D ZERO
WIDTH JOINER) in most places in URLs. The implementation passes the
UIDNA_CHECK_CONTEXTJ option to ICU, where this rule is implemented.
Reuse no-store images on same-src reassignment
This feature lets same-document available-image reuse bypass Cache-Control:
no-store reload when the same src value is reassigned to an <img> element.
Previously, Blink re-fetched the image even though it was already decoded and
available in the document. This aligns with existing Gecko and WebKit behavior.
Add the contentType field to Resource Timing
This feature adds the contentType field to PerformanceResourceTiming to hold
a string that corresponds to the content type of the fetched resource, as
returned by the server.
Suppress pointer events on drag start
According to the HTML specification, when a drag starts, the user agent should
send the appropriate events to the drag source to indicate that the pointer
event stream has ended and that it shouldn't expect any more events from this
pointer. This code was partially implemented for mouse events and fully
implemented for touch drags on Android. With this feature, Chrome aims to fully
satisfy this specification requirement on all other platforms. Practically, this
means that after a drag has started, the drag source will now receive the
pointercancel, pointerout, and pointerleave events to indicate that the
current event stream has finished.
WebRTC Datachannel: Always negotiate data channels
This feature implements a WebRTC extension, alwaysNegotiateDataChannels, which
defines a way for an application to negotiate data channels in an SDP offer
before creating a datachannel. This also negotiates the data m= section before
any audio or video m sections and uses it as the 'offerer-tagged m= section'
for [BUNDLE].
This means that if you create an RTCPeerConnection with
alwaysNegotiateDataChannels: true and then call createOffer(), it creates an
offer with an application m-line in the SDP. For example:
const pc = new RTCPeerConnection({
alwaysNegotiateDataChannels: true});
const offer = await pc.createOffer();
If you also add an audio transceiver and a data channel, the offer negotiates an application m-line followed by an audio m-line in the SDP:
const pc = new RTCPeerConnection({
alwaysNegotiateDataChannels: true});
pc.addTransceiver('audio');
pc.createDataChannel('somechannel');
const offer = await pc.createOffer();
New origin trials
In Chrome 148, you can opt into the following new origin trials.
Agentic Federated Login
A set of FedCM extensions to help agentic browsers safely log users in to websites using their federated accounts.
Connection Allowlists
Connection Allowlists is a feature designed to provide explicit control over external endpoints by restricting connections initiated through the Fetch API or other web platform APIs from a document or worker. The proposed implementation distributes an authorized endpoint list from the server through an HTTP response header. Before the user agent establishes any connection on behalf of a page, the agent evaluates the destination against this allowlist. Connections to verified endpoints are permitted, while those failing to match the entries in the list are blocked.
Container Timing
The Container Timing API lets you monitor when annotated sections of the DOM are
displayed on screen and have finished their initial paint. You can mark
subsections of the DOM with the containertiming attribute (similar to
elementtiming for the Element Timing API) and receive performance entries when
that section has been painted for the first time. This API lets you measure the
timing of various components in your pages.
Declarative CSS module scripts
Declarative CSS Module Scripts are an extension of the existing script-based CSS
Module Scripts. They let developers share declarative stylesheets with shadow
roots, including declarative shadow roots. Developers can define inline style
modules with <style type="module" specifier="foo"> and apply a declarative
module to a declarative shadow DOM by referencing specifier or a URL, such as
<template shadowrootmode="open" shadowrootadoptedstylesheets="foo">.
HTML-in-canvas
HTML-in-canvas is a new API that lets you customize render DOM elements
directly into a canvas or WebGL / WebGPU texture while maintaining interactivity
and accessibility of the content. It has three parts:
an attribute to opt-in canvas elements (layoutsubtree),
methods to draw child elements (2d: drawElementImage,
webgl:texElementImage2D, webgpu: copyElementImageToTexture),
and a way to update the transform of the element correctly
on the screen for interactivity.
Long Animation Frames style duration
This feature adds styleDuration and forcedStyleDuration information to the
Long Animation Frame API. This lets developers distinguish style and layout
times.
OpaqueRange
OpaqueRange represents a live span of text within a form control's value
(for example, a <textarea> or text <input>),
so developers can work with value text using range-like APIs.
It enables operations like getBoundingClientRect(), getClientRects(),
and use with the CSS Highlights API for UI such as inline suggestions,
highlights, and anchored popovers. It preserves encapsulation by exposing only
value offsets (and returning null for startContainer and endContainer),
so DOM endpoints and internal structure aren't exposed.
Parse processing instructions in HTML
Processing instructions (syntax: <?target data>) are an existing DOM
construct, exposed in XML. This construct lets node objects that are not
elements have semantic meaning for the processing of a document. For example,
you can use them to denote ranges for streaming or highlighting without
requiring new DOM elements and changing the DOM structure as far as CSS is
concerned. You can also use them as directives for the HTML parser about how to
buffer and stream.
Permissions Policy: focus-without-user-activation
This policy gives embedders control over programmatic focus from embedded
content through the focus-without-user-activation permissions policy. When the
policy is denied for a frame, programmatic focus calls (element.focus(),
autofocus, window.focus(), dialog.showModal(), and popover focusing) are
blocked unless triggered by user activation. User-initiated focus, such as
clicking or tabbing, is never affected. You can set the policy through a
Permissions-Policy HTTP response header or the iframe allow attribute. Focus
delegation is supported. A parent frame that has focus can programmatically pass
focus to a child iframe, even if the child has the policy denied. Once a frame
has focus, it can move focus within its own subtree.
Prompt API sampling parameters
This feature adds sampling parameters to the Prompt API. These parameters
control how tokens are sampled from the model, which gives developers control
over the creativeness or randomness of the output. Additionally, it adds
attributes to the LanguageModel instance to read the set values. It also adds
a static LanguageModel function to get the default and maximum values of these
parameters. The first implementation adds temperature and topK parameters.
Web app HTML install element
This feature lets a website declaratively prompt users to install a web app. The element optionally accepts two attributes, which lets you install content from a different origin.