Experimental Chromium Web Platform Features

As agreed upon in the CSSWG issue here: https://github.com/w3c/csswg-drafts/issues/14052, the `flow-start` and `flow-end` keywords are needed for alignment in the case of placement reversals. In CSS Grid-Lanes, when placement ordering is reversed through `track-reverse` or `fill-reverse`, the `flow-start` keyword will indicate the starting edge of the container at which placement begins, while `flow-end` indicates the ending edge of the container at which placement ends. In the absence of any reversals, we expect `flow-start` to have the same meaning as `start`, and `flow-end` to have the same meaning as `end`. `flow-start/end` act as value aliases for `flex-start/end` and should be the canonical values.

Currently web developers cannot retry failed module loads, as these failures are being cached (and retries just result in immediate failures). This change to the module loading behavior enables failed module loads to be manually retried (e.g. by calling `import()` again), solving real developer (and user) pain when it comes to using modules over unstable networks.

Expose multiple HTML setting methods that provide a coherent story for dynamically inserting markup into an existing document. - Positional methods (before/after/append/prepend/replaceWith) that take HTML as argument, effectively replacing insertAdjacentHTML. - Streaming methods (stream{Append}HTML{Unsafe}) which return a WritableStream - Passing {runScripts} as part of SetHTMLUnsafeOptions, mimicking createContextualFragment behavior. - Supporting createParserOptions in trusted types, allowing trusted types to override scripting mode and sanitizer.

Adds the  WebTransportOptions.datagramsReadableType  constructor option. By default, incoming WebTransport Datagrams are exposed through a default  ReadableStream . Applications that require BYOB reading can request a readable byte stream by setting  datagramsReadableType: "bytes" .

Adds the  WebTransport.reliability  instance attribute and static WebTransport.supportsReliableOnly attribute. These APIs indicate whether the user agent supports WebTransport over exclusively reliable connections and whether an established session supports unreliable transport such as datagrams. In Chromium, reliability initially returns "pending" and changes to  "supports-unreliable" after an HTTP/3 WebTransport connection is established.  Since Chromium does not currently support HTTP/2 fallback,  WebTransport.supportsReliableOnly returns false; any successfully established session uses HTTP/3 and supports unreliable datagrams.

The EVP (email verification protocol) helps users create, access and recover accounts by providing cryptographic proof of ownership seamlessly rather than email OTPs manually.

Selects the element that initiated the navigation, whether it's a link/button/form. The element stays selected throughout the navigation.

The side attribute on the SVG <textPath> element places text on the opposite side of the path, equivalent to reversing the path direction. This lets authors label a shape's interior or exterior (e.g. text inside vs. outside a circular path) without duplicating or manually reversing path data.

Adds the modern WebTransport Datagram sending API. WebTransportDatagramDuplexStream.createWritable() creates independent WebTransportDatagramsWritable streams. Each writable has mutable sendGroup and sendOrder attributes for expressing relative priority among queued WebTransport data in the same send group. Chromium currently applies this ordering among Datagram writables. The implementation also reports the negotiated maximum outgoing Datagram payload size and discards oversized writes as required by the WebTransport specification.

CSS text-decoration-inset controls how far underlines, overlines, and line-through decorations are inset from or extended beyond text run edges. It supports auto, length, and percentage values, including one-value and two-value syntax for setting the start and end offsets. This lets developers adjust decoration spacing and create reveal effects with native text decorations instead of background gradients or additional elements. sampler: https://static.januschka.com/i-468928416/?asddsaasd MDN: https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/text-decoration-inset CL: https://chromium-review.googlesource.com/c/chromium/src/+/7748204

Extends the declarative `focusgroup` attribute to richer composite widgets. The new `itemcontrols` modifier (name pending bikeshedding) makes nested controls sequentially reachable only for the active item; `feed` models ARIA-style content streams; and `grid` provides two-dimensional focus navigation with configurable wrapping and flow. These additions reduce custom focus-management code for cards, chat threads, feeds, and grid-based UI.

Surfaces the abort reason, if one is provided, to the methods of the Response object and its ReadableStream, rather than just the fetch promise. This fills a gap in our compliance with the standard, surfacing the developer-supplied abort reason everywhere it is intended to.

Add support for passing a targetAddressSpace option in the WebSocket constructor. This allows developers to specify that a WebSocket connection to a public hostname should be treated as going to a "local" or "loopback" destination, matching the existing support on the Fetch API. The main use case is to offer an escape hatch to bypass mixed content restrictions for connecting to local servers that cannot yet support HTTPS (as Local Network Access permissions require a secure context). Example: A public site that connects to a local server can use a hostname to avoid needing manual configuration of the exact private IP address in use: `const ws = new WebSocket("ws://local-server.example", { targetAddressSpace: "local"}` This will flag the WebSocket connection as going to a local address, bypassing mixed content blocking when run in a secure context. The user must grant the site the local network permission for the WebSocket connection to succeed, and the hostname must resolve to a local IP address (otherwise it will be blocked). This builds on https://chromestatus.com/feature/5080055102439424 which adds an options bag to the WebSocket constructor.

Adds a <string> value to the text-overflow property. This allows web authors to specify a custom string (e.g., "(more)") to indicate that text has been clipped. This provides more design flexibility and can be used to create more user-friendly and context-aware overflow indicators.

Add support for passing an option bag (WebSocketInit dictionary) as the second argument to the WebSocket constructor. The option bag will initially support a "protocols" option, allowing developers to specify subprotocols (mirroring the existing protocols argument), and also serves as an extension point for future options. Before, this would be written `const socket = new WebSocket("wss://example.com:8080", "soap")`. After, this could also be written `const socket = new WebSocket("wss://example.com:8080", { protocols: "soap" })`. See https://github.com/whatwg/websockets/issues/42 and spec PR https://github.com/whatwg/websockets/pull/76 for this change.

The Web Speech API currently does not expose the acoustic timing bounds of recognized speech segments, making it difficult to associate transcribed text with media timelines or generate synchronized subtitle cues. We propose adding speechStartTime and speechEndTime (double, in seconds relative to stream start) attributes on the SpeechRecognitionResult interface.

Adds support for passing custom HTTP request headers via WebTransportOptions and inspecting server response headers through the WebTransport instance. This allows web applications to supply metadata, authentication tokens, and custom parameters during the initial CONNECT handshake and access server-provided headers once the connection is established.

When fetching rel=compression-dictionary links: - Use "compression-dictionary" as request destination. - Properly set request's mode, credentials, referrer and referrerpolicy. - Take into account crossorigin and referrer attributes form <link rel="compression-dictionary">.

Introduces a new Document-Policy value "js-profiling-mode=eager|lazy". Setting "js-profiling-mode=lazy" authorizes JS Self-Profiling capability without incurring immediate initialization overhead during page load. Related WICG PR : https://github.com/WICG/js-self-profiling/pull/87 Related discussion for more context: https://github.com/WICG/js-self-profiling/issues/86

Aligns Blink's dispatch timing for animation "transitionrun" event and media query "change" event with the spec, making the timing interoperable with Gecko and WebKit. More precisely, as per HTML window event loop specification, "transitionrun" events will be fired at Step 3.11 even for animations created earlier in the same iteration (instead of delaying them for a later iteration), and the media query "change" event will be fired at Step 3.10 before firing any pending animation events (instead of intermixing them with animation events at Step 3.11).

Gamepad API defines standard indices for 17 common gamepad buttons. The GamepadButton type attribute provides an alternate, interoperable identifier for common buttons that are not included in the standard set, like "trackpad".

Chrome 151 began deprecating support for unspecified presentation and issuance protocols in the **Digital Credentials API**; final removal is scheduled for Chrome 160. The Digital Credentials API was originally designed to be an opaque pipeline for arbitrary exchange protocols. In November 2025, the [FedID WG resolved](https://github.com/w3c-fedid/digital-credentials/issues/396) to change this so that the spec normatively referenced only a specific set of exchange protocols. The removal of support for arbitrary, opaque pipelines ensures that only verified protocols are used, enabling a more robust privacy and security threat model for identity verification. This change aligns Chromium with updated industry specifications that normatively reference only a specific set of exchange protocols.

Adds support for the alpha and colorspace attributes on <input type=color>, matching the WHATWG HTML specification. When enabled, the color input gains an alpha boolean attribute (allowing non-opaque colors) and a colorspace attribute (limited-srgb or display-p3), and its CSS color parsing and serialization are expanded to support any CSS color value rather than only opaque hex colors. Both attributes are gated behind a single runtime flag.

A TC39 proposal to add module `import … with { type: "text" }` statements to JavaScript. The import attribute loads text data as a string value.

Implement `getPathData()`, `setPathData()`, and `getPathSegmentAtLength()` on `SVGPathElement`, three methods that give developers structured, segment-level access to <path> data as simple ` {type, values} ` dictionaries. A `getPathData({normalize: true}) ` option reduces all commands to the absolute M, L, C, Z subset. ``` dictionary SVGPathSegment { required DOMString type; required sequence<unrestricted float> values; }; dictionary SVGPathDataSettings { boolean normalize = false; }; partial interface SVGPathElement { sequence<SVGPathSegment> getPathData(optional SVGPathDataSettings settings = {}); undefined setPathData(sequence<SVGPathSegment> pathData); SVGPathSegment? getPathSegmentAtLength(unrestricted float distance); }; ```

WebRTC Data Channels use the Stream Control Transmission Protocol (SCTP) over a Datagram Transport Layer Security (DTLS) association. The standard SCTP connection establishment requires a handshake that introduces latency. A new Internet draft specifies a method to accelerate the datachannel establishment by embedding the SCTP initialization parameters within the Session Description Protocol (SDP) offer/answer exchange. This reduces the time required to open a data channel by up to two network round-trip times.