Skip to contentSkip to footer

Experimental web platform features are not yet part of the official web platform specifications and are marked as "experimental" in Chromium.

Polypane ships with these features (and more) enabled by default. Other Chromium browsers let you enable these on a "flags" settings page.

New in Chromium 122 currentPolypane 18

  • Form Controls Vertical Writing Mode Direction Support

    CSS property writing-mode allow elements to go vertical, but users cannot set the direction in which value changes. With this feature, we are allowing the form control elements meter, progress and range input type to have vertical writing mode and choose the form control's value direction. If direction is rtl, the value is rendered from bottom to top. If direction is ltr, the value is rendered from top to bottom. For Web compatibility, we will slowly rollout the change in 123 and enable in stable in 124.

  • Keyboard Focusable Scrollers

    Improves accessibility by making scroll containers focusable using sequential focus navigation. Today, the tab key doesn't focus scrollers unless tabIndex is explicitly set to 0 or more. By making scrollers focusable by default, users who can't (or don't want to) use a mouse will be able to focus clipped content using a keyboard's tab and arrow keys. This behavior is enabled only if the scroller does not contain any keyboard focusable children. This logic is necessary so we don't cause regressions for existing focusable elements that might exist within a scroller like a <textarea>.

  • Media Capture Voice Isolation

    This is about adding support in Chrome for the VoiceIsolation getUserMedia constraint ( The constraint only takes effect on platforms where there is low-level support for voice-isolation style denoising. Currently this is limited to a selected number of ChromeOS devices, but further platforms will be added.

  • Stylable Select

    Allows <button> and <datalist> in <selectlist> which replace the default button and listbox respectively, as well as introducing a new <selectedoption> element that shows the chosen value.

  • Web Auth Allow Create In Cross Origin Frame

    This feature allows web developers to create WebAuthn[0] credentials (that is, "publickey" credentials, aka passkeys) in cross-origin iframes. Two conditions are required for this new ability: 1. The iframe has a publickey-credentials-create-feature permission policy. 2. The iframe has transient user activation. This will allow developers to create passkeys in embedded scenarios, such as after an identity step-up flow where the Relying Party is providing a federated identity experience. [0]:

  • New features in Chromium 122 with missing description
    App Title
    CSS Cross Fade
    CSS Text Spacing Trim
    Offset Mapping Unit Variable
    Performance Mark Feature Usage
    Top Level Tpcd
    Web Authentication Hints

New in Chromium 121

  • Align Content For Blocks

    `align-content` CSS property works for block containers and table cells. The property worked only for flex containers and grid containers. It supports block containers and table cells, that is to say `display: block`, `display: list-item`, `display: table-cell`, etc.

  • Auto Size Lazy Loaded Images

    Auto Sizes allows developers to set the sizes attribute to auto (sizes=auto) for lazy loaded image elements with srcset. For this use case the image's width and height should be provided. The browser will use the layout width of the image in order to select the source url from the srcset.

  • Boundary Event Dispatch Tracks Node Removal

    After an event target gets removed from the DOM, the logical target of the pointer as implied by the Pointer and Mouse boundary events (i.e. over, out, enter and leave events) should be the nearest ancestor still attached to the DOM. PEWG has recently reached consensus on this behavior, see Chrome has been keeping track of a node even after it gets removed from DOM. As a result, if the pointer moves to a new node B after the hit-test node A is removed from DOM, the boundary event sequence (pointerover, pointerout, pointerenter, pointerleave events and the corresponding mouse events) used to imply a pointer movement from A to B. As per the new consensus, the event sequence should imply a pointer movement from the "parent of A" to B.

  • Close Watcher

    "Close requests" are a new concept that encompasses user requests to close something currently open, using the Esc key on desktop or the back gesture/button on Android. Integrating them into Chromium comes with two changes: * CloseWatcher, a new API for directly listening and responding to close requests. * Upgrades to <dialog> and popover="" to use the new close request framework, so that they respond to the Android back button.

  • CSS Supports For Import Rules

    It allows to import stylesheets and layers conditioned on supports(). If the support() doesn't match, the import will not be fetched.

  • Mouse Drag On Cancelled Mouse Move

    Canceling mousemove will not prevent text selection or drag-and-drop. Chrome allowed cancelling mousemove events to prevent other APIs like text selection (and even drag-and-drop in the past). This does not match other major browsers; nor does it conform to the UI Event spec: Through this feature, the default-action of mousemove becomes none. Text selection and drag-and-drop can still be prevented through cancelling selectstart and dragstart events respectively, which are spec compliant and fully interoperable.

  • Navigation Activation

    navigation.activation stores state about when the current Document was activated (e.g., when it was initialized, or restored from the back/forward cache).

  • Private Network Access Null Ip Address

    We propose to block access to IP address Chrome is deprecating direct access to private network endpoints from public websites as part of the Private Network Access (PNA) specification ( Services listening on the localhost ( are considered private according to the specification ( Chrome's PNA protection can be bypassed using the IP address to access services listening on the localhost on macOS and Linux. This can also be abused in DNS rebinding attacks targeting a web application listening on the localhost.

  • Unrestricted Usb

    Enables trusted applications to bypass security restrictions in the WebUSB API. The WebUSB specification defines a blocklist of vulnerable devices and a table of protected interfaces classes that are blocked from access through WebUSB. With this feature, Isolated Web Apps with permission to access the "usb-unrestricted" Permission Policy feature will be allowed to access blocklisted devices and protected interface classes.

  • URL Pattern Has Reg Exp Groups

    Allows easy inspection of whether a URLPattern uses one or more ECMAScript regular expression groups, and therefore may not be suitable for use in cases where an ECMAScript engine is not available (such as some upcoming planned APIs). Strictly speaking this reflects back something developers could know anyway from inspecting the pattern, but having easy access to the UA's implementation of this check makes that more straightforward.

  • Web Preferences

    The Web Preference API aims to provide a way for sites to override the value for a given user preference (e.g. color-scheme preference) in a way that fully integrates with existing Web APIs.

  • New features in Chromium 121 with missing description
    Accessibility OS Level Bold Text
    Accessibility Serialization Size Metrics
    CSS Progress Notation
    Dynamic Scroll Cull Rect Expansion
    HTML Invoke Actions V2
    One Pass Raster Invalidation
    Ruby Inlinify
    Web Authentication JSON Serialization
    Web Authentication Supplemental Pub Keys
    Web Codecs Copy To RGB

New in Chromium 120 Polypane 17.1

  • Clipboard Supported Types

    Currently during async clipboard write operation, there is no way for the web authors to detect if a particular mime type is supported by the UAs or not before attempting to actually write the formats to the clipboard. This not only affects developer ergonomics as now web authors have to attempt to write to the clipboard first in order to find out whether write failed due to a particular mime type not supported by the UAs (or sometimes add version checks that are unreliable at best), but also leads to unnecessary cost in terms of CPU cycles, COGS etc in order to produce an expensive web custom format which may not be supported by a particular browser.

  • Clipboard Well Formed Html Sanitization Write

    Using DataTransfer object’s setData and async clipboard write method, there are interop differences in how the HTML content is sanitized and written to the clipboard. The Async clipboard writer API uses sanitizers to strip out content such as `<head>`, `<meta>`, `<style>`, `<script>` tags from the HTML and inline styles into the markup. In this proposal, writing to the clipboard for `text/html` MIME type using the navigator.clipboard.write() API will write a higher fidelity sanitized, well-formed HTML markup instead of a more strictly sanitized HTML fragment. It will also preserve the tags such as `<meta>`, `<style>`, `<head>` etc that were stripped out by the fragment parser. Roundtripping of HTML content using the async clipboard API within the web doesn’t change as the async clipboard read() method still produces a sanitized HTML fragment.

  • Css Field Sizing

    By 'field-sizing' property, web authors can disable fixed default sizes of form controls, and make their size depend on their content. It's very easy to provide automatically-growing text fields.

  • Fetch Later API

    fetchLater() is a JavaScript API to request a deferred fetch. Once called, the request is queued by the browser, and will be invoked in one of the following scenarios: • The document is destroyed. • After a certain time. The API returns a FetchLaterResult that contains a boolean field "activated" that may be updated to tell whether the deferred request has been sent out or not. On successful sending, the whole response will be ignored by browser, including body and headers. Nothing at all should be processed or updated, as the page may have already be gone. Note that from the point of view of the API user, the exact send time is unknown.

  • HTML Unsafe Methods

    The setHTMLUnsafe and parseHTMLUnsafe methods allow Declarative ShadowDOM to be used from javascript. In the future, they may also get new parameters for sanitization.

  • Media Session Enter Picture In Picture

    Adds an 'enterpictureinpicture' action to the Media Session API. Websites can register an action handler which can be used to open a Picture-in-Picture or Document Picture-in-Picture window.

  • Private Network Access Permission Prompt

    In order to establish connections to devices on a local network that do not have globally unique names, and therefore cannot obtain TLS certificates, this feature introduces a new option to `fetch()` to declare a developers' intent to talk to such a device, a new policy-controlled feature to gate each sites' access to this capability, and new headers for the server's preflight response to provide additional metadata.

  • Web Codecs Content Hint

    Adding a contentHint field to VideoEncoderConfig Content hint takes values that are already used for MediaStreamTrack: "motion", "text", "detail". This gives web developers a way to communicate to VideoEncoder the expected type video frames they intend to encode. Explainer:

  • New features in Chromium 120 with missing description
    CSS Text Auto Space
    HTML Invoke Target Attribute
    Media Capture Camera Controls
    Password Strong Label
    Permission Element
    Storage Access API Beyond Cookies
    Storage Buckets Durability
    Web App Scope Extensions

New in Chromium 119

  • Backdrop Inherit Originating

    The ::backdrop pseudo element used to inherit from initial values. That meant ::backdrop could not use custom property values unless specified directly on the ::backdrop rule. The specification has now changed so that ::backdrop inherits from the originating element, and with that the implementation.

  • Database

    Since M104 cookies newly created or updated with an expiration date would have that date capped at no more than 400 days in the future. This same limit will now be retroactively applied to cookies already in storage to cap their expiration dates to no more than 400 days after the first time Chrome M119+ starts up and does a one time database migration. The impact of this change will not be felt by users until at least 400 days after M119 is released, and then only for existing cookies that have not been updated in that period.

  • Font Palette Animation

    The CSS `font-palette` property allows selection of a specific palette used to render a color font. With the newly added support for animating this property, transitioning between palettes is no longer a discrete step, but becomes a smooth transition between two selected palettes. This works everywhere in CSS animations and transitions.

  • Highlight Inheritance

    With CSS Highlight Inheritance, the CSS Highlight pseudo classes, such as ::selection and ::highlight, inherit their properties through the pseudo highlight chain, rather than the element chain. The result is a more intuitive model for inheritance of properties in highlights. Specifically, "When any supported property is not given a value by the cascade ... its specified value is determined by inheritance from the corresponding highlight pseudo-element of its originating element’s parent element." (

  • HTML Select Element Show Picker

    Developers have been asking for a way to programmatically open the option picker of a select element. See This is currently impossible in almost every browser. Providing showPicker() gives developers a supported way to do this. Following the pattern of input.showPicker().

  • Intersection Observer Scroll Margin

    Intersection Observer scrollMargin allows developers to observe targets inside nested scroll containers that are currently clipped away by the scroll containers. This is achieved by expanding the container's clipping rect by the scrollMargin when calculating the intersection.

  • Page Reveal Event

    The `pagereveal` event is fired on a Document's window object at the first render opportunity after a Document is: initially loaded, restored from the back-forward cache, or activated from a prerender. It can be used by a page author to setup a page entry UX - such as a ViewTransition from a previous state. This feature is split out from the larger ViewTransition-on-Navigation project.

  • This experiment exposes a temporary set of APIs which provide access to browser-determined treatment and control groups to support opt-in server side testing of the third-party cookie deprecation.

  • New features in Chromium 119 with missing description
    Css Form Sizing
    Exclude Broken Image Icon From Being Lcp Eligible
    Hit Test Opaqueness
    Navigate Event Source Element
    Observable API
    Scoped Custom Element Registry
    Set Sequential Focus Starting Point
    Web Assembly JS String Builtins

Build your next project with Polypane

  • Use all features on all plans
  • On Mac, Window and Linux
  • 14-day free trial – no credit card needed
Try for free
Polypane screenshot