Firefox

Allows DOM requests (such as fetch requests) to be aborted if desired.

A Strict & highly optimizable subset of JavaScript that can be used as a low-level compile target.

Async functions make it possible to treat functions returning Promise objects as if they were synchronous.

Allows read and write access to the contents of the system clipboard; can be used to implement cut, copy, and paste features within a web application.

A royalty-free format created by the Alliance for Open Media, designed for effective video delivery on the open web. Firefox currently supports AV1 on Windows only, but more support will follow soon.

Provides one-off and periodic synchronization for Service Workers with an onsync event.

A policy that stops audio content from autoplaying on web pages unless it is initiated by a user gesture (e.g. a click event).

Allows real-time video capture of the surface of the canvas.

This API lets a website request credentials from a user agent and helps it store these credentials for future use.

Applies filter effects to elements below the target element.

Extends the use of CSS Box Alignment properties beyond CSS Grid and Flexbox layouts, to any block layout.

Defines a shape as a clipping region over an element. Only the parts of the element inside the clipping region are displayed.

The contain property allows an author to indicate that an element and its contents are, as much as possible, independent of the rest of the document tree. This allows the browser to recalculate layout, style, paint, size, or any combination of them for a limited area of the DOM and not the entire page.

A way to define and use variables that can be used in place of any CSS property.

Provides a native clearfix solution that doesn't rely on extra markup and CSS hacks.

Allows the creation of environment variables in CSS, which are global to a particular document, unlike custom properties.

Determines how a font face is displayed based on whether and when it is downloaded and ready to use.

Provides low-level control over OpenType or TrueType font typographic features.

Controls how blocks break between pages and columns.

A two-dimensional grid-based layout system, optimized for user interface design.

A CSS property providing styling for dropped, raised, and sunken initial letters.

Provides the ability to control layout through logical, rather than physical, direction and dimension mappings, e.g. inline-start and inline-end rather than left and right.

Allow authors to animate graphical objects along an author-defined path. The associated properties are now named <code>offset-*</code>, not <code>motion-*</code>.

Allows content to be broken across multiple columns, like a book index or a newspaper layout.

Allows you to control the browser's scroll overflow behavior — what happens when the boundary of a scrolling area is reached.

Used to detect if the user has enabled their system's setting for minimizing the amount of animation or motion it uses.

Adjusts the scroll position to prevent visible jumps (or "reflows") when content changes above the viewport. The "overflow-anchor" property is also introduced as a way to disable this behavior.

Provides a way to define "snap positions", which enforce the scroll positions that elements should stop at when they have finished scrolling.

Provides CSS properties for customizing the width and color scheme of webpage scrollbars.

Specifies different ways to define a shape on a floated element; wrapping text then wraps round the shape rather than following the rectangle of the element's box, allowing for interesting text layout effects.

Allows an animation to occur in equidistant steps, rather than a smooth motion. Formerly frames().

Allows a CSS grid nested inside another CSS grid to be connected to its containing grid; all browsers left this feature out of their initial grid implementation.

Allows for the definition of custom HTML elements.

Provides access to device's physical orientation.

Provides semantics for marking up modal dialogs, along with access to useful related functionality.

A low-level API for fetching network resources that is more powerful and flexible than XMLHttpRequest.

Provides an easy way for web content to be presented using the user's entire screen.

Provides access and responses to signals from gamepads and other game controllers.

Allows HTML documents and fragments to be conveniently reused in other HTML documents.

Declared fragments of markup that are parsed as HTML, but implicitly inactive until instantiated later on at runtime.

Creates a Blob object representing a file containing an image captured from a canvas.

Next revision of the HTTP protocol for faster transport of web content.

An asynchronous client-side storage API offering fast access to large amounts of structured data.

Asynchronously observes changes in the intersection of two elements; enables code to react to changes in the visibility of these elements.

A numeric type that provides a way to represent arbitrarily large integers in JavaScript (whole numbers larger than 2⁵³, which is the largest number JavaScript can reliably represent with the Number primitive).

Modules allow for easy modularization and encapsulation of JavaScript code across separate files.

Public class fields allow you to specify members you want a class to have up front, making the code more logical and self-documenting, and the constructor cleaner.

A hint for supporting browsers to prefetch specified resources without executing them, allowing developers to precisely control what resources are loaded and when. Used properly, this can lead to significant performance improvements.

Allows programmatic determination of the decoding and display abilities of the device, enabling more effective media playback.

Provides the ability to encode audio and video streams on the fly in the browser.

Allows for the creation of media streams via JavaScript, which can be played using <audio> and <video> elements.

Adds a new method, queueMicrotask(), which allows direct queueing of a callback to run as a microtask. Microtasks are callbacks that run just before the current task ends.

Programmatically determines the visibility state of a page, and provides notification if the visibility state changes.

An API for registering event listeners that explicitly cannot prevent the default action of the event.

Allows web applications to request permission from the end-user to handle requests for payments from the Payment Request API.

Specifies a workflow enabling browsers to handle web-based payments in a consistent manner, facilitating interactions between users, retailers, and card networks.

Observes performance measurement events and sends notifications of new performance entries as they are recorded in the browser performance timeline.

Provides methods and properties to store and retrieve metrics regarding the browser's document navigation events.

Exposes server metrics that are sent with the response in the Server-Timing HTTP header.

Provides a consistent programmatic way to query the status of API permissions attributed to the current context.

Requests permission to use a given API.

Revokes the permission currently set on a given API.

Handles hardware-agnostic pointer input from devices including mouse, pen, touchscreen, etc.

Provides access to raw mouse movement, locks the target of mouse events to a single element, eliminates limits of how far mouse movement can go in a single direction, and removes the cursor from view.

The Promise object is used for deferred and asynchronous computations.

Allows messages to be pushed to the client from a server even when the site isn't focused or even open in the user agent.

Allows streams of data to be represented and handle in JavaScript, read chunk by chunk.

Provides functionality to return localized strings that indicate relative time, e.g. "yesterday" in English, "ayer" in Spanish, or "wczoraj" in Polish.

Requests a callback when the user agent is idle, allowing developers to schedule background computation tasks on the event loop that have a better chance of not interfering with other more time-critical operations.

Observes changes to the size of an elementʼs content rectangle.

Allows screen orientation to be programmatically set and locked, and provides events to signal orientation changes.

Event-driven scripts that can handle network requests and manage cached responses in the background.

Provides encapsulation for JavaScript, CSS, templating and placeholder slots inside Web Components. This refers to the modern standard Shadow DOM, not Chrome's original experimental version.

Fine-grained sharing and borrowing of ArrayBuffers between workers.

A specific kind of worker that can be accessed from several browsing contexts (including windows, iframes, and other workers).

Provides an integrity attribute allowing scripts and stylesheets to protect against unexpected modifications.

Provides access to vibration hardware, allowing physical feedback to the user by causing the device to shake.

Provides an explicit mechanism for querying and modifying the properties of the visual viewport. The visual viewport is the visual portion of a screen excluding on-screen keyboards, areas outside of a pinch-zoom area, or any other on-screen artifact that doesn't scale with the dimensions of a page.

Creates and manages animations run by the browser (detailed Firefox implementation status).

A JSON-based manifest providing developers with a centralized place to put metadata associated with a web application.

A high-level web API for processing and synthesizing audio in web applications.

An extension of the Credential Management API that enables strong authentication with public key cryptography, enabling password-less authentication and secure second-factor authentication without SMS texts.

An API for communicating with Bluetooth Low Energy devices as a GATT Client.

Recognizes speech input in web applications.

Generates text-to-speech output in web applications.

A low-level, portable, size- and load-time-efficient binary code format designed to serve as a compilation target for the Web.

An API closely conforming to OpenGL ES 2.0, for rendering 2D and 3D graphics in a <canvas> element.

An update to WebGL, based on OpenGL ES 3.0.

Image format that provides lossless and lossy compression for images on the web, at significantly smaller file sizes that older formats.

Captures and streams audio, video, and arbitrary data between browsers without requiring an intermediary.

Allows for the creation and management of a WebSocket connection to a server, as well as sending and receiving data via the connection.

Provides support for exposing virtual reality displays — like the Oculus Rift or HTC Vive — to web apps, enabling developers to create interactive virtual reality scenes on the web platform.

Provides support for exposing virtual reality displays — like the Oculus Rift or HTC Vive — to web apps, enabling developers to create interactive virtual reality scenes on the web platform.

Allows JavaScript to write chunks of data to streams.