Erik Wilde on Services and APIs

HTML5 Landscape Overview

This page was last updated June 5, 2015, and will not be updated after that. Please refer (and update your bookmarks) to this GitHub repository instead, which has been the primary source for this page for quite a while already, and will be the only maintained page starting today.

HTML5 is more a movement (or maybe it's more appropriate to call it a
brand) than it is a technology. it says
more power to the browser and mostly means
more power to the browser
as a programming platform. given this focus of HTML5, it is surprisingly hard to find a good place where all
the APIs under development are listed. this page is an attempt to collect that information
in one place. the current status captured on this page lists 94 current specifications and 25 expired specifications (119 total). since the HTML5 landscape is changing fairly quickly, it is likely that some
information on this page is outdated. if that is the case, please
get in touch so that i can update the page. thanks!

here is a list of the functionality and APIs currently under development as standalone
documents in the W3C (links are to the latest version, order is alphabetical by title,
the list contains 94 specs):

Accessible Rich Internet Applications (WAI-ARIA) 1.0REC: Accessibility of web content requires semantic information about widgets, structures,
and behaviors, in order to allow assistive technologies to convey appropriate information
to persons with disabilities. This specification provides an ontology of roles, states,
and properties that define accessible user interface elements and can be used to improve
the accessibility and interoperability of web content and applications. These semantics
are designed to allow an author to properly convey user interface behaviors and structural
information to assistive technologies in document-level markup.
(Spec type: User Interaction)

Ambient Light EventsWD: This specification defines a means to receive events that correspond to a light sensor
detecting the presence of a light.
(Spec type: Device)

Audio Output Devices APIWD: This document defines a set of JavaScript APIs that let a Web application manage how
audio is rendered on the user audio output devices.
(Spec type: Device)

Battery Status Event SpecificationCR: This specification defines a new DOM event type that provides information about the
battery status of the hosting device and associated auxiliary devices.
(Spec type: Device)

BeaconWD: This specification defines an interoperable means for site developers to asynchronously
transfer data from the user agent to a web server, with the user agent taking the
responsibility to eventually send the data.
(Spec type: Communications/Networking)

Content Security Policy 2.0CR: This document defines a policy language used to declare a set of content restrictions
for a web resource, and a mechanism for transmitting the policy from a server to a
client where the policy is enforced.
(Spec type: Security)

Credential Management Level 1WD: This specification describes an imperative API enabling a website to request a user's
credentials from a user agent, and to help the user agent correctly store user credentials
for future use.
(Spec type: Security)

Cross-Origin Resource SharingPR: This document defines a mechanism to enable client-side cross-origin requests. Specifications
that enable an API to make cross-origin requests to resources can use the algorithms
defined by this specification. If such an API is used on http://example.org resources,
a resource on http://hello-world.example can opt in using the mechanism described
by this specification (e.g., specifying Access-Control-Allow-Origin: http://example.org
as response header), which would allow that resource to be fetched cross-origin from
http://example.org.
(Spec type: Communications/Networking)

Custom ElementsWD: This specification describes the method for enabling the author to define and use
new types of DOM elements in a document.
(Spec type: DOM)

DOM Parsing and SerializationWD: This specification defines various APIs for programmatic access to HTML and generic
XML parsers by web applications for use in parsing and serializing DOM nodes.
(Spec type: DOM)

DeviceOrientation Event SpecificationWD: This specification defines several new DOM event types that provide information about
the physical orientation and motion of a hosting device.
(Spec type: Device)

EncodingWD: While encodings have been defined to some extent, implementations have not always
implemented them in the same way, have not always used the same labels, and often
differ in dealing with undefined and former proprietary areas of encodings. This specification
attempts to fill those gaps so that new implementations do not have to reverse engineer
encoding implementations of the market leaders and existing implementations can converge.
(Spec type: DOM)

Encrypted Media ExtensionsWD: This proposal extends HTMLMediaElement providing APIs to control playback of protected
content. The API supports use cases ranging from simple clear key decryption to high
value video (given an appropriate user agent implementation). License/key exchange
is controlled by the application, facilitating the development of robust playback
applications supporting a range of content decryption and protection technologies.
This specification does not define a content protection or Digital Rights Management
system. Rather, it defines a common API that may be used to discover, select and interact
with such systems as well as with simpler content encryption systems. Implementation
of Digital Rights Management is not required for compliance with this specification:
only the simple clear key system is required to be implemented as a common baseline.
The common API supports a simple set of content encryption capabilities, leaving application
functions such as authentication and authorization to page authors. This is achieved
by requiring content protection system-specific messaging to be mediated by the page
rather than assuming out-of-band communication between the encryption system and a
license or other server.
(Spec type: Media)

File APIWD: This specification provides an API for representing file objects in web applications,
as well as programmatically selecting them and accessing their data.
(Spec type: File System)

Frame TimingWD: This specification defines an interface to help web developers measure the performance
of their applications by giving them access to frame performance data to facilitate
smoothness (i.e. Frames per Second and Time to Frame) measurements.
(Spec type: Monitoring)

HTML Image Description Extension (longdesc)REC: This specification defines a longdesc attribute (based on the longdesc attribute of
HTML 4) to link descriptions to images in HTML5 content. By allowing a hyperlink inside
another one, this document explicitly redefines the HTML concept of hyperlink in a
limited set of circumstances.
(Spec type: Media)

HTML ImportsWD: HTML Imports are a way to include and reuse HTML documents in other HTML documents.
(Spec type: DOM)

HTML Media CaptureCR: This specification defines HTML form enhancements that provide access to the audio,
image and video capture capabilities of the device.
(Spec type: Media)

HTML5REC: This specification defines the 5th major revision of the core language of the World
Wide Web: the Hypertext Markup Language (HTML). In this version, new features are
introduced to help Web application authors, new elements are introduced based on research
into prevailing authoring practices, and special attention has been given to defining
clear conformance criteria for user agents in an effort to improve interoperability.
(Spec type: Core)

HTML5 Web MessagingREC: This specification defines two mechanism for communicating between browsing contexts
in HTML documents.

High Resolution TimeREC: This specification defines a JavaScript interface that provides the current time in
sub-millisecond resolution and such that it is not subject to system clock skew or
adjustments.
(Spec type: Monitoring)

High Resolution Time Level 2WD: This specification defines a JavaScript interface that provides the current time in
sub-millisecond resolution and such that it is not subject to system clock skew or
adjustments.
(Spec type: Monitoring)

Identifiers for WebRTC's Statistics APIWD: This document defines a set of JavaScript APIs that allow access to the statistical
information about a PeerConnection.
(Spec type: Communications/Networking)

Indexed Database APIREC: This document defines APIs for a database of records holding simple values and hierarchical
objects. Each record consists of a key and some value. Moreover, the database maintains
indexes over records it stores. An application developer directly uses an API to locate
records either by their key or by using an index. A query language can be layered
on this API. An indexed database can be implemented using a persistent B-tree data
structure.
(Spec type: Storage)

IndieUI: Events 1.0WD: IndieUI: Events 1.0 is an abstraction between physical, device-specific user interaction
events and inferred user intent such as scrolling or changing values. This provides
an intermediate layer between device- and modality-specific user interaction events,
and the basic user interface functionality used by web applications. IndieUI: Events
focuses on granular user interface interactions such as scrolling the view, canceling
an action, changing the value of a user input widget, selecting a range, placing focus
on an object, etc. Implementing platforms will combine modality-specific user input,
user idiosyncratic heuristics to determine the specific corresponding Indie UI event,
and send that to the web application in addition to the modality-specific input such
as mouse or keyboard events, should applications wish to process it.
(Spec type: User Interaction)

IndieUI: User Context 1.0WD: IndieUI: User Context defines a set of preferences that users can choose to expose
to web applications, and an API for user agents to access the preferences and listen
for changes. User can set preferences for features such as screen and font size, color,
and typographical preferences. Users with disabilities can provide information about
assistive technologies in use, indicate that the display is in an accessibility mode,
and indicate whether and what kind of subtitles and audio descriptions they need.
Web applications can use this information to optimize the presentation without a requirement
to target a specific device, operating system, or locale. While customizations based
on these properties benefit users, the information could also be used to make assumptions
about users or compromise anonymity. Therefore, the specification includes user agent
requirements to allow users to opt out and choose not to expose information on a category
basis to preserve privacy.
(Spec type: User Interaction)

Input Method Editor APIWD: This specification defines an "IME API" that provides Web applications with scripted
access to an IME (input-method editor) associated with a hosting user agent. This
IME API includes: an InputMethodContext interface, which provides methods to retrieve
detailed data from an in-progress IME composition; and a Composition dictionary, which
represents read-only attributes about the current composition, such as the actual
text and its style. This API is designed to be used in conjunction with DOM events.
(Spec type: User Interaction)

Manifest for Web ApplicationWD: This specification defines a JSON-based manifest that provides developers with a centralized
place to put metadata associated with a web application. This includes, but is not
limited to, the web application's name, links to icons, as well as the preferred URL
to open when a user launches the web application. The manifest also allows developers
to declare a default orientation for their web application, as well as providing the
ability to set the display mode for the application (e.g., in fullscreen). Additionally,
the manifest allows a developer to "scope" a web application to a URL. This restricts
the URLs to which the application can be navigated and provides a means to "deep link"
into a web application from other applications. Using this metadata, user agents can
provide developers with means to create user experiences that are more comparable
to that of a native application. In addition, this specification defines the manifest
link type, which provides a declarative means for a document to be associated with
a manifest.

Media Capture Depth Stream ExtensionsWD: This specification extends the Media Capture and Streams specification to allow a
depth stream to be requested from the web platform using APIs familiar to web authors.
(Spec type: Media)

Media Capture from DOM ElementsWD: This document defines how a stream of media can be captured from a DOM element, such
as a <video>, <audio>, or <canvas> element, in the form of a MediaStream.
(Spec type: Media)

Media Source ExtensionsCR: This specification extends HTMLMediaElement to allow JavaScript to generate media
streams for playback. Allowing JavaScript to generate streams facilitates a variety
of use cases like adaptive streaming and time shifting live streams.
(Spec type: Media)

MediaStream RecordingWD: This document defines a recording API for use with MediaStreams as defined in Media
Capture and Streams.
(Spec type: Media)

Mediastream Image CaptureWD: This document specifies the takePhoto() and getFrame() methods, and corresponding
camera settings for use with MediaStreams as defined in Media Capture and Streams.
(Spec type: Media)

Navigation Timing 2WD: This specification defines an interface for web applications to access the complete
timing information for navigation of a document.
(Spec type: Monitoring)

Network Error LoggingWD: This document defines a mechanism that enables developers to declare a network error
reporting policy for a web application. A user agent can use this policy to report
encountered network errors that prevented it from successfully fetching requested
resources.
(Spec type: Monitoring)

Network Service DiscoveryWD: This specification defines a mechanism for an HTML document to discover and subsequently
communicate with HTTP-based services advertised via common discovery protocols within
the current network.
(Spec type: Communications/Networking)

Page VisibilityREC: This specification defines a means for site developers to programmatically determine
the current visibility state of the page in order to develop power and CPU efficient
web applications.
(Spec type: Monitoring)

Pointer EventsREC: This document defines events and related interfaces for handling hardware agnostic
pointer input from devices like a mouse, pen, or touchscreen. For compatibility with
existing mouse-based content, this specification also describes a mapping to fire
DOM3 Mouse Events for pointer device types other than mouse.
(Spec type: Device)

Pointer LockCR: This specification defines an API that provides scripted access to raw mouse movement
data while locking the target of mouse events to a single element and removing the
cursor from view. This is an essential input mode for certain classes of applications,
especially first person perspective 3D applications and 3D modelling software.

Presentation APIWD: This specification defines an API to enable web content to access external presentation-type
displays and use them for presenting web content.
(Spec type: Device)

Privileged ContextsWD: This specification provides guidelines for user agent implementors and spec authors
for implementing features whose properties dictate that they be exposed to the web
only within a trustworthy environment.
(Spec type: Security)

Progress EventsREC: The Progress Events specification defines an event interface that can be used for
measuring progress; e.g. HTTP entity body transfers. This specification is primarily
meant to be used by other specifications.
(Spec type: Monitoring)

Proximity EventsCR: This specification defines a means to receive events that correspond to a proximity
sensor detecting the presence of a physical object.
(Spec type: Device)

Push APIWD: The Push API provides webapps with scripted access to server-sent messages, for simplicity
referred to here as push messages, as delivered by push services. A push service allows
an application server to send messages to a webapp, regardless of whether the webapp
is currently active on the user agent. The push message will be delivered to a Service
Worker, which could then store the message's data or display a notification to the
user. This specification is designed to promote compatibility with any delivery method
for push messages from push services to user agents.
(Spec type: Communications/Networking)

Quota Management APIWD: This specification defines an API to manage usage and availability of local storage
resources, and defines a means by which a user agent (UA) may grant Web applications
permission to use more local space, temporarily or persistently, via various different
storage APIs.
(Spec type: Storage)

Referrer PolicyWD: This document describes how an author can set a referrer policy for documents they
create, and the impact of such a policy on the referer HTTP header for outgoing requests
and navigations.
(Spec type: Security)

Resource HintsWD: This specification defines the preconnect relationship and extends the preload relationship
of the HTML Link Element (<link>). These primitives enable the developer, and the
server generating or delivering the resources, to assist the user agent in the decision
process of which origins it should connect to, and which resources it should fetch
to improve page performance.
(Spec type: Communications/Networking)

Runtime and Security Model for Web ApplicationsWD: This document specifies a runtime and security model for Web Applications. It describes
how an application is defined through an application manifest, and how it can be installed,
updated and packaged. It also specifies how such an application can be put into the
background, be put back in the foreground or woken up. Finally, the document describes
the security model for such applications. This includes the permission model and the
different security rules that would apply.
(Spec type: Security)

Screen CaptureWD: This document defines how a user's display, or parts thereof, can be used as the source
of a media stream using getOutputMedia, an extension to the Media Capture API.
(Spec type: Media)

Screen Orientation APIWD: The Screen Orientation API provides the ability to read the screen orientation type
and angle, to be informed when the screen orientation state changes, and be able to
lock the screen orientation to a specific state.
(Spec type: Device)

Selectors API Level 1WD: The Selectors API specification defines methods for retrieving Element nodes from
the DOM by matching against a group of selectors.
(Spec type: DOM)

Selectors API Level 2WD: The Selectors API specification defines methods for retrieving element nodes from
the DOM by matching against a group of selectors, and for testing if a given element
matches a particular selector.
(Spec type: DOM)

Server TimingWD: This specification introduces Server Timing, which enables the server to communicate
performance metrics about the request-response cycle to the user agent, and a JavaScript
interface to enable applications to collect, process, and act on these metrics to
optimize application delivery.
(Spec type: Monitoring)

Server-Sent EventsREC: This specification defines an API for opening an HTTP connection for receiving push
notifications from a server in the form of DOM events. The API is designed such that
it can be extended to work with other push notification schemes such as Push SMS.
(Spec type: Communications/Networking)

Service WorkersWD: This specification describes a method that enables applications to take advantage
of persistent background processing, including hooks to enable bootstrapping of web
applications while offline. The core of this system is an event-driven Web Worker,
which responds to events dispatched from documents and other sources. A system for
managing installation, versions, and upgrades is provided. The Service Worker is a
generic entry point for event-driven background processing in the Web Platform that
is extensible by other specifications.

Shadow DOMWD: This specification describes a method of establishing and maintaining functional boundaries
between DOM trees and how these trees interact with each other within a document,
thus enabling better functional encapsulation within the DOM.
(Spec type: DOM)

Streams APIWD: WHATWG Streams API spec provides an API for representing and handling a stream of
data in JavaScript. This W3C spec is intended to extend the WHATWG spec to meet requirements
specific to the browser environment.

Subresource IntegrityWD: This specification defines a mechanism by which user agents may verify that a fetched
resource has been delivered without unexpected manipulation.
(Spec type: Security)

Task Scheduler API SpecificationWD: This specification defines an API to schedule a task at a specified time. When the
indicated time is reached, the application that scheduled the task will be notified
via a functional event on a service worker. A task event will be delivered to a service
worker, regardless of whether the application is active on user agent. Applications
such as an alarm clock or an auto-updater may utilize this API to perform certain
action at a specified time.
(Spec type: OS Environment)

The Permissions APIWD: The Permissions API allows a web application to be aware of the status of a given
permission, to know whether it is granted, denied or if the user will be asked whether
the permission should be granted.
(Spec type: Monitoring)

The app: URI schemeWD: This specification defines the app: URI scheme and rules for dereferencing an app:
URI, which can be used to address resources inside a package (e.g., a packaged application).
The dereferencing model relies on HTTP semantics to return resources in a manner akin
to a HTTP GET request. Doing so allows this URI scheme to be used with other technologies
that rely on HTTP responses to function as intended, such as XmlHttpRequest.
(Spec type: File System)

Timing Control for Script-Based AnimationsCR: This document defines an API web page authors can use to write script-based animations
where the user agent is in control of limiting the update rate of the animation. The
user agent is in a better position to determine the ideal animation rate based on
whether the page is currently in a foreground or background tab, what the current
load on the CPU is, and so on. Using this API should therefore result in more appropriate
utilization of the CPU by the browser.
(Spec type: Monitoring)

Touch EventsREC: The Touch Events specification defines a set of low-level events that represent one
or more points of contact with a touch-sensitive surface, and changes of those points
with respect to the surface and any DOM elements displayed upon it (e.g. for touch
screens) or associated with it (e.g. for drawing tablets without displays). It also
addresses pen-tablet devices, such as drawing tablets, with consideration toward stylus
capabilities.
(Spec type: Device)

W3C HTML Form HTTP ExtensionsWD: This is an addendum to the specification of HTML5 forms extending the abilities of
configuring HTTP requests through HTML markup. This document has been developed as
a result of work contributed in addressing HTML WG ISSUE-195: Enhance http request
generation from forms.
(Spec type: Communications/Networking)

Wake Lock APIWD: This document specifies an API that allows web applications to request a wake lock.
A wake lock prevents some aspect of the device from entering a power-saving state
(e.g., preventing the system from turning off the screen).
(Spec type: Device)

Web Animations 1.0WD: This specification defines a model for synchronization and timing of changes to the
presentation of a Web page. This specification also defines an application programming
interface for interacting with this model and it is expected that further specifications
will define declarative means for exposing these features.
(Spec type: Graphics)

Web Audio APIWD: This specification describes a high-level JavaScript API for processing and synthesizing
audio in web applications. The primary paradigm is of an audio routing graph, where
a number of AudioNode objects are connected together to define the overall audio rendering.
The actual processing will primarily take place in the underlying implementation (typically
optimized Assembly/C/C++ code), but direct JavaScript processing and synthesis is
also supported. This API is designed to be used in conjunction with other APIs and
elements on the web platform, notably: XMLHttpRequest (using the responseType and
response attributes). For games and interactive applications, it is anticipated to
be used with the canvas 2D and WebGL 3D graphics APIs.
(Spec type: Media)

Web Cryptography APICR: This specification describes a JavaScript API for performing basic cryptographic operations
in web applications, such as hashing, signature generation and verification, and encryption
and decryption. Additionally, it describes an API for applications to generate and/or
manage the keying material necessary to perform these operations. Uses for this API
range from user or service authentication, document or code signing, and the confidentiality
and integrity of communications.
(Spec type: Security)

Web MIDI APIWD: Some user agents have connected music devices, such as synthesizers, keyboard and
other controllers, and drum machines. The widely adopted Musical Instrument Digital
Interface (MIDI) protocol enables electronic musical instruments, controllers and
computers to communicate and synchronize with each other. MIDI does not transmit audio
signals: instead, it sends event messages about musical notes, controller signals
for parameters such as volume, vibrato and panning, cues and clock signals to set
the tempo, and system-specific MIDI communications (e.g. to remotely store synthesizer-specific
patch data). This same protocol has become a standard for non-musical uses, such as
show control, lighting and special effects control. This specification defines an
API supporting the MIDI protocol, enabling web applications to enumerate and select
MIDI input and output devices on the client system and send and receive MIDI messages.
It is intended to enable non-music MIDI applications as well as music ones, by providing
low-level access to the MIDI devices available on the users' systems. At the same
time, the Web MIDI API is not intended to become a semantic controller platform; it
is designed to expose the mechanics of MIDI input and output interfaces, and the practical
aspects of sending and receiving MIDI messages, without identifying what those actions
might mean semantically. To some users, "MIDI" has become synonymous with Standard
MIDI Files and General MIDI. That is not the intent of this API; the use case of simply
playing back a .SMF file is not within the purview of this specification (it could
be considered a different format to be supported by the HTML5 <audio> element, for
example). The Web MIDI API is intended to enable direct access to devices that respond
to MIDI - external synthesizers or lighting systems, for example, or even the software
synthesizers that are built in to many common operating systems. The Web MIDI API
is also explicitly designed to enable a new class of applications on the web that
can respond to MIDI controller inputs - using external hardware controllers with physical
buttons, knobs and sliders (as well as musical controllers like keyboard, guitar or
wind instrument controllers) to control web applications. The Web MIDI API is also
expected to be used in conjunction with other APIs and elements of the web platform,
notably the Web Audio API and High-Resolution Time. This API is also intended to be
familiar to users of MIDI APIs on other systems, such as Apple's CoreMIDI and Microsoft's
Windows MIDI API.
(Spec type: User Interaction)

Web NFC APIWD: Near Field Communication (NFC) is an international standard (ISO/IEC 18092) that specifies
an interface and protocol for simple wireless interconnection of closely coupled devices
operating at 13.56 MHz. There are three groups of application scenarios for NFC: The
first one is to hold a device close to a wireless tag to exchange some digital information
or data; The second is to hold two devices close to each other in order to exchange
some information or data between them; The third one is to make payments by holding
mobile phones close to point of sales terminals instead of swiping smart cards. NFC
enables wireless communication between two devices at close proximity, usually less
than a few centimeters.
(Spec type: Device)

Web NotificationsCR: Web notifications defines an API for end-user notifications. A notification allows
alerting the user outside the context of a web page of an occurrence, such as the
delivery of email.
(Spec type: User Interaction)

Web WorkersCR: This specification defines an API that allows Web application authors to spawn background
workers running scripts in parallel to their main page. This allows for thread-like
operation with message-passing as the coordination mechanism.

WebCrypto Key DiscoveryWD: This specification describes a JavaScript API for discovering named, origin-specific
pre-provisioned cryptographic keys for use with the Web Cryptography API. Pre-provisioned
keys are keys which have been made available to the UA by means other than the generation,
derivation, imporation functions of the Web Cryptography API. Origin-specific keys
are keys that are available only to a specified origin. Named keys are identified
by a name assumed to be known to the origin in question and provisioned with the key
itself.
(Spec type: Security)

WebDriverWD: This specification defines the WebDriver API, a platform-and language-neutral interface
that allows programs or scripts to introspect into, and control the behaviour of,
a web browser. The WebDriver API is primarily intended to allow developers to write
tests that automate a browser from a separate controlling process, but may also be
implemented in such a way as to allow in-browser scripts to control a browser. The
WebDriver API is defined by a set of interfaces to discover and manipulate DOM elements
on a page, and to control the behaviour of the containing browser. This specification
also includes a non-normative reference useful for browser vendors.

WebRTC 1.0: Real-time Communication Between BrowsersWD: This document defines a set of ECMAScript APIs in WebIDL to allow media to be sent
over the network to another browser or device implementing the appropriate set of
real-time protocols, and media to be received from another browser or device. This
specification is being developed in conjunction with a protocol specification developed
by the IETF RTCWEB group and an API specification to get access to local media devices
developed by the Media Capture Task Force.
(Spec type: Communications/Networking)

WebSocket APICR: This specification defines an API that enables Web pages to use the WebSocket protocol
(defined by the IETF) for two-way communication with a remote host.
(Spec type: Communications/Networking)

WebVTT: The Web Video Text Tracks FormatWD: This specification defines WebVTT, the Web Video Text Tracks format. Its main use
is for marking up external text track resources in connection with the HTML <track>
element. WebVTT files provide captions or subtitles for video content, and also text
video descriptions, chapters for content navigation, and more generally any form of
metadata that is time-aligned with audio or video content.
(Spec type: Media)

XMLHttpRequestWD: The XMLHttpRequest specification defines an API that provides scripted client functionality
for transferring data between a client and a server.
(Spec type: Communications/Networking)

XMLHttpRequest Level 2WD: The XMLHttpRequest Level 2 specification enhances the XMLHttpRequest object with new
features, such as cross-origin requests, progress events, and the handling of byte
streams for both sending and receiving.
(Spec type: Communications/Networking)

here is a list of specifications that have been officially deprecated or where development
has been discontinued (alphabetical order, the list contains 25 specs):

Contacts Manager APINOTE: This specification defines a System Level API which offers a simple interface to manage
user's contacts stored in the system's address book. A typical use case of the Contacts
API is the implementation of an application to manage said address book.
(Spec type: OS Environment)

Content Security Policy 1.0NOTE: This document defines a policy language used to declare a set of content restrictions
for a web resource, and a mechanism for transmitting the policy from a server to a
client where the policy is enforced.
(Spec type: Security)

File API: Directories and SystemNOTE: This specification defines an API to navigate file system hierarchies, and defines
a means by which a user agent may expose sandboxed sections of a user's local filesystem
to web applications. It builds on
File API: Writer, which in turn built on
File API, each adding a different kind of functionality.
(Spec type: File System)

File API: WriterNOTE: This specification defines an API for writing to files from web applications. This
API is designed to be used in conjunction with, and depends on definitions in, other
APIs and elements on the web platform. Most relevant among these are
File API and
Web Workers.
(Spec type: File System)

HTML MicrodataNOTE: This specification defines the HTML microdata mechanism. This mechanism allows machine-readable
data to be embedded in HTML documents in an easy-to-write manner, with an unambiguous
parsing model. It is compatible with numerous other data formats including RDF and
JSON.

Messaging APINOTE: This specification defines a System Level API which offers a simple interface to get
access to mobile messaging services. A typical use case of the Messaging API is the
implementation of a messaging client application that allows the user to send SMS
and MMS messages as well as to access and manage the received SMS and MMS messages.
(Spec type: Communications/Networking)

Pick Contacts IntentNOTE: The Pick Contacts Intent defines a Web Intent that enables access to a user's address
book service from inside a Web application. It defines both an Intent action/type
pair that selects this operation, and the format of the contacts data that is returned
by services implementing this specification.
(Spec type: OS Environment)

Pick Media IntentNOTE: The Pick Media Intent defines a Web Intent that enables access to a user's media gallery
from inside a Web application. It defines both an Intent action/type pair that selects
this operation, and the format of the media data that is returned by services implementing
this specification.
(Spec type: Media)

Programmable HTTP Caching and ServingNOTE: This document defines APIs for off-line serving of requests to HTTP resources using
static and dynamic responses. It extends the function of application caches defined
in HTML5.

Resource PrioritiesNOTE: This specification defines a means for site developers to programmatically give the
User Agent hints on the download priority of a resource. This will allow User Agents
to more efficiently manage the order in which resources are downloaded.
(Spec type: Monitoring)

System Information APINOTE: This specification defines an API to provide Web applications with access to various
properties of the system which they are running on. Specifically, properties pertaining
to the device hardware are addressed. Examples include battery status, current network
bandwidth. Additionally, some of those properties offer access to the environment
around the device, such as ambient brightness or atmospheric pressure.
(Spec type: Device)

The Messaging APINOTE: This specification defines an API that provides access to messaging functionality
in the device, including SMS, MMS and email.
(Spec type: Communications/Networking)

The picture ElementNOTE: This specification defines the HTML picture element and extends the img and source
elements to allow authors to declaratively control or give hints to the user agent
about which image resource to use, based on the screen pixel density, viewport size,
image format, and other factors.
(Spec type: Media)

The srcset AttributeNOTE: When authors adapt their sites for high-resolution displays, they often need to be
able to use different assets representing the same image. We address this need for
adaptive, bitmapped content images by adding a srcset attribute to the img element.
(Spec type: Media)

Touch Events ExtensionsNOTE: This document defines extensions to the Touch Events specification that have been
implemented by one or more browsers. We recommend that user agents implement the Touch
Events Recommendation and/or the newer Pointer Events specification instead. This
document is no longer being developed.
(Spec type: Device)

Web IntentsNOTE: This specification defines a service discovery and light-weight RPC mechanism for
web apps called Web Intents. This document defines DOM interfaces and markup used
by client and service pages to create, receive, and reply to Web Intents messages,
and the procedures the User Agent carries out to facilitate that process.
(Spec type: Communications/Networking)

Web Intents Addendum — Local ServicesNOTE: This specification is an addendum to Web Intents, that defines how Web Intents enabled
User Agents can discover and communicate with local Web Intents Services.
(Spec type: Communications/Networking)

Web SQL DatabaseNOTE: This specification defines an API for storing data in databases that can be queried
using a variant of SQL.
(Spec type: Storage)

Web Telephony APINOTE: This specification defines an API to manage telephone calls. A typical use case of
the Web Telephony API is the implementation of a 'Dialer' application supporting multiparty
calls and multiple telephony services. A minimal structure for call history items
is also defined.
(Spec type: Communications/Networking)