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.

Provides one-off and periodic synchronization for Service Workers with an onsync 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.

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.

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.

Allows media queries to include tests for interactivity, for example whether the pointer is coarse or fine, or whether hovering is available on the device.

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.

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 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.

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

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.

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.

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.

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).

Allows streams of data to be represented and handled in JavaScript.

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.

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.

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.