This document describes how user agents determine names and descriptions of accessible objects from web content languages and expose them in accessibility APIs. This allows assistive technologies to associate and relay the name or description of objects to users. Documenting the algorithm and mappings promotes interoperable exposure of these properties and events as implemented by different accessibility APIs, and helps to ensure that this information appears in a manner consistent with author intent.

The accessible name and description computation and mappings specification defines support that applies across multiple content technologies. This includes accessible name and description provided by general-purpose WAI-ARIA [WAI-ARIA] roles, states, and properties as well as features specific to individual content languages. The accessible name and description computation extends the mapping guidance provided by CORE-AAM [CORE-AAM] and technology-specific accessibility API mappings.

This document updates and will eventually supersede the accessible name and description guidance in the WAI-ARIA 1.0 User Agent Implementation Guide [WAI-ARIA-IMPLEMENTATION] W3C Recommendation. It is part of the WAI-ARIA suite described in the WAI-ARIA Overview.

Status of This Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

This is a First Public Working Draft of Accessible Name and Description: Computation and API Mappings 1.1 by the Protocols & Formats Working Group of the Web Accessibility Initiative. It contains content previously published in WAI-ARIA 1.1 [WAI-ARIA] and Core Accessibility API Mappings 1.1 [CORE-AAM]. Moving that content to this specification eliminates duplication between Core AAM and WAI-ARIA, and facilitates future host language-specific accessible name guidance. It is anticipated that this specification will progress on the same timeline as those two specifications, though it may also be updated as needed to describe accessible name and description computation for additional host languages.

Feedback on any aspect of the specification is accepted. For this publication, the Protocols and Formats Working Group particularly seeks feedback on the following questions:

To comment, send email to public-pfwg-comments@w3.org (comment archive) or file an issue in W3C Bugzilla. Comments are requested by 30 January 2015. In-progress updates to the document may be viewed in the publicly visible editors' draft.

Publication as a First Public Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.

This document is governed by the 1 August 2014 W3C Process Document.

Table of Contents §

1. Introduction §

This section is informative.

User agents acquire information from the DOM and create a parallel structure called the accessibility tree, made up of accessible objects. An accessible object provides information about its role, states, and properties. An example is an accessible object whose role is menuitem, is currently in an enabled state, with a haspopup property, indicating that it leads to a sub-menu.

The two properties of accessible objects described in this document are its accessible name and accessible description. The name is a short label that provides information about the purpose of the object. An example of an accessible name for a menu item is New, signifying that the menu item provides for the creation of new documents, windows, and so on.

The description is a short explanation that further clarifies the nature of the accessible object. It is not always necessary to provide a description if the name is sufficient, but it can help a user better understand the use of the object.

Accessibility APIs currently support flat, unstructured strings for accessible names and descriptions. The result of the name/description computation is thus a flat string.

The terms "accessible name" and "accessible description" are used to emphasize that they are properties of accessible objects as exposed by Accessibility APIs. However, they are frequently referred to hereafter as simply "name" and "description".

2. Normative User Agent Implementation Requirements for WAI-ARIA §

This section is normative.

This specification indicates whether a section is normative or informative and the classification applies to the entire section. A statement "This section is normative" or "This section is informative" applies to all sub-sections of that section.

Normative sections provide requirements that user agents must follow for an implementation to conform to this specification. The keywords MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, RECOMMENDED, MAY, and OPTIONAL in this document are to be interpreted as described in Keywords for use in RFCs to indicate requirement levels [RFC2119]. RFC-2119 keywords are formatted in uppercase and contained in a strong element with class="rfc2119". When the keywords shown above are used, but do not share this format, they do not convey formal information in the RFC 2119 sense, and are merely explanatory, i.e., informative. As much as possible, such usages are avoided in this specification.

Informative sections provide information useful to understanding the specification. Such sections may contain examples of recommended practice, but it is not required to follow such recommendations in order to conform to this specification.

3. Important Terms §

This section is normative.

While some terms are defined in place, the following definitions are used throughout this document.

Accessibility API

Operating systems and other platforms provide a set of interfaces that expose information about objects and events to assistive technologies. Assistive technologies use these interfaces to get information about and interact with those widgets. Examples of accessibility APIs are Microsoft Active Accessibility [MSAA], Microsoft User Interface Automation [UI-AUTOMATION], MSAA with UIA Express [UIA-EXPRESS], the Mac OS X Accessibility Protocol [AXAPI], the Linux/Unix Accessibility Toolkit [ATK] and Assistive Technology Service Provider Interface [AT-SPI], and IAccessible2 [IAccessible2].

Accessibility Subtree

An accessible object in the accessibility tree and its descendants in that tree. It does not include objects which have relationships other than parent-child in that tree. For example, it does not include objects linked via aria-flowto unless those objects are also descendants in the accessibility tree.

Accessibility Tree

Tree of accessible objects that represents the structure of the user interface (UI). Each node in the accessibility tree represents an element in the UI as exposed through the accessibility API; for example, a push button, a check box, or container.

Accessible Description

An accessible description provides additional information, related to an interface element, that complements the accessible name. The accessible description might or might not be visually perceivable.

Accessible Name

The accessible name is the name of a user interface element. Each platform accessibility API provides the accessible name property. The value of the accessible name may be derived from a visible (e.g., the visible text on a button) or invisible (e.g., the text alternative that describes an icon) property of the user interface element. See related accessible description.

A simple use for the accessible name property may be illustrated by an "OK" button. The text "OK" is the accessible name. When the button receives focus, assistive technologies may concatenate the platform's role description with the accessible name. For example, a screen reader may speak "push-button OK" or "OK button". The order of concatenation and specifics of the role description (e.g., "button", "push-button", "clickable button") are determined by platform accessibility APIs or assistive technologies.

Accessible object

A user interface object whose basic accessibility is exposed to assistive technology via a platform accessibility API. Accessible objects are included in the accessibility tree. MS UIA represents accessible objects as automation elements.

Activation behavior

The action taken when an event, typically initiated by users through an input device, causes an element to fulfill a defined role. The role may be defined for that element by the host language, or by author-defined variables, or both. The role for any given element may be a generic action, or may be unique to that element. For example, the activation behavior of an HTML or SVG <a> element shall be to cause the user agent to traverse the link specified in the href attribute, with the further optional parameter of specifying the browsing context for the traversal (such as the current window or tab, a named window, or a new window); the activation behavior of an HTML <input> element with the type attribute value submit shall be to send the values of the form elements to an author-defined IRI by the author-defined HTTP method.

Assistive Technologies

Hardware and/or software that:

  • relies on services provided by a user agent to retrieve and render Web content
  • works with a user agent or web content itself through the use of APIs, and
  • provides services beyond those offered by the user agent to facilitate user interaction with web content by people with disabilities

This definition may differ from that used in other documents.

Examples of assistive technologies that are important in the context of this document include the following:

  • screen magnifiers, which are used to enlarge and improve the visual readability of rendered text and images;
  • screen readers, which are most-often used to convey information through synthesized speech or a refreshable Braille display;
  • text-to-speech software, which is used to convert text into synthetic speech;
  • speech recognition software, which is used to allow spoken control and dictation;
  • alternate input technologies (including head pointers, on-screen keyboards, single switches, and sip/puff devices), which are used to simulate the keyboard;
  • alternate pointing devices, which are used to simulate mouse pointing and clicking.

In this specification, attribute is used as it is in markup languages. Attributes are structural features added to elements to provide information about the states and properties of the object represented by the element.


A set of instance objects that share similar characteristics.

Desktop focus event

Event from/to the host operating system via the accessibility API, notifying of a change of input focus.


In this specification, element is used as it is in markup languages. Elements are the structural elements in markup language that contains the data profile for objects.


A programmatic message used to communicate discrete changes in the state of an object to other objects in a computational system. User input to a web page is commonly mediated through abstract events that describe the interaction and can provide notice of changes to the state of a document object. In some programming languages, events are more commonly known as notifications.


Translated to platform-specific accessibility APIs as defined in the WAI-ARIA User Agent Implementation Guide. [WAI-ARIA-IMPLEMENTATION]


Indicates that the element is not visible or perceivable to any user. An element is only considered hidden in the DOM if it or one of its ancestor elements has the aria-hidden attribute set to true.


Note: Authors are reminded that visibility:hidden and display:none apply to all CSS media types; therefore, use of either will hide the content from assistive technologies that access the DOM through a rendering engine. However, in order to support assistive technologies that access the DOM directly, or other authoring techniques to visibly hide content (for example, opacity or off-screen positioning), authors need to ensure the aria-hidden attribute is always updated accordingly when an element is shown or hidden, unless the intent of using off-screen positioning is to make the content visible only to screen reader users and not others.


Content provided for information purposes and not required for conformance. Content required for conformance is referred to as normative.

Keyboard Accessible

Accessible to the user using a keyboard or assistive technologies that mimic keyboard input, such as a sip and puff tube. References in this document relate to WCAG 2 Guideline 2.1; "Make all functionality available from a keyboard" [WCAG20].


A type of region on a page to which the user may want quick access. Content in such a region is different from that of other regions on the page and relevant to a specific user purpose, such as navigating, searching, perusing the primary content, etc.

Live Region

Live regions are perceivable regions of a web page that are typically updated as a result of an external event when user focus may be elsewhere. These regions are not always updated as result of a user interaction. This practice has become commonplace with the growing use of Ajax. Examples of live regions include a chat log, stock ticker, or a sport scoring section that updates periodically to reflect game statistics. Since these asynchronous areas are expected to update outside the user's area of focus, assistive technologies such as screen readers have either been unaware of their existence or unable to process them for the user. WAI-ARIA has provided a collection of properties that allow the author to identify these live regions and how to process them: aria-live, aria-relevant, aria-atomic, and aria-busy. Pre-defined live region roles are listed in the Choosing Between Special Case Live Regions ([WAI-ARIA-PRACTICES], Section 5.3).

Primary Content Element

An implementing host language's primary content element, such as the body element in HTML.

Managed State

Accessibility API state that is controlled by the user agent, such as focus and selection. These are contrasted with "unmanaged states" that are typically controlled by the author. Nevertheless, authors can override some managed states, such as aria-posinset and aria-setsize. Many managed states have corresponding CSS pseudo-classes, such as :focus, and pseudo-elements, such as ::selection, that are also updated by the user agent.

Nemeth Braille

The Nemeth Braille Code for Mathematics is a braille code for encoding mathematical and scientific notation. See Nemeth Braille on Wikipedia.


Basic type of object in the DOM tree or accessibility tree. DOM nodes are further specified as Element or Text nodes, among other types. The nodes of an accessibility tree are accessible objects.


Required for conformance. By contrast, content identified as informative or "non-normative" is not required for conformance.


In the context of user interfaces, an item in the perceptual user experience, represented in markup languages by one or more elements, and rendered by user agents.

In the context of programming, the instantiation of one or more classes and interfaces which define the general characteristics of similar objects. An object in an accessibility API may represent one or more DOM objects. Accessibility APIs have defined interfaces that are distinct from DOM interfaces.

A description of the characteristics of classes and how they relate to each other.


Usable by users in ways they can control. References in this document relate to WCAG 2 Principle 2; content must be operable [WCAG20]. See Keyboard Accessible.

Owned Element

An 'owned element' is any DOM descendant of the element, any element specified as a child via aria-owns, or any DOM descendant of the owned child.

Owning Element

An 'owning element' is any DOM ancestor of the element, or any element with an aria-owns attribute which references the ID of the element.


Presentable to users in ways they can sense. References in this document relate to WCAG 2 Principle 1; content must be perceivable [WCAG20].


Attributes that are essential to the nature of a given object, or that represent a data value associated with the object. A change of a property may significantly impact the meaning or presentation of an object. Certain properties (for example, aria-multiline) are less likely to change than states, but note that the frequency of change difference is not a rule. A few properties, such as aria-activedescendant, aria-valuenow, and aria-valuetext are expected to change often. See clarification of states versus properties.


A connection between two distinct things. Relationships may be of various types to indicate which object labels another, controls another, etc.


Main indicator of type. This semantic association allows tools to present and support interaction with the object in a manner that is consistent with user expectations about other objects of that type.

Root WAI-ARIA node

The primary element containing non-metadata content. In many languages, this is the document element but in HTML, it is the <body> or <frameset>.


The meaning of something as understood by a human, defined in a way that computers can process a representation of an object, such as elements and attributes, and reliably represent the object in a way that various humans will achieve a mutually consistent understanding of the object.


A state is a dynamic property expressing characteristics of an object that may change in response to user action or automated processes. States do not affect the essential nature of the object, but represent data associated with the object or user interaction possibilities. See clarification of states versus properties.


Any document created from a <frame>, <iframe> or similar mechanism. A sub-document may contain a document, an application or any widget such as a calendar pulled in from another server. In the accessible tree there are two accessible objects for this situation—one represents the <frame>/<iframe> element in the parent document, which parents a single accessible object child representing the spawned document contents.

Target Element

An element specified in a WAI-ARIA relation. For example, in aria-controls=”elem1”, “elem1” is the target element.


A hierarchical definition of how the characteristics of various classes relate to each other, in which classes inherit the properties of superclasses in the hierarchy. A taxonomy can comprise part of the formal definition of an ontology.

Text node

Type of DOM node that represents the textual content of an attribute or an element. A Text node has no child nodes.


Presentable to users in ways they can construct an appropriate meaning. References in this document relate to WCAG 2 Principle 3; Information and the operation of user interface must be understandable [WCAG20].

User Agent

Any software that retrieves, renders and facilitates end user interaction with Web content. This definition may differ from that used in other documents.


A reference to a target element in the same document that has a matching ID


A literal that solidifies the information expressed by a state, property, role, or text content.


Discrete user interface object with which the user can interact. Widgets range from simple objects that have one value or operation (e.g., check boxes and menu items), to complex objects that contain many managed sub-objects (e.g., trees and grids).

4. Name and Description §

This section is normative.

The starting point of the name and description computation is a DOM element. The output is a flat, unstructured string that can be as simple as a single word, or a string of space-separated tokens. Examples include Save and Reload from disk.

An important factor is the element's role, that determines which content contributes to the name string. Roles have a nameFrom RDF property, with two possible values:

name is generated from values provided by the author in explicit markup features such as the aria-label and aria-labelledby attribute, or a host language labeling mechanism, such as the alt or title attribute in HTML, or the desc element in SVG.
name is generated from the Text nodes associated with the element. Although this may be allowed in addition to "author" in some roles, "content" is used only if higher priority "author" features are not provided. Priority is defined by the text alternative computation algorithm.

Editorial Note: (Joseph) Need links into ARIA spec to (1) a list of nameFrom:author roles, and (2) a list of nameFrom:contents roles. Reference these at step 2F below.

4.1 Name Computation §

User agents MUST compute an accessible name using the rules outlined below in the section titled Text Alternative Computation.

Editorial Note (Joseph): The following special case is specific to HTML, and should be moved elsewhere.

Special Case: If the element is an img element that is exposed in the accessibility tree; and the computed text alternative is empty, then check for the presence of role presentation or any labeling attribute that specifies an empty label, specifically aria-label, aria-labelledby, alt or title. The presence of any of these indicates the author's intention to indicate that the img is decorative or redundant. In this case, the user agent MUST set the name to an empty string. If none of these attributes are present, this indicates the author simply did not provide an accessible label for the image, and the implementation MUST return an accessible name of NULL instead of an empty string if the API supports it. This hints to the assistive technology to do its own heuristic processing to repair the missing accessible name.

4.2 Description Computation §

If aria-describedby is present, user agents MUST compute the accessible description by concatenating the text alternatives for elements referenced by an aria-describedby attribute on the current element. The text alternatives for the referenced elements are computed using a number of methods, outlined below in the section titled Text Alternative Computation.

4.3 Text Alternative Computation §

The text alternative computation is used to generate both the accessible name and accessible description. There are different rules provided for several different types of elements, nodes, and combinations of markup. Text alternatives are built up, when appropriate, from all the relevant content contained within an element. This is accomplished via steps 2B and 2F, which are recursive, using the full set of rules to retrieve text from its own children or nodes it references.

The purpose of the computation is to create a perceivable label or description for alternative presentations, in the form of a flat string of space separated textual tokens.

4.3.1 Terminology §

Root node
The DOM node or element for which the text alternative is sought.
Current node
The DOM node currently traversed to compute the root node's text equivalent. Initially, the current node is the root node, but at later stages is either some descendant of the root node, or another referenced node.
Flat string
A string of characters where all carriage returns, newlines, tabs, and form-feeds are replaced with a single space, and multiple spaces are reduced to a single space. The string contains only character data; it does not contain any markup.
Total Accumulated text
The text equivalent computed up to, but not including the current node.
Accumulated text
Text accumulated at a step or sequence of steps described below. It is temporary storage for those steps.
The text equivalent computed at one of the steps described below.
Append the result, without a space, to X
  • If X is empty, copy the result to X.
  • If X is non-empty, copy the result to the end of X.
Append the result, with a space, to X
  • If X is empty, copy the result to X.
  • If X is non-empty, add a space to the end of X and then copy the result to X after the space.
Prepend result, without a space, to X
  • If X is empty, copy the result to X.
  • If X is non-empty, copy the result to the start of X.
Prepend the result, without a space, to X
  • If X is empty, copy the result to X.
  • If X is non-empty, copy the result to the start of X, and add a space after the copy.

The text alternative for a given element is computed as follows:

  1. Initialize: Set the root node to the given element, the current node to the root node, and the total accumulated text to the empty string ("").
  2. Compute the text alternative for the current node:
    1. If the current node is hidden and is not referenced by aria-labelledby or aria-describedby, nor referenced by a native host language text alternative element or attribute, return the empty string.

      By default, assistive technologies do not relay hidden information, but an author can explicitly override that and include hidden text as part of the accessible name or accessible description by using aria-labelledby or aria-describedby.

    2. Otherwise, if the current node has a non-empty aria-labelledby attribute, and the current node is not already part of an aria-labelledby traversal, process its IDREFs in the order they occur:
      1. Set the accumulated text to the empty string.
      2. For each IDREF:
        1. Set the current node to the node referenced by the IDREF.
        2. Compute the text alternative of the current node beginning with step 2. Set the result to that text alternative.
        3. Append the result, with a space, to the accumulated text.
      3. Return the accumulated text.

      Editorial note: (Joseph) Need to address aria-describedby here, using the the same loop mechanism to process the referenced nodes except where the current node is already part of an aria-describedby traversal.

      The following example shows the meaning of the clause "… and the current node is not already part of an aria-labelledby traversal …" .

      • element1's accessible name is "hello" because this is a first traversal of its aria-labelledby, leading to element3.
      • element2 has no accessible name. The computation involves a first traversal of its aria-labelledby leading to element1, but element1's aria-labelledby is not subsequently followed.
    3. Otherwise, if the current node has a non-empty aria-label attribute:
      • If traversal of the current node is due to recursion and the current node is an embedded control as defined in step 2E, ignore aria-label and skip to rule 2E.
      • Otherwise, return the value of aria-label.

      The following example shows the interaction of aria-labelledby and aria-label when a node has an aria-labelledby that refers to itself. The <span role="button"> elements have the accessible names "Delete Documentation.pdf" and "Delete HolidayLetter.pdf", respectively.

    4. Otherwise, if the current node's native markup provides an attribute or element that defines a text alternative, return that alternative as a flat string, unless the element is marked as presentational (role="presentation" or role="none").

      Editorial note: Above wording taken from second note in ISSUE-522.

      For example, in HTML, the img element's alt attribute defines a text alternative string, and the label element provides text for the referenced form element. In SVG2, the desc and title elements provide a description of their parent element.

    5. Otherwise, if the current node is a control embedded within the label of another widget, where the user can adjust the embedded control's value, then include the value of the embedded control as part of the text alternative in the following manner:
      • If the embedded control has role textbox, return its value.
      • If the embedded control has role menu button, return the text alternative of the button.
      • If the embedded control has role combobox, return the text alternative of the chosen option.
      • If the embedded control has role range (e.g., a spinbutton or slider):
        • If the aria-valuetext property is present, return its value,
        • Otherwise, if the aria-valuenow property is present, return its value,
        • Otherwise, use the value as specified by a host language attribute.

      Consider a check box label that contains a text input field: "Flash the screen [input] times". If the user has entered "5" for the embedded textbox, the complete label is "Flash the screen 5 times", e.g.:

    6. Otherwise, if the current node's role allows "Name From: contents":
      1. Set the accumulated text to the empty string.
      2. Check for CSS generated textual content associated with the current node and include it in the accumulated text:
        • The "bullet" or "number" characters associated with a list item are not present in the DOM, but are provided by the user agent's style engine. If the CSS list-style-type is not "none", user agents MUST prepend the list item indicator text to the item's text. If the list item indicator text includes a space, prepend the indicator text without a space; otherwise prepend with a space.
        • Similarly, the CSS :before and :after pseudo elements can provide textual content for elements that have a content model.
          • For :before pseudo elements, User agents MUST prepend CSS textual content, without a space, to the textual content of the current node.
          • For :after pseudo elements, User agents MUST append CSS textual content, without a space, to the textual content of the current node.
      3. For each child node of the current node:
        1. Set the current node to the child node.
        2. Compute the text alternative of the current node beginning with step 2. Set the result to that text alternative.
        3. Append the result to the accumulated text.

        Editorial Note: (Joseph) the last step above needs work since there are cases where you "append with a space" and others where you "append without a space". Example of the latter: <label> <input type="checkbox"> Make this the <em>top</em>most element</label>. The result is "Make this the topmost element", not "Make this the top most element" – do not append a space after "top".

      4. Return the accumulated text.

      Important: Each node in the subtree is consulted only once. If text has been collected from a descendant, but is referenced by another IDREF in some descendant node, then that second, or subsequent, reference is not followed. This is done to avoid infinite loops.

      This step can apply to the child nodes themselves, which means the computation is recursive and results in text collected from all the elements in the current node's subtree, no matter how deep it is. However, any given descendant node's text alternative can result from higher precedent markup described in steps B through D above, where "Namefrom: author" attributes provide the text alternative for the entire subtree.

    7. Otherwise, if the current node is a Text node, return its textual contents.
    8. Otherwise, if the current node has a tooltip attribute, return its value.

      Tooltip attributes are used only if nothing else, including subtree content, has provided results.

    Append the result of each step above, with a space, to the total accumulated text.

After all steps are completed, the total accumulated text is used as the accessible name or accessible description of the element that initiated the computation.

5. Accessible Name and Description Mapping §

Each step of the algorithm generates a flat text string. An implementation trims the text and concatenates it with the text alternative computed by previous steps. The result is a single flat string name or description associated with the element for which the text alternative computation was executed. The computed string is used to set the accessible name or accessible description property of the accessible object corresponding to the element. The specifics of each accessibility API mapping is given in the following table.

Accessible name and accessible description mapping table
Accessibility API Property MSAA + UIA Express MSAA + IAccessible2 UIA ATK/AT-SPI AXAPI
accessible name Expose in accName property. Expose in accName property.

aria-labelledby: If the referenced objects are in the accessibility tree expose pointers to them using IA2_RELATION_LABELLED_BY, and expose reverse relations as described in Relations.

Expose in Name property.

aria-labelledby: If the referenced objects are in the accessibility tree, expose pointers to them using the LabeledBy property.

Expose in the name property of the accessible object.

aria-labelledby: If the referenced objects are in the accessibility tree, expose pointers to them using RELATION_LABELLED_BY, and expose reverse relations as described in Relations.

Expose as string AXTitle, AXDescription, or AXTitleUIElement:
  • Accessible name values that are exposed visually, as in the case of a button, should be exposed as string AXTitle.
  • AXDescription is recommended for accessible name values that are not exposed visually, such as @alt and @aria-label.


  • If aria-labelledby references a single element, expose the labeling relationship as element AXTitleUIElement.
  • If aria-labelledby references multiple elements, or if the labeling element is invisible or otherwise not exposed in the accessibility tree, expose as string AXDescription.
accessible description Expose in accDescription property. Expose in accDescription property.

aria-describedby: If the referenced objects are in the accessibility tree, expose pointers to them using IA2_RELATION_DESCRIBED_BY, and expose reverse relations as described in Relations.


aria-describedby: If the referenced objects are in the accessibility tree, expose pointers to the referenced accessible objects using the DescribedBy property.

(See ACTION-1104)

Expose in the description property of the accessible object.

aria-describedby: If the referenced objects are in the accessibility tree, expose reverse relations as described in Relations.

Expose as string AXHelp.

More information concerning name and description accessibility API mappings, including relationships, such as labelled-by/label-for and described-by/description-for, is documented in the Core Accessibility API Mappings document [CORE-AAM]. See the mapping table entries for aria-label, aria-labelledby, and aria-describedby.

6. Name and Description Change Events §

Editorial Note: (Joseph) Certain Accessibility APIs emit events for name and/or description property changes. Document that here (see, for example, FF bugzilla 991969).

Although rare, sometimes an accessible name or accessible description may change. Examples include:

The following table lists the events or notifications provided by Accessibility APIs if the name or description changes. Assistive technologies can make use of these events to provide the current label as needed.

Table of events fired in each API for changes in name or desription property.
Accessibility API Property MSAA + UIA Express MSAA + IAccessible2 UIA ATK/AT-SPI AXAPI
accessible name EVENT_OBJECT_NAMECHANGE EVENT_OBJECT_NAMECHANGE ProperyChangeEvent object:property-change:accessible-name TitleChangedNotification
accessible description EVENT_OBJECT_DESCRIPTIONHANGE EVENT_OBJECT_DESCRIPTIONCHANGE ProperyChangeEvent object:property-change:accessible-description TBD.

7. Appendices §

7.1 Acknowledgments §

This section is non-normative.

The following people contributed to the development of this document.

7.1.1 Participants active in the PFWG at the time of publication §

  • Christy Blew (University of Illinois at Urbana-Champaign)
  • David Bolter (Mozilla Foundation)
  • Michael Cooper (W3C/MIT)
  • James Craig (Apple Inc.)
  • Joanmarie Diggs (Igalia)
  • Fred Esch (IBM Corporation)
  • Steve Faulkner (The Paciello Group)
  • John Foliot (Invited Expert)
  • Christopher Gallelo (Microsoft Corporation)
  • Bryan Garaventa (SSB BART Group)
  • Scott González (JQuery Foundation)
  • Billy Gregory (The Paciello Group)
  • Karl Groves (The Paciello Group)
  • Jon Gunderson (University of Illinois at Urbana-Champaign)
  • Birkir Gunnarsson (Deque Systems, Inc.)
  • Markus Gylling (DAISY Consortium)
  • Mona Heath (University of Illinois at Urbana-Champaign)
  • Susann Keohane (IBM Corporation)
  • Matthew King (IBM Corporation)
  • Jason Kiss (Department of Internal Affairs, New Zealand Government)
  • Dominic Mazzoni (Google, Inc.)
  • Shane McCarron (Invited Expert, Aptest)
  • Charles McCathieNevile (Yandex)
  • Mary Jo Mueller (IBM Corporation)
  • James Nurthen (Oracle Corporation)
  • Janina Sajka (Invited Expert, The Linux Foundation)
  • Joseph Scheuhammer (Invited Expert, Inclusive Design Research Centre, OCAD University)
  • Stefan Schnabel (SAP AG)
  • Richard Schwerdtfeger (IBM Corporation)
  • Lisa Seeman (Invited Expert)
  • Cynthia Shelly (Microsoft Corporation)
  • Alexander Surkov (Mozilla Foundation)
  • Léonie Watson (The Paciello Group)
  • Jason White (Educational Testing Service)
  • Marco Zehe (Mozilla Foundation)
  • Gottfried Zimmermann (Invited Expert, Access Technologies Group)

7.1.2 Other ARIA contributors, commenters, and previously active PFWG participants §

  • Shadi Abou-Zahra (W3C)
  • Jim Allan (TSB)
  • Jonny Axelsson (Opera Software)
  • David Baron (Mozilla Foundation)
  • Art Barstow (Nokia Corporation)
  • Simon Bates
  • Chris Blouch (AOL)
  • Judy Brewer (W3C/MIT)
  • Mark Birbeck (Sidewinder Labs)
  • Sally Cain (Royal National Institute of Blind People (RNIB))
  • Gerardo Capiel (Benetech)
  • Ben Caldwell (Trace)
  • Sofia Celic-Li
  • Jaesik Chang (Samsung Electronics Co., Ltd.)
  • Alex Qiang Chen (University of Manchester)
  • Charles Chen (Google, Inc.)
  • Christian Cohrs
  • Deborah Dahl
  • Erik Dahlström (Opera Software)
  • Dimitar Denev (Frauenhofer Gesellschaft)
  • Micah Dubinko (Invited Expert)
  • Mandana Eibegger
  • Beth Epperson (Websense)
  • Donald Evans (AOL)
  • Chris Fleizach (Apple Inc.)
  • Kelly Ford (Microsoft Corporation)
  • Geoff Freed (Invited Expert, NCAM)
  • Kentarou Fukuda (IBM Corporation)
  • Bryan Garaventa
  • Guido Geloso
  • Ali Ghassemi
  • Becky Gibson (IBM)
  • Alfred S. Gilman
  • Andres Gonzalez (Adobe Systems Inc.)
  • James Graham
  • Georgios Grigoriadis (SAP AG)
  • Jeff Grimes (Oracle)
  • Loretta Guarino Reid (Google, Inc.)
  • Katie Haritos-Shea (Invited Expert)
  • Barbara Hartel
  • James Hawkins (Google, Inc.)
  • Benjamin Hawkes-Lewis
  • Sean Hayes (Microsoft Corporation)
  • Jan Heck
  • Shawn Henry
  • Tina Homboe
  • John Hrvatin (Microsoft Corporation)
  • Takahiro Inada
  • Masayasu Ishikawa (W3C)
  • Jim Jewitt
  • Kenny Johar (Microsoft Corporation)
  • Shilpi Kapoor (BarrierBreak Technologies)
  • Masahiko Kaneko (Microsoft Corporation)
  • Marjolein Katsma
  • George Kerscher (International Digital Publishing Forum)
  • Jason Kiss (New Zealand Government)
  • Todd Kloots
  • Johannes Koch
  • Sam Kuper
  • Earl Johnson (Sun)
  • Jael Kurz
  • Rajesh Lal (Nokia Corporation)
  • Diego La Monica (International Webmasters Association / HTML Writers Guild (IWA-HWG))
  • Aaron Leventhal (IBM Corporation)
  • Gez Lemon (International Webmasters Association / HTML Writers Guild (IWA-HWG))
  • Alex Li (SAP)
  • Chris Lilley
  • Thomas Logan (HiSoftware Inc.)
  • William Loughborough (Invited Expert)
  • Linda Mao (Microsoft)
  • David MacDonald (Invited Expert, CanAdapt Solutions Inc.)
  • Carolyn MacLeod
  • Anders Markussen (Opera Software)
  • Matthew May (Adobe Systems Inc.)
  • Krzysztof Maczyński
  • Alexandre Morgaut (4D)
  • Ann Navarro (Invited Expert)
  • Joshue O Connor (Invited Expert, CFIT)
  • Artur Ortega (Microsoft Corporation)
  • Sailesh Panchang (Deque)
  • Lisa Pappas (Society for Technical Communication (STC))
  • Marta Pawlowlska (Samsung Electronics Co., Ltd.)
  • Dave Pawson (RNIB)
  • Steven Pemberton (CWI Amsterdam)
  • Simon Pieters (Opera Software)
  • Jean-Bernard Piot (4D)
  • David Poehlman, Simon Pieters (Opera Software)
  • Sarah Pulis (Media Access Australia)
  • T.V. Raman (Google, Inc.)
  • Jan Richards
  • Gregory Rosmaita (Invited Expert)
  • Tony Ross (Microsoft Corporation)
  • Alex Russell (Dojo Foundation) (
  • Mark Sadecki (W3C)
  • Mario Sánchez Prada (Samsung Electronics Co., Ltd. and Gnome Foundation)
  • Martin Schaus (SAP AG)
  • Doug Schepers (W3C)
  • Matthias Schmitt
  • Marc Silbey (Microsoft Corporation)
  • Leif Halvard Sili
  • Henri Sivonen (Mozilla)
  • Michael Smith (W3C)
  • Andi Snow-Weaver (IBM Corporation)
  • Ville Skyttä
  • Henny Swan (BBC)
  • Neil Soiffer (Design Science)
  • Vitaly Sourikov
  • Mike Squillace (IBM)
  • Maciej Stachowiak (Apple Inc.)
  • Christophe Strobbe
  • Suzanne Taylor (Pearson plc)
  • Terrill Thompson
  • David Todd
  • Gregg Vanderheiden (Invited Expert, Trace)
  • Anne van Kesteren
  • Wu Wei (W3C / RITT)
  • Ryan Williams (Oracle)
  • Tom Wlodkowski
  • Sam White (Apple Inc.)

7.1.3 Enabling funders §

This publication has been funded in part with Federal funds from the U.S. Department of Education, National Institute on Disability, Independent Living, and Rehabilitation Research (NIDILRR) under contract number ED-OSE-10-C-0067. The content of this publication does not necessarily reflect the views or policies of the U.S. Department of Education, nor does mention of trade names, commercial products, or organizations imply endorsement by the U.S. Government.

A. References §

A.1 Normative references §

Joseph Scheuhammer; Michael Cooper; Andi Snow-Weaver; Aaron Leventhal et al. Core Accessibility API Mappings 1.1. W3C Working Draft. URL: http://www.w3.org/TR/core-aam-1.1/
S. Bradner. Key words for use in RFCs to Indicate Requirement Levels. March 1997. Best Current Practice. URL: https://tools.ietf.org/html/rfc2119
James Craig; Michael Cooper; Shane McCarron et al. Accessible Rich Internet Applications (WAI-ARIA) 1.1. W3C Working Draft. URL: http://www.w3.org/TR/wai-aria-1.1/
Joseph Scheuhammer; Michael Cooper. WAI-ARIA 1.0 User Agent Implementation Guide. 20 March 2014. W3C Recommendation. URL: http://www.w3.org/TR/wai-aria-implementation/

A.2 Informative references §

Assistive Technology Service Provider Interface. URL: https://developer.gnome.org/libatspi/stable/
ATK - Accessibility Toolkit. URL: https://developer.gnome.org/atk/stable/
The Mac OS X Accessibility Protocol Mac OS 10.10. URL: https://developer.apple.com/library/mac/documentation/Cocoa/Reference/ApplicationKit/Protocols/NSAccessibility_Protocol/index.html
IAccessible2. URL: http://www.linuxfoundation.org/collaborate/workgroups/accessibility/iaccessible2
Microsoft Active Accessibility (MSAA) 2.0. URL: http://msdn.microsoft.com/en-us/library/ms697707.aspx
UI Automation. URL: http://msdn.microsoft.com/en-us/library/ee684009%28v=vs.85%29.aspx
The IAccessibleEx Interface. URL: http://msdn.microsoft.com/en-us/library/windows/desktop/dd561898%28v=vs.85%29.aspx
Joseph Scheuhammer; Michael Cooper. WAI-ARIA 1.0 Authoring Practices. 7 March 2013. W3C Working Draft. URL: http://www.w3.org/TR/wai-aria-practices/
Ben Caldwell; Michael Cooper; Loretta Guarino Reid; Gregg Vanderheiden et al. Web Content Accessibility Guidelines (WCAG) 2.0. 11 December 2008. W3C Recommendation. URL: http://www.w3.org/TR/WCAG20/