W3C Candidate Recommendation Draft 05 August 2026

Abstract

This document describes how user agents should expose semantics of web content languages to accessibility APIs. This helps users with disabilities to obtain and interact with information using assistive technologies. Documenting these mappings promotes interoperable exposure of roles, states, properties, and events implemented by accessibility APIs and helps to ensure that this information appears in a manner consistent with author intent.

This Core Accessibility API Mappings specification defines support that applies across multiple content technologies, including general keyboard navigation support and mapping of general-purpose roles, states, and properties provided in Web content via WAI-ARIA [WAI-ARIA-1.2]. Other Accessibility API Mappings specifications depend on and extend this Core specification for specific technologies, including native technology features and WAI-ARIA extensions. This document updates and will eventually supersede the guidance in the Core Accessibility API Mappings 1.1 [CORE-AAM-1.1] 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. A list of current W3C publications and the latest revision of this technical report can be found in the W3C standards and drafts index.

The Accessible Rich Internet Applications Working Group seeks feedback on any aspect of the specification. When submitting feedback, please consider issues in the context of the companion documents. To comment, file an issue in the W3C core-aam GitHub repository. If this is not feasible, send email to public-aria@w3.org (comment archive). In-progress updates to the document may be viewed in the publicly visible editors' draft.

Living specification — This document is maintained as a living specification. For the latest normative version, visit Core Accessibility API Mappings.

This document was published by the Accessible Rich Internet Applications Working Group as a Candidate Recommendation Draft using the Recommendation track.

Publication as a Candidate Recommendation does not imply endorsement by W3C and its Members. A Candidate Recommendation Draft integrates changes from the previous Candidate Recommendation that the Working Group intends to include in a subsequent Candidate Recommendation Snapshot.

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 a work in progress.

This document was produced by a group operating under the 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 that 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 18 August 2025 W3C Process Document.

This section is non-normative.

The Core Accessibility API Mappings specifies how WAI-ARIA roles, states, and properties are expected to be exposed by user agents via platform accessibility APIs. It is part of a set of resources that define and support the WAI-ARIA specification which includes the following documents:

Accessible Rich Internet Applications (WAI-ARIA) 1.2 [WAI-ARIA-1.2], a W3C recommendation, defines the WAI-ARIA standard.
WAI-ARIA Authoring Practices Guide, describes how web content developers can develop accessible rich internet applications using WAI-ARIA. It provides detailed advice and examples directed primarily to web application developers, yet also useful to user agent and developers of assistive technologies.
Roadmap for Accessible Rich Internet Applications (WAI-ARIA Roadmap) [WAI-ARIA-ROADMAP], defines the path to make rich web content accessible, including steps already taken, remaining future steps, and a time line.

For an introduction to WAI-ARIA, see the WAI-ARIA Overview.

Accessibility APIs make it possible to communicate accessibility information about user interfaces to assistive technologies. This information includes:

Descriptive properties (role, name, value, position, etc.)
Transient states (pressed, focused, etc.)
Events (text changed, button was clicked, checkbox was toggled)
Actions the user might take (click, check/toggle, drag, etc.)
Relationships (parent/child, description/described object, previous object/next object, etc.)
Textual content

Accessibility APIs covered by this specification are:

MSAA with IAccessible2 1.3 [IAccessible2]
User Interface Automation [UI-AUTOMATION]
ATK - Accessibility Toolkit [ATK] and Assistive Technology Service Provider Interface [AT-SPI], referred to hereafter as "ATK/AT-SPI"
macOS Accessibility Protocol [AXAPI]
Android [Android-Accessibility-API]

The WAI-ARIA 1.0 User Agent Implementation Guide included mappings for [UIA-EXPRESS], also known as IAccessibleEx, which was implemented in Microsoft Internet Explorer 8.0 - 11. New implementations are strongly encouraged to use UI Automation instead.

If user agent developers need to expose information using other accessibility APIs, it is recommended that they work closely with the developer of the platform where the API runs, and assistive technology developers on that platform.

For various technological and historical reasons, accessibility APIs do not all work in the same way. In many cases, there is no simple one-to-one relationship between how each of them names or exposes roles, states, and properties to assistive technologies. The following subsections describe a few of the distinguishing characteristics of some of the APIs.

MSAA, IAccessible2, UIA, and AX API each define an API that is shared by both the software application exposing information about its content and interactive components, and the assistive technology consuming that information. Conversely, Linux/GNOME separates that shared interface into its two aspects, each represented by a different accessibility API: ATK or AT-SPI.

ATK defines an interface that is implemented by software in order to expose accessibility information, whereas AT-SPI is a desktop service that gathers accessibility information from active applications and relays it to other interested applications, usually assistive technologies.

For example, the GNOME GUI toolkit [GTK], implements the relevant aspects of ATK for each widget (menu, combobox, checkbox, etc.) in order that GTK widgets expose accessibility information about themselves. AT-SPI then acquires the information from applications built with GTK and makes it available to interested parties.

ATK is most relevant to implementors, whereas AT-SPI is relevant to consumers. In the context of mapping WAI-ARIA roles, states and properties, user agents are implementors and use ATK. Assistive Technologies are consumers, and use AT-SPI.

UI Automation expresses every element of the application user interface as an automation element. Automation elements form the nodes of the application accessibility tree, that can be queried, traversed and interacted with by automation clients.

There are several concepts central to UI Automation:

Automation element - controls and some application content are presented as automation elements.
Element properties - Automation elements have several common properties describing native framework element characteristics in an agnostic way that all automation clients can understand. There are several ways to access element property values, described below.
Control Patterns - Some common interactivity in different frameworks is expressed as control patterns in UIA, allowing different automation clients to interact with controls using common programmatic interfaces.
Events - Similar to other accessibility APIs, automation elements support various events that allow automation providers to notify clients on important state changes.

All automation elements inherit from the IUIAutomationElement interface and all properties that are not specific to a particular control pattern can be queried through that interface. There are several ways to access UI Automation element properties:

Direct property accessors to the current values - Current{PropertyName}, e.g. IUIAutomationElement::CurrentName for the Name property
Cached property accessors - Cached{PropertyName}, e.g. IUIAutomationElement::CachedName for the Name property. Using cached values is preferred when providers and clients are used in remote environments.
GetCurrentPropertyValue and passing the UIA Property ID enumeration value corresponding to that property to get the current value, e.g. IUIAutomationElement::GetCurrentPropertyValue(UIA_NamePropertyId) for the Name property.
GetCachedPropertyValue and passing the UIA Property ID enumeration value corresponding to that property to get the cached value, e.g. IUIAutomationElement::GetCachedPropertyValue(UIA_NamePropertyId) for the Name property.

Properties for specific UIA control patterns are queried the same way using relevant control pattern interfaces. Taking Toggle Pattern as an example, to query the ToggleState property clients can use IUIAutomationTogglePattern::CurrentToggleState or IUIAutomationElement::GetCurrentPropertyValue(UIA_ToggleToggleStatePropertyId) to get the current value.

The property mappings in this specification provide the {PropertyName} and do not specify all specific ways to access the property value. Automation clients can access current or cached values using conventions described above, depending on specific needs and coding style conventions.

Android accessibility services and applications both express user interface elements as a tree of AccessibilityNodeInfo objects. Accessibility services receive events, traverse the AccessibilityNodeInfo tree, retrieve properties, and perform actions on a node. Conversely, Android applications build the AccessibilityNodeInfo tree indirectly by constructing views or composables, or directly via an AccessibilityNodeProvider. They then subsequently fire events, and handle actions.

For WAI-ARIA implementers, of particular interest is the mapping into properties, actions, and events on AccessibilityNodeInfo and AccessibilityEvent.

Note: Many ARIA roles in this specification are mapped to android.view.View as a default or fallback mapping. This often reflects a baseline level of support where a more specific Android widget class is not available or has not been defined yet. These mappings are subject to change as the Android accessibility ecosystem evolves and more specific mappings are identified. In cases where no specific role mapping is available, Android's setRoleDescription can be used to convey the specific ARIA role semantics to assistive technologies.

Each platform accessibility API includes a way to assign and retrieve accessible name and accessible description properties for each accessible object created in the accessibility tree. How these properties are implemented and what they are called vary depending on the API.

For instance, in MSAA, all accessible objects support the accName property, which stores the object's accessible name. Where the object also supports having an accessible description, MSAA stores this property in the object's accDescription property.

Software using ATK can read and write to an object's accessible-name and accessible-description properties. In turn, AT-SPI can query the values of those properties through its atspi_accessible_get_name and atspi_accessible_get_description functions.

Automation elements in the UIA accessibility tree have a Name property. Where the object also supports having an accessible description, UIA stores this property in the object's FullDescription property.

An object's accessible description, where provided by aria-description or aria-describedby, should be exposed in the accessibilityCustomContent API. Otherwise, it should be exposed as AXHelp.

In Android, accessible names map to a number of properties defined on AccessibilityNodeInfo such as content description, supplemental description, and text.

For more detail, see the Accessible Name and Description Computation specification.

As well as sections marked as non-normative, all authoring guidelines, diagrams, examples, and notes in this specification are non-normative. Everything else in this specification is normative.

The key words MAY, MUST, MUST NOT, SHOULD, and SHOULD NOT in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

Normative sections provide requirements that user agents and assistive technologies MUST follow for an implementation to conform to this specification.

Non-normative (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.

The WAI-ARIA specification lists some features as deprecated. Although this means authors are encouraged not to use such features, it is expected that the features could still be used in legacy content. Therefore, it is important that user agents continue to map these features to accessibility APIs, and doing so is part of conformance to this specification. When future versions of the WAI-ARIA specification change such features from deprecated to removed, they will be removed from the mappings as well and user agents will no longer be asked to continue support for those features.

Where supported by the platform Accessibility API, user agents expose WAI-ARIA semantics through the standard mechanisms of the desktop accessibility API. For example, for WAI-ARIA widgets, compare how the widget is exposed in a similar desktop widget. In general most WAI-ARIA widget capabilities are exposed through the role, value, Boolean states, and relations of the accessibility API.

With respect to WAI-ARIA 1.0 and 1.1, accessibility APIs operate in one direction only. User agents publish WAI-ARIA information (roles, states, and properties) via an accessibility API, and an AT can acquire that information using the same API. However, the other direction is not supported. WAI-ARIA 1.0 and 1.1 do not define mechanisms for assistive technologies to directly modify WAI-ARIA information.

The terms "exposing", "mapping", and "including" refer to the creation of accessible object nodes within the accessibility tree, and populating these objects with Accessibility API specific states and properties.

WAI-ARIA roles, states, and properties are intended to add semantic information when native host language elements with these semantics are not available, and are generally used on elements that have no native semantics of their own. They can also be used on elements that have similar but not identical semantics to the intended object (for instance, a nested list could be used to represent a tree structure). This method can be part of a fallback strategy for older browsers that have no WAI-ARIA implementation, or because native presentation of the repurposed element reduces the amount of style and/or script needed. Except for the cases outlined below, user agents MUST always use the WAI-ARIA semantics to define how it exposes the element to accessibility APIs, rather than using the host language semantics.

Host languages can have features that have implicit WAI-ARIA semantics corresponding to roles. When a WAI-ARIA role is provided that has a corresponding role in the accessibility API, user agents MUST use the semantic of the WAI-ARIA role for processing, not the native semantic, unless the role requires WAI-ARIA states and properties whose attributes are explicitly forbidden on the native element by the host language. Values for roles do not conflict in the same way as values for states and properties, and because authors are expected to have a valid reason to provide a WAI-ARIA role even on elements that would not normally be repurposed. For example, spin buttons are typically constructed from text fields (<input type="text">) in order to get most of the default keyboard support. But, the native role, "text field", is not correct because it does not properly communicate the additional features of a spin button. The author adds the WAI-ARIA role of spinbutton (<input type="text" role="spinbutton" ...>) so that the control is properly mapped in the accessibility API. When a WAI-ARIA role is provided that does not have a corresponding role in the accessibility API, user agents MAY expose the native semantic in addition to the WAI-ARIA role. If the host language element is overridden by a WAI-ARIA role whose semantics or structure is not equivalent to the native host language semantics or to a subclass of those semantics, then treat any child elements having roles specified as Allowed Accessibility Child Roles as having presentation or none.

Note

The above text differs slightly from the WAI-ARIA specification. The requirement for user agents to expose the WAI-ARIA role instead of the native role was intended to only apply in cases where there is a direct mapping from the WAI-ARIA role to a corresponding role in the accessibility API. The wording of the requirement is not clear in the WAI-ARIA specification, however, and has been interpreted differently by implementers. The requirement has been clarified here and an additional statement added to indicate that user agents may expose native semantics if there is not a direct mapping to a role in the accessibility API. Because there are differing implementations, authors will be advised against adding such WAI-ARIA roles to native elements that have their own semantics in the WAI-ARIA Authoring Practices Guide.

When WAI-ARIA states and properties correspond to host language features that have the same implicit WAI-ARIA semantic, it can be problematic if the values become out of sync. For example, the HTML checked attribute and the aria-checked attribute could have conflicting values. Therefore to prevent providing conflicting states and properties to assistive technologies, host languages will explicitly declare where the use of WAI-ARIA attributes on a host language element conflict with native attributes for that element. When a host language declares a WAI-ARIA attribute to be in direct semantic conflict with a native attribute for a given element, user agents MUST ignore the WAI-ARIA attribute and instead use the host language attribute with the same implicit semantic.

Host languages might also document features that cannot be overridden with WAI-ARIA (these are called "strong native semantics"). These can be features that have implicit WAI-ARIA semantics as well as features where the processing would be uncertain if the semantics were changed with WAI-ARIA. While conformance checkers might signal an error or warning when a WAI-ARIA role is used on elements with strong native semantics, user agents MUST still use the value of the semantic of the WAI-ARIA role when exposing the element to accessibility APIs.

Platform accessibility APIs might have features that are not in WAI-ARIA. Likewise, WAI-ARIA exposes capabilities that are not supported by accessibility APIs at the time of publication. There typically is not a one to one relationship between all WAI-ARIA attributes and platform accessibility APIs. When WAI-ARIA roles, states and properties do not directly map to an accessibility API, and there is a mechanism in the API to expose the WAI-ARIA role, states, and properties and their values, user agents MUST expose the WAI-ARIA data using that mechanism as follows:

In IAccessible2 and ATK/AT-SPI, use object attributes to expose semantics that are not directly supported in the APIs. Object attributes are name-value pairs that are loosely specified, and very flexible for exposing things where there is no specific interface in an accessibility API. For example, at this time, the aria-live attribute can be exposed via an object attribute because accessibility APIs have no such property available. Specific rules for exposing object attribute name-value pairs are described throughout this document, and rules for the general cases are in State and Property Mapping.
In Microsoft UIA, use the AriaRole and AriaProperties properties to expose semantics that are not directly supported in the control type.

Note

MSAA does not provide a mechanism for exposing attributes that do not map directly to the API and among implementers, there is no agreement on how to do it.

User agents MUST also expose the entire role string through this mechanism and MAY also expose WAI-ARIA attributes and values through this mechanism even when there is a direct mapping to an accessibility API.

Browser implementers are advised to publicly document their API methods for exposing any relevant information, so that assistive technology developers can use the API to support user features.

Platform accessibility APIs traditionally have had a finite set of predefined roles that are expected by assistive technologies on that platform and only one or two roles may be exposed. In contrast, WAI-ARIA allows multiple roles to be specified as an ordered set of space-separated valid role tokens. The additional roles are fallback roles similar to the concept of specifying multiple fonts in case the first choice font type is not supported.

User agents MUST expose the WAI-ARIA role string if the API supports a mechanism to do so. This allows assistive technologies to do their own additional processing of roles.

MSAA: not supported. User agents SHOULD NOT expose a custom role in MSAA's accRole property.
IAccessible2: expose as an object attribute pair (xml-roles:"string")
UIA: expose as AriaRole property. The AriaRole property can also support secondary roles using a space as a separator.
ATK/AT-SPI: expose as an object attribute pair (xml-roles:"string")

The computedrole of an element is a string that represents the role of the element as computed by the browser engine. The computedrole is used primarily for the purposes of developer tools and specification conformance and interoperability testing.

Note

When an element has a role but is not contained in the required context (for example, an orphaned listitem without the required accessible parent of role list), this is an authoring error, but the user agent behavior is not specified as a single rule. For most roles, user agents can either recover the error by ignoring the role, or respect the author's intended role in scenarios deemed by the implementation to be harmless. Please note that this permissiveness in how engines treat author role errors might be overridden in a language-specific mapping document such as [HTML-AAM].

When host language elements do not have an exact or equivalent mapping to a valid, non-abstract role, the related Accessibilty API Mapping extension specification MAY specify a unique computedrole string as the return value for interoperability testing purposes, such as <video> -> "html-video" in [HTML-AAM]. However, authors MUST NOT use any host-language-prefixed computedrole string in the role attribute (such as html-video), unless the token also matches valid, defined role (such as dpub-chapter). User Agents MUST ignore any abstract or invalid role token.

ARIA Specification	`alert`
Computed Role	`alert`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_ALERT` Event: The user agent SHOULD fire `EVENT_SYSTEM_ALERT`. ^{[Note 2]}
UIA	Control Type: `Group` Localized Control Type: `alert` LiveSetting: `Assertive (2)` Event: The user agent SHOULD fire a system alert event. ^{[Note 2]}
ATK/AT-SPI	Role: `ROLE_NOTIFICATION` Event: The user agent SHOULD fire a system alert event. ^{[Note 2]}
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXApplicationAlert` Event: The user agent SHOULD fire a system alert event. ^{[Note 2]}
Android	`android.view.View`

ARIA Specification	`alertdialog`
Computed Role	`alertdialog`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_DIALOG` Event: The user agent SHOULD fire `EVENT_SYSTEM_ALERT`. ^{[Note 2]}
UIA	Control Type: `Pane` Event: The user agent SHOULD fire a system alert event. ^{[Note 2]}
ATK/AT-SPI	Role: `ROLE_ALERT` ATK Interface: `Window` Event: The user agent SHOULD fire a system alert event. ^{[Note 2]}
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXApplicationAlertDialog` Event: The user agent SHOULD fire a system alert event. ^{[Note 2]}
Android	`android.app.Dialog / android.app.AlertDialog`

ARIA Specification	`application`
Computed Role	`application`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_APPLICATION`
UIA	Control Type: `Pane` Localized Control Type: `application`
ATK/AT-SPI	Role: `ROLE_EMBEDDED`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXWebApplication`
Android	`android.view.View`

ARIA Specification	`article`
Computed Role	`article`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_DOCUMENT` State: `STATE_SYSTEM_READONLY` Object Attribute: `xml-roles:article`
UIA	Control Type: `Group` Localized Control Type: `article`
ATK/AT-SPI	Role: `ROLE_ARTICLE` Object Attribute: `xml-roles:article`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXDocumentArticle`
Android	`android.view.View`

ARIA Specification	`blockquote`
Computed Role	`blockquote`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING` Role: `IA2_ROLE_BLOCK_QUOTE`
UIA	Control Type: `Group` Localized Control Type: `blockquote`
ATK/AT-SPI	Role: `ROLE_BLOCK_QUOTE`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `<nil>`
Android	`android.view.View`

ARIA Specification	`button` with default values for `aria-pressed` and `aria-haspopup`
Computed Role	`button`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_PUSHBUTTON`
UIA	Control Type: `Button`
ATK/AT-SPI	Role: `ROLE_PUSH_BUTTON`
AX API^{[Note 1]}	AXRole: `AXButton` AXSubrole: `<nil>`
Android	`android.widget.Button`

ARIA Specification	`button` with defined value for `aria-pressed`
Computed Role	`button`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_PUSHBUTTON` Role: `IA2_ROLE_TOGGLE_BUTTON`
UIA	Control Type: `Button`
ATK/AT-SPI	Role: `ROLE_TOGGLE_BUTTON`
AX API^{[Note 1]}	AXRole: `AXCheckBox` AXSubrole: `AXToggle`
Android	`android.widget.ToggleButton`

ARIA Specification	`caption`
Computed Role	`caption`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING` Role: `IA2_ROLE_CAPTION`
UIA	Control Type: `Text`
ATK/AT-SPI	Role: `ROLE_CAPTION`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `<nil>`
Android	`android.view.View`

ARIA Specification	`cell`
Computed Role	`cell`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_CELL` Interface: `IAccessibleTableCell`
UIA	Control Type: `DataItem` Localized Control Type: `item` Control Pattern: `GridItem` Control Pattern: `TableItem`
ATK/AT-SPI	Role: `ROLE_TABLE_CELL` Interface: `TableCell`
AX API^{[Note 1]}	AXRole: `AXCell` AXSubrole: `<nil>`
Android	`android.view.View`

ARIA Specification	`checkbox`
Computed Role	`checkbox`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_CHECKBUTTON` See also: `aria-checked` in the State and Property Mapping Tables
UIA	Control Type: `CheckBox` See also: `aria-checked` in the State and Property Mapping Tables
ATK/AT-SPI	Role: `ROLE_CHECK_BOX` See also: `aria-checked` in the State and Property Mapping Tables
AX API^{[Note 1]}	AXRole: `AXCheckBox` AXSubrole: `<nil>` See also: `aria-checked` in the State and Property Mapping Tables
Android	`android.widget.CheckBox`

ARIA Specification	`code`
Computed Role	`code`
MSAA + IAccessible2	Role: `IA2_ROLE_TEXT_FRAME` Object Attribute: `xml-roles:code`
UIA	Control Type: `Text` Localized Control Type: `code`
ATK/AT-SPI	Role: `ROLE_STATIC` Object Attribute: `xml-roles:code`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXCodeStyleGroup`
Android	`android.view.View`

ARIA Specification	`columnheader`
Computed Role	`columnheader`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_COLUMNHEADER` Interface: `IAccessibleTableCell`
UIA	Control Type: `DataItem` Localized Control Type: `column header` Control Pattern: `GridItem` Control Pattern: `TableItem`
ATK/AT-SPI	Role: `ROLE_COLUMN_HEADER` Interface: `TableCell`
AX API^{[Note 1]}	AXRole: `AXCell` AXSubrole: `<nil>`
Android	`android.view.View`

ARIA Specification	`combobox`
Computed Role	`combobox`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_COMBOBOX` State: `STATE_SYSTEM_HASPOPUP` State: `STATE_SYSTEM_COLLAPSED` if `aria-expanded` is not `"true"`
UIA	Control Type: `ComboBox`
ATK/AT-SPI	Role: `ROLE_COMBO_BOX` State: `STATE_EXPANDABLE` State: `STATE_HAS_POPUP`
AX API^{[Note 1]}	AXRole: `AXComboBox` AXSubrole: `<nil>`
Android	`android.widget.EditText`

ARIA Specification	`complementary`
Computed Role	`complementary`
MSAA + IAccessible2	Role: `IA2_ROLE_LANDMARK` Object Attribute: `xml-roles:complementary`
UIA	Control Type: `Group` Localized Control Type: `complementary` Landmark Type: `Custom` Localized Landmark Type: `complementary`
ATK/AT-SPI	Role: `ROLE_LANDMARK` Object Attribute: `xml-roles:complementary`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXLandmarkComplementary`
Android	`android.view.View`

ARIA Specification	`contentinfo`
Computed Role	`contentinfo`
MSAA + IAccessible2	Role: `IA2_ROLE_LANDMARK` Object Attribute: `xml-roles:contentinfo`
UIA	Control Type: `Group` Localized Control Type: `content information` Landmark Type: `Custom` Localized Landmark Type: `content information`
ATK/AT-SPI	Role: `ROLE_LANDMARK` Object Attribute: `xml-roles:contentinfo`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXLandmarkContentInfo`
Android	`android.view.View`

ARIA Specification	`definition`
Computed Role	`definition`
MSAA + IAccessible2	Object Attribute: `xml-roles:definition`
UIA	Control Type: `Group` Localized Control Type: `definition`
ATK/AT-SPI	Role: `ROLE_DESCRIPTION_VALUE` Object Attribute: `xml-roles:definition`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXDefinition`
Android	`android.view.View`

ARIA Specification	`deletion`
Computed Role	`deletion`
MSAA + IAccessible2	Role: `IA2_ROLE_CONTENT_DELETION`
UIA	Control Type: `Text` Localized Control Type: `deletion`
ATK/AT-SPI	Role: `ROLE_CONTENT_DELETION` Object Attribute: `xml-roles:deletion`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXDeleteStyleGroup` AXAttributedStringForTextMarkerRange: contains `AXIsSuggestedDeletion = 1;` for all text contained in a `deletion`
Android	`android.view.View`

ARIA Specification	`dialog`
Computed Role	`dialog`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_DIALOG`
UIA	Control Type: `Pane`
ATK/AT-SPI	Role: `ROLE_DIALOG` ATK Interface: `Window`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXApplicationDialog`
Android	`android.app.Dialog / android.app.AlertDialog`

ARIA Specification	`directory`
Computed Role	list
MSAA + IAccessible2	Role: `ROLE_SYSTEM_LIST`
UIA	Control Type: `List`
ATK/AT-SPI	Role: `ROLE_LIST`
AX API^{[Note 1]}	AXRole: `AXList` AXSubrole: `AXContentList`
Android	`android.view.View`

ARIA Specification	`document`
Computed Role	`document`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_DOCUMENT` State: `STATE_SYSTEM_READONLY`
UIA	Control Type: `Document`
ATK/AT-SPI	Role: `ROLE_DOCUMENT_FRAME`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXDocument`
Android	`android.view.View`

ARIA Specification	`emphasis`
Computed Role	`emphasis`
MSAA + IAccessible2	Role: `IA2_ROLE_TEXT_FRAME` Object Attribute: `xml-roles:emphasis`
UIA	Control Type: `Text` Localized Control Type: `emphasis`
ATK/AT-SPI	Role: `ROLE_STATIC` Object Attribute: `xml-roles:emphasis`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXEmphasisStyleGroup`
Android	`android.view.View`

ARIA Specification	`feed`
Computed Role	`feed`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING` Object Attribute: `xml-roles:feed`
UIA	Control Type: `Group` Localized Control Type: `feed`
ATK/AT-SPI	Role: `ROLE_PANEL` Object Attribute: `xml-roles:feed`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXApplicationGroup`
Android	`android.view.View`

ARIA Specification	`figure`
Computed Role	`figure`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING` Object Attribute: `xml-roles:figure`
UIA	Control Type: `Group` Localized Control Type: `figure`
ATK/AT-SPI	Role: `ROLE_PANEL` Object Attribute: `xml-roles:figure`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `<nil>`
Android	`android.view.View`

ARIA Specification	`form` with an accessible name
Computed Role	`form`
MSAA + IAccessible2	Role: `IA2_ROLE_FORM` Object Attribute: `xml-roles:form`
UIA	Control Type: `Group` Localized Control Type: `form` Landmark Type: `Form`
ATK/AT-SPI	Role: `ROLE_LANDMARK` Object Attribute: `xml-roles:form`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXLandmarkForm`
Android	`android.view.View`

ARIA Specification	`form` without an accessible name
Computed Role	`form`
MSAA + IAccessible2	Do not expose the element as a landmark. Use the native host language role of the element instead.
UIA	Do not expose the element as a landmark. Use the native host language role of the element instead.
ATK/AT-SPI	Do not expose the element as a landmark. Use the native host language role of the element instead.
AX API^{[Note 1]}	Do not expose the element as a landmark. Use the native host language role of the element instead.
Android	`android.view.View`

ARIA Specification	`generic`
Computed Role	`generic`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING` Role: `IA2_ROLE_SECTION`
UIA	Control Type: `Group`
ATK/AT-SPI	Role: `ROLE_SECTION`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `<nil>`
Android	`android.view.View` Note: Exposed as `android.widget.TextView` if the element has only text children.

ARIA Specification	`grid`
Computed Role	`grid`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_TABLE` Object Attribute: `xml-roles:grid` Interface: `IAccessibleTable2` Method: `IAccessible::accSelect()` Method: `IAccessible::get_accSelection()`
UIA	Control Type: `DataGrid` Control Pattern: `Grid` Control Pattern: `Table` Control Pattern: `Selection`
ATK/AT-SPI	Role: `ROLE_TABLE` Object Attribute: `xml-roles:grid` Interface: `Table` Interface: `Selection` Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return `false` for all `Selection` methods that provide a means to modify the selection.
AX API^{[Note 1]}	AXRole: `AXTable` AXSubrole: `<nil>` AXColumnHeaderUIElements: a list of pointers to the columnheader elements AXHeader: a pointer to the row or group containing those columnheader elements AXRowHeaderUIElements: a list of pointers to the rowheader elements
Android	`android.widget.GridView`

ARIA Specification	`gridcell`
Computed Role	`gridcell`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_CELL` Interface: `IAccessibleTableCell`
UIA	Control Type: `DataItem` Localized Control Type: `item` Control Pattern: `SelectionItem` Control Pattern: `GridItem` Control Pattern: `TableItem` SelectionItem.SelectionContainer: the containing `grid`
ATK/AT-SPI	Role: `ROLE_TABLE_CELL` Interface: `TableCell`
AX API^{[Note 1]}	AXRole: `AXCell` AXSubrole: `<nil>`
Android	`android.view.View`

ARIA Specification	`group`
Computed Role	`group`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING`
UIA	Control Type: `Group`
ATK/AT-SPI	Role: `ROLE_PANEL`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXApplicationGroup`
Android	`android.view.View`

ARIA Specification	`heading`
Computed Role	`heading`
MSAA + IAccessible2	Role: `IA2_ROLE_HEADING` Object Attribute: `xml-roles:heading`
UIA	Control Type: `Text` Localized Control Type: `heading`
ATK/AT-SPI	Role: `ROLE_HEADING`
AX API^{[Note 1]}	AXRole: `AXHeading` AXSubrole: `<nil>`
Android	`android.view.View` Method: `AccessibilityNodeInfo.isHeading`: `true` Note: Exposed as `android.widget.TextView` if the element has only text children.

ARIA Specification	`image`
Computed Role	`image`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GRAPHIC` Interface: `IAccessibleImage`
UIA	Control Type: `Image`
ATK/AT-SPI	Role: `ROLE_IMAGE` Interface: `Image`
AX API^{[Note 1]}	AXRole: `AXImage` AXSubrole: `<nil>`
Android	`android.widget.Image`

ARIA Specification	`img`
Computed Role	`image`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GRAPHIC` Interface: `IAccessibleImage`
UIA	Control Type: `Image`
ATK/AT-SPI	Role: `ROLE_IMAGE` Interface: `Image`
AX API^{[Note 1]}	AXRole: `AXImage` AXSubrole: `<nil>`
Android	`android.widget.Image / android.widget.ImageButton`

ARIA Specification	`insertion`
Computed Role	`insertion`
MSAA + IAccessible2	Role: `IA2_ROLE_CONTENT_INSERTION`
UIA	Control Type: `Text` Localized Control Type: `insertion`
ATK/AT-SPI	Role: `ROLE_CONTENT_INSERTION` Object Attribute: `xml-roles:insertion`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXInsertStyleGroup` AXAttributedStringForTextMarkerRange: contains `AXIsSuggestedInsertion = 1;` for all text contained in a `insertion`
Android	`android.view.View`

ARIA Specification	`link`
Computed Role	`link`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_LINK` State: `STATE_SYSTEM_LINKED` State: `STATE_SYSTEM_LINKED` on its descendants Interface: `IAccessibleHypertext`
UIA	Control Type: `HyperLink` Control Pattern: `Value`
ATK/AT-SPI	Role: `ROLE_LINK` Interface: `HyperlinkImpl`
AX API^{[Note 1]}	AXRole: `AXLink` AXSubrole: `<nil>`
Android	`android.view.View` Method: `AccessibilityNodeInfo.getText` returns text containing an `android.text.style.URLSpan` when exposed as part of formatted text.

ARIA Specification	`list`
Computed Role	`list`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_LIST` State: `STATE_SYSTEM_READONLY`
UIA	Control Type: `List`
ATK/AT-SPI	Role: `ROLE_LIST`
AX API^{[Note 1]}	AXRole: `AXList` AXSubrole: `AXContentList`
Android	`android.widget.ListView`

ARIA Specification	`listbox`
Computed Role	`listbox`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_LIST` Method: `IAccessible::accSelect()` Method: `IAccessible::get_accSelection()`
UIA	Control Type: `List` Control Pattern: `Selection`
ATK/AT-SPI	Role: `ROLE_LIST_BOX` Interface: `Selection` Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return `false` for all `Selection` methods that provide a means to modify the selection.
AX API^{[Note 1]}	AXRole: `AXList` AXSubrole: `<nil>`
Android	`android.widget.ListView`

ARIA Specification	`listbox`
Computed Role	`listbox`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_LIST` Method: `IAccessible::accSelect()` Method: `IAccessible::get_accSelection()`
UIA	Control Type: `List` Control Pattern: `Selection`
ATK/AT-SPI	Role: `ROLE_MENU` Interface: `Selection` Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return `false` for all `Selection` methods that provide a means to modify the selection.
AX API^{[Note 1]}	AXRole: `AXList` AXSubrole: `<nil>`
Android	`android.widget.ListView`

ARIA Specification	`listitem`
Computed Role	`listitem`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_LISTITEM` State: `STATE_SYSTEM_READONLY`
UIA	Control Type: `ListItem` Control Pattern: `SelectionItem` SelectionItem.SelectionContainer: the containing `list`
ATK/AT-SPI	Role: `ROLE_LIST_ITEM`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `<nil>`
Android	`android.view.View`

ARIA Specification	`log`
Computed Role	`log`
MSAA + IAccessible2	Object Attribute: `xml-roles:log` Object Attribute: `container-live:polite` Object Attribute: `live:polite` Object Attribute: `container-live-role:log`
UIA	Control Type: `Group` Localized Control Type: `log` LiveSetting: `Polite (1)`
ATK/AT-SPI	Role: `ROLE_LOG` Object Attribute: `xml-roles:log` Object Attribute: `container-live:polite` Object Attribute: `live:polite` Object Attribute: `container-live-role:log`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXApplicationLog`
Android	`android.view.View`

ARIA Specification	`main`
Computed Role	`main`
MSAA + IAccessible2	Role: `IA2_ROLE_LANDMARK` Object Attribute: `xml-roles:main`
UIA	Control Type: `Group` Localized Control Type: `main` Landmark Type: `Main`
ATK/AT-SPI	Role: `ROLE_LANDMARK` Object Attribute: `xml-roles:main`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXLandmarkMain`
Android	`android.view.View`

ARIA Specification	`mark`
Computed Role	`mark`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING` Role: `IA2_ROLE_MARK` Object Attribute: `xml-roles:mark`
UIA	Control Type: `Group`
ATK/AT-SPI	Role: `ROLE_MARK` Object Attribute: `xml-roles:mark`
AX API^{[Note 1]}	AXRole: `AXGroup` AXRoleDescription: `highlight` AXAttributedStringForTextMarkerRange: contains `AXHighlight = 1;` for all text contained in a `mark`
Android	`android.view.View`

ARIA Specification	`marquee`
Computed Role	`marquee`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_ANIMATION` Object Attribute: `xml-roles:marquee`
UIA	Control Type: `Group` Localized Control Type: `marquee`
ATK/AT-SPI	Role: `ROLE_MARQUEE`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXApplicationMarquee`
Android	`android.view.View`

ARIA Specification	`math`
Computed Role	`math`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_EQUATION`
UIA	Control Type: `Group` Localized Control Type: `math`
ATK/AT-SPI	Role: `ROLE_MATH`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXDocumentMath`
Android	`android.view.View` Method: `AccessibilityNodeInfo.getStructuredDataInfo` returns mathematical content in an `AccessibilityNodeInfo.MathInfo` object.

ARIA Specification	`meter`
Computed Role	`meter`
MSAA + IAccessible2	Role: `IA2_ROLE_LEVEL_BAR` Interface: `IAccessibleValue`
UIA	Control Type: `ProgressBar` Localized Control Type: `meter` Control Pattern: `RangeValue`
ATK/AT-SPI	Role: `ROLE_LEVEL_BAR` Interface: `Value`
AX API^{[Note 1]}	AXRole: `AXLevelIndicator` AXSubrole: `AXMeter`
Android	`android.widget.ProgressBar` Method: `AccessibilityNodeInfo.getRangeInfo` returns an `AccessibilityNodeInfo.RangeInfo` object if it represents a numeric range without `aria-valuetext`.

ARIA Specification	`navigation`
Computed Role	`navigation`
MSAA + IAccessible2	Role: `IA2_ROLE_LANDMARK` Object Attribute: `xml-roles:navigation`
UIA	Control Type: `Group` Localized Control Type: `navigation` Landmark Type: `Navigation`
ATK/AT-SPI	Role: `ROLE_LANDMARK` Object Attribute: `xml-roles:navigation`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXLandmarkNavigation`
Android	com.google.android.material.navigation.NavigationView

ARIA Specification	`none`
Computed Role	`none`
MSAA + IAccessible2	For objects that have specified allowed accessibility children (e.g., a grid with gridcell children, a list with listitem children), and the descendant is in the accessibility tree, expose it as `IA2_ROLE_TEXT_FRAME`. user agents SHOULD prune empty descendants from the accessibility tree.
UIA	For objects that have specified allowed accessibility children (e.g., a grid with gridcell children, a list with listitem children), and the descendant is in the accessibility tree, expose it using the `text` pattern. user agents SHOULD prune empty descendants from the accessibility tree.
ATK/AT-SPI	For objects that have specified allowed accessibility children (e.g., a grid with gridcell children, a list with listitem children), and the descendant is in the accessibility tree, expose it as `ROLE_SECTION`. user agents SHOULD prune empty descendants from the accessibility tree.
AX API^{[Note 1]}	For objects that have specified allowed accessibility children (e.g., a grid with gridcell children, a list with listitem children), and the descendant is in the accessibility tree, expose it as `AXGroup`. user agents SHOULD prune empty descendants from the accessibility tree.
Android	`android.view.View`

ARIA Specification	`note`
Computed Role	`note`
MSAA + IAccessible2	Role: `IA2_ROLE_NOTE`
UIA	Control Type: `Group` Localized Control Type: `note`
ATK/AT-SPI	Role: `ROLE_COMMENT`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXDocumentNote`
Android	`android.view.View`

ARIA Specification	`option` not inside `combobox`
Computed Role	`option`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_LISTITEM` See also: `aria-checked` in the State and Property Mapping Tables
UIA	Control Type: `ListItem` Control Pattern: `Invoke` See also: `aria-checked` in the State and Property Mapping Tables
ATK/AT-SPI	Role: `ROLE_LIST_ITEM` See also: `aria-checked` in the State and Property Mapping Tables
AX API^{[Note 1]}	AXRole: `AXStaticText` AXSubrole: `<nil>` See also: `aria-checked` in the State and Property Mapping Tables
Android	`android.view.View`

ARIA Specification	`option` inside `combobox`
Computed Role	`option`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_LISTITEM` See also: `aria-checked` in the State and Property Mapping Tables
UIA	Control Type: `ListItem` Control Pattern: `Invoke` See also: `aria-checked` in the State and Property Mapping Tables
ATK/AT-SPI	Role: `ROLE_MENU_ITEM` See also: `aria-checked` in the State and Property Mapping Tables
AX API^{[Note 1]}	AXRole: `AXStaticText` AXSubrole: `<nil>` See also: `aria-checked` in the State and Property Mapping Tables
Android	`android.view.View` Method: `AccessibilityNodeInfo.getCollectionItemInfo` returns an `AccessibilityNodeInfo.CollectionItemInfo` object.

ARIA Specification	`paragraph`
Computed Role	`paragraph`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING` Role: `IA2_ROLE_PARAGRAPH`
UIA	Control Type: `Text`
ATK/AT-SPI	Role: `ROLE_PARAGRAPH`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `<nil>`
Android	`android.view.View` Note: Exposed as `android.widget.TextView` if the element has only text children.

ARIA Specification	`presentation`
Computed Role	`none`
MSAA + IAccessible2	For objects that have specified allowed accessibility children (e.g., a grid with gridcell children, a list with listitem children), and the descendant is in the accessibility tree, expose it as `IA2_ROLE_TEXT_FRAME`. user agents SHOULD prune empty descendants from the accessibility tree.
UIA	For objects that have specified allowed accessibility children (e.g., a grid with gridcell children, a list with listitem children), and the descendant is in the accessibility tree, expose it using the `text` pattern. user agents SHOULD prune empty descendants from the accessibility tree.
ATK/AT-SPI	For objects that have specified allowed accessibility children (e.g., a grid with gridcell children, a list with listitem children), and the descendant is in the accessibility tree, expose it as `ROLE_SECTION`. user agents SHOULD prune empty descendants from the accessibility tree.
AX API^{[Note 1]}	For objects that have specified allowed accessibility children (e.g., a grid with gridcell children, a list with listitem children), and the descendant is in the accessibility tree, expose it as `AXGroup`. user agents SHOULD prune empty descendants from the accessibility tree.
Android	`android.view.View`

ARIA Specification	`progressbar`
Computed Role	`progressbar`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_PROGRESSBAR` State: `STATE_SYSTEM_READONLY` Interface: `IAccessibleValue`
UIA	Control Type: `ProgressBar` Control Pattern: `RangeValue` if `aria-valuenow`, `aria-valuemax`, or `aria-valuemin` is present
ATK/AT-SPI	Role: `ROLE_PROGRESS_BAR` Interface: `Value` Because WAI-ARIA does not support modifying the value via the accessibility API, user agents MUST return `false` for all `Value` methods that provide a means to modify the value.
AX API^{[Note 1]}	AXRole: `AXProgressIndicator` AXSubrole: `<nil>`
Android	`android.widget.ProgressBar` Note: Exposed with `RangeInfo` if it represents a numeric range without `aria-valuetext`.

ARIA Specification	`radio`
Computed Role	`radio`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_RADIOBUTTON` See also: `aria-checked` in the State and Property Mapping Tables
UIA	Control Type: `RadioButton` Control Pattern: `Toggle` Control Pattern: `SelectionItem` See also: `aria-checked` in the State and Property Mapping Tables
ATK/AT-SPI	Role: `ROLE_RADIO_BUTTON` See also: `aria-checked` in the State and Property Mapping Tables
AX API^{[Note 1]}	AXRole: `AXRadioButton` AXSubrole: `<nil>` See also: `aria-checked` in the State and Property Mapping Tables
Android	`android.widget.RadioButton`

ARIA Specification	`radiogroup`
Computed Role	`radiogroup`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING`
UIA	Control Type: `List`
ATK/AT-SPI	Role: `ROLE_PANEL`
AX API^{[Note 1]}	AXRole: `AXRadioGroup` AXSubrole: `<nil>`
Android	`android.widget.RadioGroup`

ARIA Specification	`region` with an accessible name
Computed Role	`region`
MSAA + IAccessible2	Role: `IA2_ROLE_LANDMARK` Object Attribute: `xml-roles:region`
UIA	Control Type: `Group` Localized Control Type: `region` Landmark Type: `Custom` Localized Landmark Type: `region`
ATK/AT-SPI	Role: `ROLE_LANDMARK` Object Attribute: `xml-roles:region`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXLandmarkRegion`
Android	`android.view.View`

ARIA Specification	`region` without an accessible name
Computed Role	Use native host language role.
MSAA + IAccessible2	Do not expose the element as a landmark. Use the native host language role of the element instead.
UIA	Do not expose the element as a landmark. Use the native host language role of the element instead.
ATK/AT-SPI	Do not expose the element as a landmark. Use the native host language role of the element instead.
AX API^{[Note 1]}	Do not expose the element as a landmark. Use the native host language role of the element instead.
Android	`android.view.View`

ARIA Specification	`row` not inside `treegrid`
Computed Role	`row`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_ROW`
UIA	Control Type: `DataItem` Localized Control Type: `row` Control Pattern: `SelectionItem`
ATK/AT-SPI	Role: `ROLE_TABLE_ROW`
AX API^{[Note 1]}	AXRole: `AXRow` AXSubrole: `<nil>`
Android	`android.view.View`

ARIA Specification	`row` inside `treegrid`
Computed Role	`row`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_OUTLINEITEM`
UIA	Control Type: `DataItem` Localized Control Type: `row` Control Pattern: `SelectionItem`
ATK/AT-SPI	Role: `ROLE_TABLE_ROW`
AX API^{[Note 1]}	AXRole: `AXRow` AXSubrole: `<nil>`
Android	`android.view.View` Note: Exposed with `CollectionItemInfo`.

ARIA Specification	`rowgroup`
Computed Role	`rowgroup`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING`
UIA	Control Type: `Group`
ATK/AT-SPI	Role: `ROLE_PANEL`
AX API^{[Note 1]}	Not mapped
Android	`android.view.View`

ARIA Specification	`scrollbar`
Computed Role	`scrollbar`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_SCROLLBAR` Interface: `IAccessibleValue`
UIA	Control Type: `ScrollBar` Control Pattern: `RangeValue`
ATK/AT-SPI	Role: `ROLE_SCROLL_BAR` Interface: `Value` Because WAI-ARIA does not support modifying the value via the accessibility API, user agents MUST return `false` for all `Value` methods that provide a means to modify the value.
AX API^{[Note 1]}	AXRole: `AXScrollBar` AXSubrole: `<nil>`
Android	`android.view.View` Note: Exposed with `RangeInfo` if it represents a numeric range without `aria-valuetext`.

ARIA Specification	`search`
Computed Role	`search`
MSAA + IAccessible2	Role: `IA2_ROLE_LANDMARK` Object Attribute: `xml-roles:search`
UIA	Control Type: `Group` Localized Control Type: `search` Landmark Type: `Search`
ATK/AT-SPI	Role: `ROLE_LANDMARK` Object Attribute: `xml-roles:search`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXLandmarkSearch`
Android	`android.widget.SearchView`

ARIA Specification	`searchbox`
Computed Role	`searchbox`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_TEXT` Object Attribute: `text-input-type:search`
UIA	Control Type: `Edit` Localized Control Type: `search box`
ATK/AT-SPI	Role: `ROLE_ENTRY` Object Attribute: `xml-roles:searchbox` Object Attribute: `text-input-type:search` Interface: `EditableText` if `aria-readonly` is not `"true"`
AX API^{[Note 1]}	AXRole: `AXTextField` AXSubrole: `AXSearchField`
Android	`android.widget.EditText`

ARIA Specification	`separator` (non-focusable)
Computed Role	`seperator`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_SEPARATOR`
UIA	Control Type: `Separator`
ATK/AT-SPI	Role: `ROLE_SEPARATOR`
AX API^{[Note 1]}	AXRole: `AXSplitter` AXSubrole: `<nil>`
Android	`android.view.View`

ARIA Specification	`separator` (focusable)
Computed Role	`seperator`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_SEPARATOR` Interface: `IAccessibleValue`
UIA	Control Type: `Thumb` Control Pattern: `RangeValue`
ATK/AT-SPI	Role: `ROLE_SEPARATOR` Interface: `Value` Because WAI-ARIA does not support modifying the value via the accessibility API, user agents MUST return `false` for all `Value` methods that provide a means to modify the value.
AX API^{[Note 1]}	AXRole: `AXSplitter` AXSubrole: `<nil>`
Android	`android.view.View` Note: Exposed with `RangeInfo` if it represents a numeric range without `aria-valuetext`.

ARIA Specification	`slider`
Computed Role	`slider`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_SLIDER` Interface: `IAccessibleValue`
UIA	Control Type: `Slider` Control Pattern: `RangeValue`
ATK/AT-SPI	Role: `ROLE_SLIDER` Interface: `Value` Because WAI-ARIA does not support modifying the value via the accessibility API, user agents MUST return `false` for all `Value` methods that provide a means to modify the value.
AX API^{[Note 1]}	AXRole: `AXSlider` AXSubrole: `<nil>`
Android	`android.widget.SeekBar`

ARIA Specification	`spinbutton`
Computed Role	`spinbutton`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_SPINBUTTON` Interface: `IAccessibleValue`
UIA	Control Type: `Spinner` Control Pattern: `RangeValue`
ATK/AT-SPI	Role: `ROLE_SPIN_BUTTON` Interface: `Value` Because WAI-ARIA does not support modifying the value via the accessibility API, user agents MUST return `false` for all `Value` methods that provide a means to modify the value.
AX API^{[Note 1]}	AXRole: `AXIncrementor` AXSubrole: `<nil>`
Android	`android.widget.EditText` Note: Exposed with `RangeInfo` if it represents a numeric range without `aria-valuetext`.

ARIA Specification	`status`
Computed Role	`status`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_STATUSBAR` Object Attribute: `container-live:polite` Object Attribute: `live:polite` Object Attribute: `container-live-role:status`
UIA	Control Type: `Group` Localized Control Type: `status` LiveSetting: `Polite (1)`
ATK/AT-SPI	Role: `ROLE_STATUS_BAR` Object Attribute: `container-live:polite` Object Attribute: `live:polite` Object Attribute: `container-live-role:status`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXApplicationStatus`
Android	`android.view.View` Method: `AccessibilityNodeInfo.getLiveRegion`: `View.ACCESSIBILITY_LIVE_REGION_POLITE`

ARIA Specification	`strong`
Computed Role	`strong`
MSAA + IAccessible2	Role: `IA2_ROLE_TEXT_FRAME` Object Attribute: `xml-roles:strong`
UIA	Control Type: `Text` Localized Control Type: `strong`
ATK/AT-SPI	Role: `ROLE_STATIC` Object Attribute: `xml-roles:strong`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXStrongStyleGroup`
Android	`android.view.View` Method: `AccessibilityNodeInfo.getText` returns text containing an `android.text.style.StyleSpan` with `android.graphics.Typeface.BOLD`.

ARIA Specification	`subscript`
Computed Role	`subscript`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING` Role: `IA2_ROLE_TEXT_FRAME` Text Attribute: `text-position:sub`
UIA	Control Type: `Text` Styles used are exposed by `IsSubscript` attribute of the `TextRange` Control Pattern implemented on the accessible object.
ATK/AT-SPI	Role: `ROLE_SUBSCRIPT`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXSubscriptStyleGroup`
Android	`android.view.View` Method: `AccessibilityNodeInfo.getText` returns text containing an `android.text.style.SubscriptSpan`.

ARIA Specification	`suggestion`
Computed Role	`suggestion`
MSAA + IAccessible2	Role: `IA2_ROLE_SUGGESTION` Object Attribute: `xml-roles:suggestion`
UIA	Control Type: `Group` Localized Control Type: `suggestion`
ATK/AT-SPI	Role: `ROLE_SUGGESTION` Object Attribute: `xml-roles:suggestion`
AX API^{[Note 1]}	AXRole: `AXGroup` AXAttributedStringForTextMarkerRange: contains `AXIsSuggestion = 1;` for all text contained in a `suggestion`
Android	`android.view.View` Method: `AccessibilityNodeInfo.getText` returns text containing an `android.text.style.SuggestionSpan`.

ARIA Specification	`superscript`
Computed Role	`superscript`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING` Role: `IA2_ROLE_TEXT_FRAME` Text Attribute: `text-position:super`
UIA	Control Type: `Text` Styles used are exposed by `IsSuperscript` attribute of the `TextRange` Control Pattern implemented on the accessible object.
ATK/AT-SPI	Role: `ROLE_SUPERSCRIPT`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXSuperscriptStyleGroup`
Android	`android.view.View` Method: `AccessibilityNodeInfo.getText` returns text containing an `android.text.style.SuperscriptSpan`.

ARIA Specification	`switch`
Computed Role	`switch`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_CHECKBUTTON` Role: `IA2_ROLE_TOGGLE_BUTTON` Object Attribute: `xml-roles:switch` See also: `aria-checked` in the State and Property Mapping Tables
UIA	Control Type: `Button` Localized Control Type: `toggleswitch` Control Pattern: `Toggle` See also: `aria-checked` in the State and Property Mapping Tables
ATK/AT-SPI	Role: `ROLE_TOGGLE_BUTTON` Object Attribute: `xml-roles:switch` See also: `aria-checked` in the State and Property Mapping Tables
AX API^{[Note 1]}	AXRole: `AXCheckBox` AXSubrole: `AXSwitch` See also: `aria-checked` in the State and Property Mapping Tables
Android	`android.widget.Switch`

ARIA Specification	`tab`
Computed Role	`tab`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_PAGETAB` State: `STATE_SYSTEM_SELECTED` if focus is inside `tabpanel` associated with `aria-labelledby`
UIA	Control Type: `TabItem`
ATK/AT-SPI	Role: `ROLE_PAGE_TAB` State: `STATE_SELECTED` if focus is inside `tabpanel` associated with `aria-labelledby`
AX API^{[Note 1]}	AXRole: `AXRadioButton` AXSubrole: `AXTabButton`
Android	`android.view.View` Note: Exposed with `CollectionItemInfo`.

ARIA Specification	`table`
Computed Role	`table`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_TABLE` Object Attribute: `xml-roles:table` Interface: `IAccessibleTable2`
UIA	Control Type: `Table` Control Pattern: `Grid` Control Pattern: `Table`
ATK/AT-SPI	Role: `ROLE_TABLE` Object Attribute: `xml-roles:table` Interface: `Table`
AX API^{[Note 1]}	AXRole: `AXTable` AXSubrole: `<nil>` AXColumnHeaderUIElements: a list of pointers to the columnheader elements AXHeader: a pointer to the row or group containing those columnheader elements AXRowHeaderUIElements: a list of pointers to the rowheader elements
Android	`android.widget.GridView`

ARIA Specification	`tablist`
Computed Role	`tablist`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_PAGETABLIST` Method: `IAccessible::accSelect()` Method: `IAccessible::get_accSelection()`
UIA	Control Type: `Tab` Control Pattern: `Selection`
ATK/AT-SPI	Role: `ROLE_PAGE_TAB_LIST` Interface: `Selection` Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return `false` for all `Selection` methods that provide a means to modify the selection.
AX API^{[Note 1]}	AXRole: `AXTabGroup` AXSubrole: `<nil>`
Android	`android.widget.TabWidget`

ARIA Specification	`tabpanel`
Computed Role	`tabpanel`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_PANE` or `ROLE_SYSTEM_PROPERTYPAGE`
UIA	Control Type: `Pane`
ATK/AT-SPI	Role: `ROLE_SCROLL_PANE`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXTabPanel`
Android	`android.view.View`

ARIA Specification	`term`
Computed Role	`term`
MSAA + IAccessible2	Role: `IA2_ROLE_TEXT_FRAME` Object Attribute: `xml-roles:term`
UIA	Control Type: `Text` Localized Control Type: `term`
ATK/AT-SPI	Role: `ROLE_DESCRIPTION_TERM`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXTerm`
Android	`android.view.View`

ARIA Specification	`textbox` when `aria-multiline` is `false`
Computed Role	`textbox`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_TEXT` State: `IA2_STATE_SINGLE_LINE`
UIA	Control Type: `Edit`
ATK/AT-SPI	Role: `ROLE_ENTRY` State: `STATE_SINGLE_LINE` Interface: `EditableText` if `aria-readonly` is not `"true"`
AX API^{[Note 1]}	AXRole: `AXTextField` AXSubrole: `<nil>`
Android	`android.widget.EditText`

ARIA Specification	`textbox` when `aria-multiline` is `true`
Computed Role	`textbox`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_TEXT` State: `IA2_STATE_MULTI_LINE`
UIA	Control Type: `Edit`
ATK/AT-SPI	Role: `ROLE_ENTRY` State: `STATE_MULTI_LINE` Interface: `EditableText` if `aria-readonly` is not `"true"`
AX API^{[Note 1]}	AXRole: `AXTextArea` AXSubrole: `<nil>`
Android	`android.widget.EditText` Method: `AccessibilityNodeInfo.isMultiLine`: `true`

ARIA Specification	`time`
Computed Role	`time`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_GROUPING` Object Attribute: `xml-roles:time`
UIA	Control Type: `Text` Localized Control Type: `time` Note: create a separate UIA Control of type Text. This is different from most UIA text mappings, which only create ranges in the page text pattern.
ATK/AT-SPI	Role: `ROLE_STATIC` Object Attribute: `xml-roles:time`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXTimeGroup`
Android	`android.widget.TimePicker`

ARIA Specification	`timer`
Computed Role	`timer`
MSAA + IAccessible2	Object Attribute: `xml-roles:timer`
UIA	Control Type: `Group` Localized Control Type: `timer`
ATK/AT-SPI	Role: `ROLE_TIMER`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXApplicationTimer`
Android	`android.view.View`

ARIA Specification	`toolbar`
Computed Role	`toolbar`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_TOOLBAR`
UIA	Control Type: `ToolBar`
ATK/AT-SPI	Role: `ROLE_TOOL_BAR`
AX API^{[Note 1]}	AXRole: `AXToolbar` AXSubrole: `<nil>`
Android	`android.view.View`

ARIA Specification	`tooltip`
Computed Role	`tooltip`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_TOOLTIP`
UIA	Control Type: `ToolTip`
ATK/AT-SPI	Role: `ROLE_TOOL_TIP`
AX API^{[Note 1]}	AXRole: `AXGroup` AXSubrole: `AXUserInterfaceTooltip`
Android	`android.view.View` Note: The tooltip text is typically exposed via `AccessibilityNodeInfo.getTooltipText` on the associated anchor element.

ARIA Specification	`tree`
Computed Role	`tree`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_OUTLINE` Method: `IAccessible::accSelect()` Method: `IAccessible::get_accSelection()`
UIA	Control Type: `Tree`
ATK/AT-SPI	Role: `ROLE_TREE` Interface: `Selection` Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return `false` for all `Selection` methods that provide a means to modify the selection.
AX API^{[Note 1]}	AXRole: `AXOutline` AXSubrole: `<nil>`
Android	`android.view.View` Note: Exposed with `CollectionInfo`.

ARIA Specification	`treegrid`
Computed Role	`treegrid`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_OUTLINE` Interface: `IAccessibleTable2` Method: `IAccessible::accSelect()` Method: `IAccessible::get_accSelection()`
UIA	Control Type: `DataGrid`
ATK/AT-SPI	Role: `ROLE_TREE_TABLE` Interface: `Table` Interface: `Selection` Because WAI-ARIA does not support modifying the selection via the accessibility API, user agents MUST return `false` for all `Selection` methods that provide a means to modify the selection.
AX API^{[Note 1]}	AXRole: `AXTable` AXSubrole: `<nil>`
Android	`android.widget.GridView`

ARIA Specification	`treeitem`
Computed Role	`treeitem`
MSAA + IAccessible2	Role: `ROLE_SYSTEM_OUTLINEITEM` See also: `aria-checked` in the State and Property Mapping Tables
UIA	Control Type: `TreeItem` See also: `aria-checked` in the State and Property Mapping Tables
ATK/AT-SPI	Role: `ROLE_TREE_ITEM` See also: `aria-checked` in the State and Property Mapping Tables
AX API^{[Note 1]}	AXRole: `AXRow` AXSubrole: `AXOutlineRow` See also: `aria-checked` in the State and Property Mapping Tables
Android	`android.view.View` Note: Exposed with `CollectionItemInfo`.

Note

^{[Note 1]} User agent should return a user-presentable, localized string value for the AXRoleDescription.

Note

^{[Note 2]} This specification does not currently contain guidance for when user agents should fire system alert events. Some guidance may be added to the specification at a later date but it will be a recommendation (SHOULD), not a requirement (MUST).

This section describes how to expose WAI-ARIA states and properties.

User agents MUST compute managed states VISIBLE/INVISIBLE, SHOWING/OFFSCREEN, etc. This typically is done in the same way as for ordinary elements that do not have WAI-ARIA attributes present. The FOCUSABLE/FOCUSED states may be affected by aria-activedescendant.
User agents MUST continue to expose native semantics in addition to WAI-ARIA state and property semantics except where an explicit WAI-ARIA override is allowed by the host language. For example, an HTML checkbox may have an aria-labelledby attribute but the native HTML semantics must still be exposed.
User agents MUST expose additional states for certain roles as defined in the Role Mapping Tables.
User agents MUST compute states for the relevant WAI-ARIA attributes and map to the accessibility API as specified in the State and Property Mapping Tables. To determine the relevant WAI-ARIA attributes, refer to the Definition of Roles [WAI-ARIA-1.2]]. Where the author has not provided values for required attributes, user agents SHOULD process as if the default value was provided.
Some WAI-ARIA properties are not global, and are only supported on certain roles. If a non-global WAI-ARIA state or property is used where it is not supported, user agents SHOULD NOT map the given WAI-ARIA property to the platform accessibility API. For example, if aria-checked="true" is specified on <div role="grid">, it should not be exposed in MSAA implementations as STATE_SYSTEM_CHECKED.
When an explicit or inherited role of none or presentation is applied to an element, the user agent MUST implement the rules for the none or the presentation role defined in Accessible Rich Internet Applications (WAI-ARIA) 1.2 [WAI-ARIA-1.2]].

There are a number of occurrences in the table where a given state or property is declared "Not mapped". In some cases, this occurs for the default value of the state/property, and is equivalent to its absence. User agents might find it quicker to map the value than check to see if it is the default. For computational efficiency, user agents MAY expose the state or property value if doing so is equivalent to not mapping it. These cases are marked with an asterisk.

In other cases, it is mandatory that the state/property not be mapped, since exposing it implies a related affordance. An example is aria-grabbed. Its absence not only indicates that the accessible object is not grabbed, but further defines it as not grab-able. These cases are marked as "Not mapped" without an asterisk.

ARIA Specification	`aria-activedescendant`
MSAA + IAccessible2	See Focus Changes.
UIA	See Focus Changes.
ATK/AT-SPI	See Focus Changes.
AX API	See Focus Changes. Property: `AXSelectedRows`: pointer to active descendant node
Android	TBD

ARIA Specification	`aria-atomic`=`true`
MSAA + IAccessible2	Object Attribute: `atomic:true` Object Attribute: `container-atomic:true` Object Attribute: `container-atomic:true` on all descendants Relation: `IA2_RELATION_MEMBER_OF` pointing to this element (the atomic root) See also: Changes to document content or node visibility
UIA	Property: `AriaProperties.atomic`: `true` See also: Changes to document content or node visibility
ATK/AT-SPI	Object Attribute: `atomic:true` Object Attribute: `container-atomic:true` Object Attribute: `container-atomic:true` on all descendants Relation: `RELATION_MEMBER_OF` pointing to this element (the atomic root) See also: Changes to document content or node visibility
AX API	Property: `AXARIAAtomic`: `YES` See also: Changes to document content or node visibility
Android	TBD

ARIA Specification	`aria-atomic`=`false`
MSAA + IAccessible2	Not mapped*, but if mapped: Object Attribute: `atomic:false` Object Attribute: `container-atomic:false` Object Attribute: `container-atomic:false` on all descendants Relation: `IA2_RELATION_MEMBER_OF` pointing to this element (the atomic root) See also: Changes to document content or node visibility
UIA	Property: `AriaProperties.atomic`: `false` See also: Changes to document content or node visibility
ATK/AT-SPI	Not mapped*, but if mapped: Object Attribute: `atomic:false` Object Attribute: `container-atomic:false` Object Attribute: `container-atomic:false` on all descendants Relation: `RELATION_MEMBER_OF` pointing to this element (the atomic root) See also: Changes to document content or node visibility
AX API	Property: `AXARIAAtomic`: `NO` See also: Changes to document content or node visibility
Android	TBD

ARIA Specification	`aria-autocomplete`=`inline`, `list`, or `both`
MSAA + IAccessible2	Object Attribute: `autocomplete:<value>` State: `IA2_STATE_SUPPORTS_AUTOCOMPLETION`
UIA	Not mapped
ATK/AT-SPI	Object Attribute: `autocomplete:<value>` State: `STATE_SUPPORTS_AUTOCOMPLETION`
AX API	Not mapped
Android	TBD

ARIA Specification	`aria-autocomplete`=`none`
MSAA + IAccessible2	Not mapped*
UIA	Not mapped*
ATK/AT-SPI	Not mapped*
AX API	Not mapped*
Android	TBD

ARIA Specification	`aria-braillelabel`
MSAA + IAccessible2	Object Attribute: `braillelabel:<value>`
UIA	Property: `AriaProperties.braillelabel`: `<value>`
ATK/AT-SPI	Object Attribute: `braillelabel:<value>`
AX API	Property: AXBrailleLabel
Android	TBD

ARIA Specification	`aria-brailleroledescription`
MSAA + IAccessible2	Object Attribute: `brailleroledescription:<value>`
UIA	Property: `AriaProperties.brailleroledescription`: `<value>`
ATK/AT-SPI	Object Attribute: `brailleroledescription:<value>`
AX API	Property: AXBrailleRoleDescription
Android	TBD

ARIA Specification	`aria-brailleroledescription` is undefined or the empty string
MSAA + IAccessible2	Not mapped
UIA	Not mapped
ATK/AT-SPI	Not mapped
AX API	Not mapped
Android	TBD

ARIA Specification	`aria-busy`=`true`
MSAA + IAccessible2	State: `STATE_SYSTEM_BUSY`
UIA	Property: `AriaProperties.busy`: `true`
ATK/AT-SPI	State: `STATE_BUSY`
AX API	Property: `AXElementBusy`: `YES`
Android	TBD

ARIA Specification	`aria-busy`=`false`
MSAA + IAccessible2	State: `STATE_SYSTEM_BUSY` not exposed
UIA	Property: `AriaProperties.busy`: `false`
ATK/AT-SPI	State: `STATE_BUSY` not exposed
AX API	Property: `AXElementBusy`: `NO`
Android	TBD

ARIA Specification	`aria-checked`=`true`
MSAA + IAccessible2	State: `STATE_SYSTEM_CHECKED` Object Attribute: `checkable:true`
UIA	Property: `Toggle.ToggleState`: `On (1)` Property: `SelectionItem.IsSelected`: `True` for `radio` and `menuitemradio`
ATK/AT-SPI	State: `STATE_CHECKABLE` State: `STATE_CHECKED`
AX API	Property: `AXValue`: `1` Property: `AXMenuItemMarkChar`: `✓` for `menuitemcheckbox` and `menuitemradio`
Android	TBD

ARIA Specification	`aria-checked`=`false`
MSAA + IAccessible2	State: `STATE_SYSTEM_CHECKED` not exposed Object Attribute: `checkable:true`
UIA	Property: `Toggle.ToggleState`: `Off (0)` Property: `SelectionItem.IsSelected`: `False` for `radio` and `menuitemradio`
ATK/AT-SPI	State: `STATE_CHECKABLE` State: `STATE_CHECKED` not exposed
AX API	Property: `AXValue`: `0` Property: `AXMenuItemMarkChar`: `<nil>` for `menuitemcheckbox` and `menuitemradio`
Android	TBD

ARIA Specification	`aria-checked`=`mixed`
MSAA + IAccessible2	State: `STATE_SYSTEM_MIXED` Object Attribute: `checkable:true`
UIA	Property: `Toggle.ToggleState`: `Indeterminate (2)`
ATK/AT-SPI	State: `STATE_INDETERMINATE` State: `STATE_CHECKABLE` State: `STATE_CHECKED` not exposed
AX API	Property: `AXValue`: `2` Property: `AXMenuItemMarkChar`: `<nil>` for `menuitemcheckbox` and `menuitemradio`
Android	TBD

ARIA Specification	`aria-checked` is undefined
MSAA + IAccessible2	Not mapped
UIA	Not mapped
ATK/AT-SPI	Not mapped
AX API	Not mapped
Android	TBD

ARIA Specification	`aria-colcount`
MSAA + IAccessible2	Object Attribute: `colcount:<value>` Method: `IAccessible2::groupPosition()`: `similarItemsInGroup=<value>` on cells and headers
UIA	Property: `Grid.ColumnCount`: `<value>`
ATK/AT-SPI	Object Attribute: `colcount` should contain the author-provided value. Method: `atk_table_get_n_columns()` should return the actual number of columns.
AX API	Property: `AXARIAColumnCount`: `<value>`
Android	TBD

ARIA Specification	`aria-colindex`
MSAA + IAccessible2	Object Attribute: `colindex:<value>` Method: `IAccessible2::groupPosition()`: `positionInGroup=<value>` on cells and headers
UIA	Property: `GridItem.Column`: `<value>` (zero-based)
ATK/AT-SPI	Object Attribute: `colindex` should contain the author-provided value. Method: `atk_table_cell_get_position()` should return the actual (zero-based) column index.
AX API	Property: `AXARIAColumnIndex`: `<value>`
Android	TBD

ARIA Specification	`aria-colindextext`
MSAA + IAccessible2	Object Attribute: `colindextext:<value>`
UIA	Property: `AriaProperties.colindextext`: `<value>`
ATK/AT-SPI	Object Attribute: `colindextext:<value>`
AX API	Property: `AXColumnIndexDescription`: `<value>`
Android	TBD

ARIA Specification	`aria-colspan`
MSAA + IAccessible2	Object Attribute: `colspan:<value>` Method: `IAccessibleTableCell::columnExtent()`: `<value>`
UIA	Property: `GridItem.ColumnSpan`: `<value>`
ATK/AT-SPI	Object Attribute: `colspan` should contain the author-provided value. Method: `atk_table_cell_get_row_column_span()` should return the actual column span.
AX API	Property: `AXColumnIndexRange.length`: `<value>`
Android	TBD

ARIA Specification	`aria-controls`
MSAA + IAccessible2	Relation: `IA2_RELATION_CONTROLLER_FOR` points to accessible nodes matching IDREFs Reverse Relation: `IA2_RELATION_CONTROLLED_BY` points to element See also: Mapping Additional Relations
UIA	Property: `ControllerFor`: pointers to accessible nodes matching IDREFs
ATK/AT-SPI	Relation: `RELATION_CONTROLLER_FOR` points to accessible nodes matching IDREFs Reverse Relation: `RELATION_CONTROLLED_BY` points to element See also: Mapping Additional Relations
AX API	Property: `AXLinkedUIElements`: pointers to accessible nodes matching IDREFs
Android	TBD

ARIA Specification	`aria-current` with non-`false` allowed value
MSAA + IAccessible2	Object Attribute: `current:<value>`
UIA	Property: `AriaProperties.current`: `<value>`
ATK/AT-SPI	Object Attribute: `current:<value>` State: `STATE_ACTIVE`
AX API	Property: `AXARIACurrent`: `<value>`
Android	TBD

ARIA Specification	`aria-current` with unrecognized value
MSAA + IAccessible2	Object Attribute: `current:true`
UIA	Property: `AriaProperties.current`: `true`
ATK/AT-SPI	Object Attribute: `current:true` State: `STATE_ACTIVE`
AX API	Property: `AXARIACurrent`: `true`
Android	TBD

ARIA Specification	`aria-current` is `false` or undefined
MSAA + IAccessible2	Not mapped*
UIA	Not mapped*
ATK/AT-SPI	Not mapped*
AX API	Not mapped*
Android	TBD

ARIA Specification	`aria-describedby`
MSAA + IAccessible2	Property: `accDescription`: `<value>` Relation: `IA2_RELATION_DESCRIBED_BY` points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree Reverse Relation: `IA2_RELATION_DESCRIPTION_FOR` points to element See also: Name Computation and Mapping Additional Relations
UIA	Property: `FullDescription`: `<value>` See also: Name Computation
ATK/AT-SPI	Property: `Description`: `<value>` Relation: `RELATION_DESCRIBED_BY` points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree Reverse Relation: `RELATION_DESCRIPTION_FOR` points to element See also: Name Computation and Mapping Additional Relations
AX API	In the accessibilityCustomContent API, expose as an `AXCustomContent` object with `{ label: "description" }` and ``value`` set to the description string. - See also: Name Computation
Android	TBD

ARIA Specification	`aria-description`
MSAA + IAccessible2	Property: `accDescription`: `<value>` See also: Name Computation
UIA	Property: `FullDescription`: `<value>` See also: Name Computation
ATK/AT-SPI	Property: `Description`: `<value>` See also: Name Computation
AX API	In the accessibilityCustomContent API, expose as an `AXCustomContent` object with `{ label: "description" }` and ``value`` set to the description string. See also: Name Computation
Android	TBD

ARIA Specification	`aria-details`
MSAA + IAccessible2	Relation: `IA2_RELATION_DETAILS` points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree Reverse Relation: `IA2_RELATION_DETAILS_FOR` points to element See also: Mapping Additional Relations
UIA	Property: `DescribedBy`: points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree
ATK/AT-SPI	Relation: `RELATION_DETAILS` points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree Reverse Relation: `RELATION_DETAILS_FOR` points to element See also: Mapping Additional Relations
AX API	Property: `AXDetailsElements`: pointers to accessible nodes matching IDREFs
Android	TBD

ARIA Specification	`aria-disabled`=`true`
MSAA + IAccessible2	State: `STATE_SYSTEM_UNAVAILABLE` State: `STATE_SYSTEM_UNAVAILABLE` on all descendants with `STATE_SYSTEM_FOCUSABLE`
UIA	Property: `IsEnabled`: `false`
ATK/AT-SPI	State: `STATE_ENABLED` not exposed
AX API	Property: `AXEnabled`: `NO`
Android	TBD

ARIA Specification	`aria-disabled`=`false`
MSAA + IAccessible2	State: `STATE_SYSTEM_UNAVAILABLE` not exposed
UIA	Property: `IsEnabled`: `true`
ATK/AT-SPI	State: `STATE_ENABLED`
AX API	Property: `AXEnabled`: `YES`
Android	TBD

ARIA Specification	`aria-dropeffect`=`none`
MSAA + IAccessible2	Object Attribute: `dropeffect:none` if there are no other valid tokens Not mapped* if not specified by the author
UIA	Not mapped*
ATK/AT-SPI	Object Attribute: `dropeffect:none` if there are no other valid tokens Not mapped* if not specified by the author
AX API	Not mapped*
Android	TBD

ARIA Specification	`aria-errormessage`
MSAA + IAccessible2	Relation: `IA2_RELATION_ERROR` points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree Reverse Relation: `IA2_RELATION_ERROR_FOR` points to element See also: Mapping Additional Relations
UIA	Property: `ControllerFor`: pointer to the target accessible object
ATK/AT-SPI	Relation: `RELATION_ERROR_MESSAGE` points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree Reverse Relation: `RELATION_ERROR_FOR` points to element See also: Mapping Additional Relations
AX API	Property: `AXErrorMessageElements`: pointers to accessible nodes matching IDREFs
Android	TBD

ARIA Specification	`aria-expanded`=`true`
MSAA + IAccessible2	State: `STATE_SYSTEM_EXPANDED`
UIA	Property: `ExpandCollapse.ExpandCollapseState`: `Expanded`
ATK/AT-SPI	State: `STATE_EXPANDABLE` State: `STATE_EXPANDED`
AX API	Property: `AXExpanded`: `YES`
Android	TBD

ARIA Specification	`aria-expanded`=`false`
MSAA + IAccessible2	State: `STATE_SYSTEM_COLLAPSED`
UIA	Property: `ExpandCollapse.ExpandCollapseState`: `Collapsed`
ATK/AT-SPI	State: `STATE_EXPANDABLE` State: `STATE_EXPANDED` not exposed
AX API	Property: `AXExpanded`: `NO`
Android	TBD

ARIA Specification	`aria-expanded` is undefined
MSAA + IAccessible2	Not mapped
UIA	Not mapped
ATK/AT-SPI	Not mapped
AX API	Not mapped
Android	TBD

ARIA Specification	`aria-flowto`
MSAA + IAccessible2	Relation: `IA2_RELATION_FLOW_TO` points to accessible nodes matching IDREFs Reverse Relation: `IA2_RELATION_FLOW_FROM` points to element See also: Mapping Additional Relations
UIA	Property: `FlowsTo`: pointers to accessible nodes matching IDREFs
ATK/AT-SPI	Relation: `RELATION_FLOWS_TO` points to accessible nodes matching IDREFs Reverse Relation: `RELATION_FLOWS_FROM` points to element See also: Mapping Additional Relations
AX API	Property: `AXLinkedUIElements`: pointers to accessible nodes matching IDREFs
Android	TBD

ARIA Specification	`aria-grabbed`=`true`
MSAA + IAccessible2	Object Attribute: `grabbed:true`
UIA	Property: `AriaProperties.grabbed`: `true`
ATK/AT-SPI	Object Attribute: `grabbed:true`
AX API	Property: `AXGrabbed`: `YES`
Android	TBD

ARIA Specification	`aria-grabbed`=`false`
MSAA + IAccessible2	Object Attribute: `grabbed:false`
UIA	Property: `AriaProperties.grabbed`: `false`
ATK/AT-SPI	Object Attribute: `grabbed:false`
AX API	Property: `AXGrabbed`: `NO`
Android	TBD

ARIA Specification	`aria-grabbed` is undefined
MSAA + IAccessible2	Not mapped
UIA	Not mapped
ATK/AT-SPI	Not mapped
AX API	Not mapped
Android	TBD

ARIA Specification	`aria-hidden`=`true` on unfocused element
MSAA + IAccessible2	Element SHOULD NOT be exposed See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
UIA	Element SHOULD NOT be exposed See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
ATK/AT-SPI	Element SHOULD NOT be exposed See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
AX API	Element SHOULD NOT be exposed See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
Android	TBD

ARIA Specification	`aria-hidden`=`true` when element is focused or fires an accessibility event
MSAA + IAccessible2	Object Attribute: `hidden:true` See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
UIA	Property: `AriaProperties.hidden`: `true` See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
ATK/AT-SPI	Object Attribute: `hidden:true` See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
AX API	Not mapped See also: Including Elements in the Accessibility Tree in the WAI-ARIA specification
Android	TBD

ARIA Specification	`aria-hidden`=`false`
MSAA + IAccessible2	Not mapped
UIA	Not mapped
ATK/AT-SPI	Not mapped
AX API	Not mapped
Android	TBD

ARIA Specification	`aria-invalid`=`true`
MSAA + IAccessible2	State: `IA2_STATE_INVALID_ENTRY` Text Attribute: `invalid:true`
UIA	Property: `IsDataValidForForm`: `false`
ATK/AT-SPI	State: `STATE_INVALID_ENTRY` Text Attribute: `invalid:true`
AX API	Property: `AXInvalid`: `true`
Android	TBD

ARIA Specification	`aria-invalid`=`false`
MSAA + IAccessible2	State: `IA2_STATE_INVALID_ENTRY` not exposed
UIA	Property: `IsDataValidForForm`: `true`
ATK/AT-SPI	State: `STATE_INVALID_ENTRY` not exposed
AX API	Property: `AXInvalid`: `false`
Android	TBD

ARIA Specification	`aria-invalid`=`spelling` or `grammar`
MSAA + IAccessible2	State: `IA2_STATE_INVALID_ENTRY` Text Attribute: `invalid:<value>`
UIA	Property: `IsDataValidForForm`: `<value>`
ATK/AT-SPI	State: `STATE_INVALID_ENTRY` Text Attribute: `invalid:<value>`
AX API	Property: `AXInvalid`: `<value>`
Android	TBD

ARIA Specification	`aria-invalid` with unrecognized value
MSAA + IAccessible2	State: `IA2_STATE_INVALID_ENTRY` Text Attribute: `invalid:true`
UIA	Property: `IsDataValidForForm`: `false`
ATK/AT-SPI	State: `STATE_INVALID_ENTRY` Text Attribute: `invalid:true`
AX API	Property: `AXInvalid`: `true`
Android	TBD

ARIA Specification	`aria-keyshortcuts`
MSAA + IAccessible2	Property: `accKeyboardShortcut`: `<value>`
UIA	Property: `AcceleratorKey`: `<value>`
ATK/AT-SPI	Object Attribute: `keyshortcuts:<value>`
AX API	Property: `AXKeyShortcutsValue`: `<value>`
Android	TBD

ARIA Specification	`aria-label`
MSAA + IAccessible2	Property: `accName`: `<value>` See also: Name Computation
UIA	Property: `Name`: `<value>` See also: Name Computation
ATK/AT-SPI	Property: `Name`: `<value>` See also: Name Computation
AX API	Property: `AXTitle`: `<value>` See also: Name Computation
Android	TBD

ARIA Specification	`aria-labelledby`
MSAA + IAccessible2	Property: `accName`: `<value>` Relation: `IA2_RELATION_LABELLED_BY` points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree Reverse Relation: `IA2_RELATION_LABEL_FOR` points to element See also: Name Computation and Mapping Additional Relations
UIA	Property: `Name`: `<value>` Property: `LabeledBy`: points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree See also: Name Computation
ATK/AT-SPI	Property: `Name`: `<value>` Relation: `RELATION_LABELLED_BY` points to accessible nodes matching IDREFs, if the referenced objects are in the accessibility tree Reverse Relation: `RELATION_LABEL_FOR` points to

Abstract

Status of This Document

Table of Contents