diff --git a/gtk/gtkaccessiblevalue.c b/gtk/gtkaccessiblevalue.c
index 2cefba0bc43c9fe6027de8b9239c5a7ae516a521..c4590678120629b77b936696e53f3bd8a41ed6e3 100644
--- a/gtk/gtkaccessiblevalue.c
+++ b/gtk/gtkaccessiblevalue.c
@@ -45,10 +45,13 @@
 #include "gtkaccessiblevalueprivate.h"
 
 #include "gtkaccessible.h"
+#include "gtkbuilderprivate.h"
 #include "gtkenums.h"
+#include "gtktypebuiltins.h"
 
 #include <math.h>
 #include <float.h>
+#include <errno.h>
 
 G_DEFINE_QUARK (gtk-accessible-value-error-quark, gtk_accessible_value_error)
 
@@ -637,6 +640,7 @@ typedef struct {
    */
   GCallback ctor;
   GCallback getter;
+  GCallback parser;
 } GtkAccessibleCollect;
 
 static const GtkAccessibleCollect collect_states[] = {
@@ -670,7 +674,8 @@ static const GtkAccessibleCollect collect_states[] = {
     .ctype = GTK_ACCESSIBLE_COLLECT_TOKEN,
     .name = "invalid",
     .ctor = (GCallback) gtk_invalid_accessible_value_new,
-    .getter = (GCallback) gtk_invalid_accessible_value_get
+    .getter = (GCallback) gtk_invalid_accessible_value_get,
+    .parser = (GCallback) gtk_invalid_accessible_value_parse,
   },
   [GTK_ACCESSIBLE_STATE_PRESSED] = {
     .value = GTK_ACCESSIBLE_STATE_PRESSED,
@@ -691,7 +696,8 @@ static const GtkAccessibleCollect collect_props[] = {
     .ctype = GTK_ACCESSIBLE_COLLECT_TOKEN,
     .name = "autocomplete",
     .ctor = (GCallback) gtk_autocomplete_accessible_value_new,
-    .getter = (GCallback) gtk_autocomplete_accessible_value_get
+    .getter = (GCallback) gtk_autocomplete_accessible_value_get,
+    .parser = (GCallback) gtk_autocomplete_accessible_value_parse,
   },
   [GTK_ACCESSIBLE_PROPERTY_DESCRIPTION] = {
     .value = GTK_ACCESSIBLE_PROPERTY_DESCRIPTION,
@@ -742,7 +748,8 @@ static const GtkAccessibleCollect collect_props[] = {
     .ctype = GTK_ACCESSIBLE_COLLECT_TOKEN | GTK_ACCESSIBLE_COLLECT_UNDEFINED,
     .name = "orientation",
     .ctor = (GCallback) gtk_orientation_accessible_value_new,
-    .getter = (GCallback) gtk_orientation_accessible_value_get
+    .getter = (GCallback) gtk_orientation_accessible_value_get,
+    .parser = (GCallback) gtk_orientation_accessible_value_parse,
   },
   [GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER] = {
     .value = GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER,
@@ -769,7 +776,8 @@ static const GtkAccessibleCollect collect_props[] = {
     .ctype = GTK_ACCESSIBLE_COLLECT_TOKEN,
     .name = "sort",
     .ctor = (GCallback) gtk_sort_accessible_value_new,
-    .getter = (GCallback) gtk_sort_accessible_value_get
+    .getter = (GCallback) gtk_sort_accessible_value_get,
+    .parser = (GCallback) gtk_sort_accessible_value_parse,
   },
   [GTK_ACCESSIBLE_PROPERTY_VALUE_MAX] = {
     .value = GTK_ACCESSIBLE_PROPERTY_VALUE_MAX,
@@ -896,6 +904,10 @@ typedef GtkAccessibleValue * (* GtkAccessibleValueStringCtor)   (const char *val
 typedef GtkAccessibleValue * (* GtkAccessibleValueRefCtor)      (GtkAccessible *value);
 typedef GtkAccessibleValue * (* GtkAccessibleValueRefListCtor)  (GList *value);
 
+typedef GtkAccessibleValue * (* GtkAccessibleValueEnumParser)   (const char  *str,
+                                                                 gsize        len,
+                                                                 GError     **error);
+
 /*< private >
  * gtk_accessible_value_get_default_for_state:
  * @state: a #GtkAccessibleState
@@ -1314,6 +1326,128 @@ gtk_accessible_value_collect_value (const GtkAccessibleCollect  *cstate,
   return res;
 }
 
+static GtkAccessibleValue *
+gtk_accessible_value_parse (const GtkAccessibleCollect  *cstate,
+                            const char                  *str,
+                            gsize                        len,
+                            GError                     **error)
+{
+  GtkAccessibleValue *res = NULL;
+  GtkAccessibleCollectType ctype = cstate->ctype;
+  gboolean collects_undef = (ctype & GTK_ACCESSIBLE_COLLECT_UNDEFINED) != 0;
+
+  ctype &= (GTK_ACCESSIBLE_COLLECT_UNDEFINED - 1);
+
+  /* Tristate values include "undefined" by definition */
+  if (ctype == GTK_ACCESSIBLE_COLLECT_TRISTATE)
+    collects_undef = TRUE;
+
+  switch (ctype)
+    {
+    case GTK_ACCESSIBLE_COLLECT_BOOLEAN:
+      {
+        gboolean b;
+
+        if (collects_undef && strncmp (str, "undefined", 9) == 0)
+          res = gtk_undefined_accessible_value_new ();
+        else if (_gtk_builder_boolean_from_string (str, &b, error))
+          res = gtk_boolean_accessible_value_new (b);
+      }
+      break;
+
+    case GTK_ACCESSIBLE_COLLECT_TRISTATE:
+      {
+        int value;
+
+        if (collects_undef && strncmp (str, "undefined", 9) == 0)
+          res = gtk_undefined_accessible_value_new ();
+        else if (_gtk_builder_enum_from_string (GTK_TYPE_ACCESSIBLE_TRISTATE, str, &value, error))
+          res = gtk_boolean_accessible_value_new (value);
+      }
+      break;
+
+    case GTK_ACCESSIBLE_COLLECT_TOKEN:
+      {
+        GtkAccessibleValueEnumParser parser =
+          (GtkAccessibleValueEnumParser) cstate->parser;
+
+        if (collects_undef && strncmp (str, "undefined", 9) == 0)
+          {
+            res = gtk_undefined_accessible_value_new ();
+          }
+        else
+          {
+            /* Token collection requires a constructor */
+            g_assert (parser != NULL);
+
+            res = (* parser) (str, len, error);
+          }
+      }
+      break;
+
+    case GTK_ACCESSIBLE_COLLECT_INTEGER:
+      {
+        char *end = NULL;
+        gint64 value = g_ascii_strtoll (str, &end, 10);
+
+        if (str == end)
+          {
+            int saved_errno = errno;
+            g_set_error (error, GTK_ACCESSIBLE_VALUE_ERROR,
+                         GTK_ACCESSIBLE_VALUE_ERROR_INVALID_VALUE,
+                         "Invalid integer value “%s”: %s",
+                         str, g_strerror (saved_errno));
+
+            return NULL;
+          }
+        else
+          res = gtk_int_accessible_value_new ((int) value);
+      }
+      break;
+
+    case GTK_ACCESSIBLE_COLLECT_NUMBER:
+      {
+        char *end = NULL;
+        double value = g_ascii_strtod (str, &end);
+
+        if (str == end || isnan (value) || isinf (value))
+          {
+            g_set_error (error, GTK_ACCESSIBLE_VALUE_ERROR,
+                         GTK_ACCESSIBLE_VALUE_ERROR_INVALID_VALUE,
+                         "Invalid numeric value “%s”",
+                         str);
+            return NULL;
+          }
+
+        res = gtk_number_accessible_value_new (value);
+      }
+      break;
+
+    case GTK_ACCESSIBLE_COLLECT_STRING:
+      {
+        res = gtk_string_accessible_value_new (str);
+      }
+      break;
+
+    case GTK_ACCESSIBLE_COLLECT_REFERENCE:
+    case GTK_ACCESSIBLE_COLLECT_REFERENCE_LIST:
+      {
+        /* We do not error out, to let the caller code deal
+         * with the references themselves
+         */
+        res = NULL;
+      }
+      break;
+
+    case GTK_ACCESSIBLE_COLLECT_UNDEFINED:
+    case GTK_ACCESSIBLE_COLLECT_INVALID:
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  return res;
+}
 /*< private >
  * gtk_accessible_value_collect_for_state:
  * @state: a #GtkAccessibleState
@@ -1370,6 +1504,19 @@ gtk_accessible_value_collect_for_state_value (GtkAccessibleState   state,
   return gtk_accessible_value_collect_value (cstate, value, error);
 }
 
+GtkAccessibleValue *
+gtk_accessible_value_parse_for_state (GtkAccessibleState   state,
+                                      const char          *str,
+                                      gsize                len,
+                                      GError             **error)
+{
+  const GtkAccessibleCollect *cstate = &collect_states[state];
+
+  g_return_val_if_fail (state <= GTK_ACCESSIBLE_STATE_SELECTED, NULL);
+
+  return gtk_accessible_value_parse (cstate, str, len, error);
+}
+
 /*< private >
  * gtk_accessible_value_get_default_for_property:
  * @property: a #GtkAccessibleProperty
@@ -1487,6 +1634,19 @@ gtk_accessible_value_collect_for_property_value (GtkAccessibleProperty   propert
   return gtk_accessible_value_collect_value (cstate, value, error);
 }
 
+GtkAccessibleValue *
+gtk_accessible_value_parse_for_property (GtkAccessibleProperty   property,
+                                         const char             *str,
+                                         gsize                   len,
+                                         GError                **error)
+{
+  const GtkAccessibleCollect *cstate = &collect_props[property];
+
+  g_return_val_if_fail (property <= GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT, NULL);
+
+  return gtk_accessible_value_parse (cstate, str, len, error);
+}
+
 /*< private >
  * gtk_accessible_value_get_default_for_relation:
  * @relation: a #GtkAccessibleRelation
@@ -1596,4 +1756,17 @@ gtk_accessible_value_collect_for_relation_value (GtkAccessibleRelation   relatio
   return gtk_accessible_value_collect_value (cstate, value, error);
 }
 
+GtkAccessibleValue *
+gtk_accessible_value_parse_for_relation (GtkAccessibleRelation   relation,
+                                         const char             *str,
+                                         gsize                   len,
+                                         GError                **error)
+{
+  const GtkAccessibleCollect *cstate = &collect_rels[relation];
+
+  g_return_val_if_fail (relation <= GTK_ACCESSIBLE_RELATION_SET_SIZE, NULL);
+
+  return gtk_accessible_value_parse (cstate, str, len, error);
+}
+
 /* }}} */
diff --git a/gtk/gtkaccessiblevalueprivate.h b/gtk/gtkaccessiblevalueprivate.h
index 073b2c2c45f4ec0848600ecbfb5ec60ce22b4c9b..3290fc1e6e1f2791e896edaeb04dc38bb09d51fb 100644
--- a/gtk/gtkaccessiblevalueprivate.h
+++ b/gtk/gtkaccessiblevalueprivate.h
@@ -98,6 +98,10 @@ GtkAccessibleValue *    gtk_accessible_value_collect_for_state          (GtkAcce
 GtkAccessibleValue *    gtk_accessible_value_collect_for_state_value    (GtkAccessibleState             state,
                                                                          const GValue                  *value,
                                                                          GError                       **error);
+GtkAccessibleValue *    gtk_accessible_value_parse_for_state            (GtkAccessibleState             state,
+                                                                         const char                    *str,
+                                                                         gsize                          len,
+                                                                         GError                       **error);
 
 GtkAccessibleValue *    gtk_accessible_value_get_default_for_property   (GtkAccessibleProperty          property);
 GtkAccessibleValue *    gtk_accessible_value_collect_for_property       (GtkAccessibleProperty          property,
@@ -106,6 +110,10 @@ GtkAccessibleValue *    gtk_accessible_value_collect_for_property       (GtkAcce
 GtkAccessibleValue *    gtk_accessible_value_collect_for_property_value (GtkAccessibleProperty          property,
                                                                          const GValue                  *value,
                                                                          GError                       **error);
+GtkAccessibleValue *    gtk_accessible_value_parse_for_property         (GtkAccessibleProperty          property,
+                                                                         const char                    *str,
+                                                                         gsize                          len,
+                                                                         GError                       **error);
 
 GtkAccessibleValue *    gtk_accessible_value_get_default_for_relation   (GtkAccessibleRelation          relation);
 GtkAccessibleValue *    gtk_accessible_value_collect_for_relation       (GtkAccessibleRelation          relation,
@@ -114,6 +122,10 @@ GtkAccessibleValue *    gtk_accessible_value_collect_for_relation       (GtkAcce
 GtkAccessibleValue *    gtk_accessible_value_collect_for_relation_value (GtkAccessibleRelation          relation,
                                                                          const GValue                  *value,
                                                                          GError                       **error);
+GtkAccessibleValue *    gtk_accessible_value_parse_for_relation         (GtkAccessibleRelation          relation,
+                                                                         const char                    *str,
+                                                                         gsize                          len,
+                                                                         GError                       **error);
 
 /* Basic values */
 GtkAccessibleValue *            gtk_undefined_accessible_value_new      (void);
@@ -143,14 +155,26 @@ GList *                         gtk_reference_list_accessible_value_get (const G
 /* Token values */
 GtkAccessibleValue *            gtk_invalid_accessible_value_new        (GtkAccessibleInvalidState value);
 GtkAccessibleInvalidState       gtk_invalid_accessible_value_get        (const GtkAccessibleValue *value);
+GtkAccessibleValue *            gtk_invalid_accessible_value_parse      (const char               *str,
+                                                                         gsize                     len,
+                                                                         GError                  **error);
 
 GtkAccessibleValue *            gtk_autocomplete_accessible_value_new   (GtkAccessibleAutocomplete value);
 GtkAccessibleAutocomplete       gtk_autocomplete_accessible_value_get   (const GtkAccessibleValue *value);
+GtkAccessibleValue *            gtk_autocomplete_accessible_value_parse (const char               *str,
+                                                                         gsize                     len,
+                                                                         GError                  **error);
 
 GtkAccessibleValue *            gtk_orientation_accessible_value_new    (GtkOrientation            value);
 GtkOrientation                  gtk_orientation_accessible_value_get    (const GtkAccessibleValue *value);
+GtkAccessibleValue *            gtk_orientation_accessible_value_parse  (const char               *str,
+                                                                         gsize                     len,
+                                                                         GError                  **error);
 
 GtkAccessibleValue *            gtk_sort_accessible_value_new           (GtkAccessibleSort         value);
 GtkAccessibleSort               gtk_sort_accessible_value_get           (const GtkAccessibleValue *value);
+GtkAccessibleValue *            gtk_sort_accessible_value_parse         (const char               *str,
+                                                                         gsize                     len,
+                                                                         GError                  **error);
 
 G_END_DECLS
diff --git a/gtk/gtkaccessiblevaluestatic.c b/gtk/gtkaccessiblevaluestatic.c
index 6d26ea2900647ea3307e434d1046020c4f083cf4..07600def081345f76ec8eb98e7cde3eb23cc1d1c 100644
--- a/gtk/gtkaccessiblevaluestatic.c
+++ b/gtk/gtkaccessiblevaluestatic.c
@@ -21,6 +21,9 @@
 #include "config.h"
 
 #include "gtkaccessiblevalueprivate.h"
+#include "gtkbuilderprivate.h"
+#include "gtkenums.h"
+#include "gtktypebuiltins.h"
 
 /* {{{ Undefined value */
 
@@ -282,6 +285,19 @@ gtk_invalid_accessible_value_get (const GtkAccessibleValue *value)
   return self->value;
 }
 
+GtkAccessibleValue *
+gtk_invalid_accessible_value_parse (const char  *str,
+                                    gsize        len,
+                                    GError     **error)
+{
+  int value;
+
+  if (_gtk_builder_enum_from_string (GTK_TYPE_ACCESSIBLE_INVALID_STATE, str, &value, error))
+    return gtk_invalid_accessible_value_new (value);
+
+  return NULL;
+}
+
 static const GtkAccessibleValueClass GTK_AUTOCOMPLETE_ACCESSIBLE_VALUE = {
   .type = GTK_ACCESSIBLE_VALUE_TYPE_TOKEN,
   .type_name = "GtkAutocompleteAccessibleValue",
@@ -327,6 +343,19 @@ gtk_autocomplete_accessible_value_get (const GtkAccessibleValue *value)
   return self->value;
 }
 
+GtkAccessibleValue *
+gtk_autocomplete_accessible_value_parse (const char  *str,
+                                         gsize        len,
+                                         GError     **error)
+{
+  int value;
+
+  if (_gtk_builder_enum_from_string (GTK_TYPE_ACCESSIBLE_AUTOCOMPLETE, str, &value, error))
+    return gtk_autocomplete_accessible_value_new (value);
+
+  return NULL;
+}
+
 static const GtkAccessibleValueClass GTK_ORIENTATION_ACCESSIBLE_VALUE = {
   .type = GTK_ACCESSIBLE_VALUE_TYPE_TOKEN,
   .type_name = "GtkOrientationAccessibleValue",
@@ -366,6 +395,19 @@ gtk_orientation_accessible_value_get (const GtkAccessibleValue *value)
   return self->value;
 }
 
+GtkAccessibleValue *
+gtk_orientation_accessible_value_parse (const char  *str,
+                                        gsize        len,
+                                        GError     **error)
+{
+  int value;
+
+  if (_gtk_builder_enum_from_string (GTK_TYPE_ORIENTATION, str, &value, error))
+    return gtk_orientation_accessible_value_new (value);
+
+  return NULL;
+}
+
 static const GtkAccessibleValueClass GTK_SORT_ACCESSIBLE_VALUE = {
   .type = GTK_ACCESSIBLE_VALUE_TYPE_TOKEN,
   .type_name = "GtkSortAccessibleValue",
@@ -411,4 +453,17 @@ gtk_sort_accessible_value_get (const GtkAccessibleValue *value)
   return self->value;
 }
 
+GtkAccessibleValue *
+gtk_sort_accessible_value_parse (const char  *str,
+                                 gsize        len,
+                                 GError     **error)
+{
+  int value;
+
+  if (_gtk_builder_enum_from_string (GTK_TYPE_ACCESSIBLE_SORT, str, &value, error))
+    return gtk_sort_accessible_value_new (value);
+
+  return NULL;
+}
+
 /* }}} */
diff --git a/gtk/gtkbuilder.c b/gtk/gtkbuilder.c
index 182ccad5f1bbf995a4a92a1596a0dfead480fe67..b6663126cffd8337af9f610ef805dc744462811b 100644
--- a/gtk/gtkbuilder.c
+++ b/gtk/gtkbuilder.c
@@ -1997,7 +1997,7 @@ gtk_builder_value_from_string (GtkBuilder   *builder,
                                              string, value, error);
 }
 
-static gboolean
+gboolean
 _gtk_builder_boolean_from_string (const char   *string,
                                   gboolean     *value,
                                   GError      **error)
diff --git a/gtk/gtkbuilderprivate.h b/gtk/gtkbuilderprivate.h
index 5fe910486b3edd4d46a6c67b9a53a0a02067ca43..c6200685c475d4a8cc136a87efb819ae0e7f5113 100644
--- a/gtk/gtkbuilderprivate.h
+++ b/gtk/gtkbuilderprivate.h
@@ -242,6 +242,10 @@ gboolean  _gtk_builder_flags_from_string (GType         type,
 					  const char   *string,
 					  guint        *value,
 					  GError      **error);
+gboolean _gtk_builder_boolean_from_string (const char   *string,
+                                           gboolean     *value,
+                                           GError      **error);
+
 const char * _gtk_builder_parser_translate (const char *domain,
                                              const char *context,
                                              const char *text);
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index fa744d1d9c70acbf68b763c164745db74f95cc9f..ad61b06674f1beea58066de819993472957ddfbe 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -248,8 +248,8 @@
  *
  * # GtkWidget as GtkBuildable
  *
- * The GtkWidget implementation of the GtkBuildable interface supports a
- * custom <accelerator> element, which has attributes named ”key”, ”modifiers”
+ * The GtkWidget implementation of the #GtkBuildable interface supports a
+ * custom `<accelerator>` element, which has attributes named ”key”, ”modifiers”
  * and ”signal” and allows to specify accelerators.
  *
  * An example of a UI definition fragment specifying an accelerator:
@@ -260,7 +260,7 @@
  * ]|
  *
  * If the parent widget uses a #GtkLayoutManager, #GtkWidget supports a
- * custom <layout> element, used to define layout properties:
+ * custom `<layout>` element, used to define layout properties:
  *
  * |[
  * <object class="MyGrid" id="grid1">
@@ -288,8 +288,8 @@
  * </object>
  * ]|
  *
- * Finally, GtkWidget allows style information such as style classes to
- * be associated with widgets, using the custom <style> element:
+ * GtkWidget allows style information such as style classes to
+ * be associated with widgets, using the custom `<style>` element:
  * |[
  * <object class="GtkButton" id="button1">
  *   <style>
@@ -299,6 +299,17 @@
  * </object>
  * ]|
  *
+ * GtkWidget allows defining accessibility information, such as properties,
+ * relations, and states, using the custom `<accessibility>` element:
+ * |[
+ * <object class="GtkButton" id="button1">
+ *   <accessibility>
+ *     <property name="label">Download</property>
+ *     <relation name="labelled-by">label1</relation>
+ *   </accessibility>
+ * </object>
+ * ]|
+ *
  * # Building composite widgets from template XML ## {#composite-templates}
  *
  * GtkWidget exposes some facilities to automate the procedure
@@ -8441,6 +8452,161 @@ static const GtkBuildableParser layout_parser =
     layout_text,
   };
 
+typedef struct
+{
+  char *name;
+  GString *value;
+  char *context;
+  gboolean translatable;
+} AccessibilityAttributeInfo;
+
+typedef struct
+{
+  GObject *object;
+  GtkBuilder *builder;
+
+  AccessibilityAttributeInfo *cur_attribute;
+
+  /* SList<AccessibilityAttributeInfo> */
+  GSList *properties;
+  GSList *states;
+  GSList *relations;
+} AccessibilityParserData;
+
+static void
+accessibility_attribute_info_free (gpointer data)
+{
+  AccessibilityAttributeInfo *pinfo = data;
+
+  if (pinfo == NULL)
+    return;
+
+  g_free (pinfo->name);
+  g_free (pinfo->context);
+  g_string_free (pinfo->value, TRUE);
+  g_free (pinfo);
+}
+
+static void
+accessibility_start_element (GtkBuildableParseContext  *context,
+                             const char                *element_name,
+                             const char               **names,
+                             const char               **values,
+                             gpointer                   user_data,
+                             GError                   **error)
+{
+  AccessibilityParserData *accessibility_data = user_data;
+
+  if (strcmp (element_name, "property") == 0 ||
+      strcmp (element_name, "relation") == 0 ||
+      strcmp (element_name, "state") == 0)
+    {
+      const char *name = NULL;
+      const char *ctx = NULL;
+      gboolean translatable = FALSE;
+      AccessibilityAttributeInfo *pinfo;
+
+      if (!_gtk_builder_check_parent (accessibility_data->builder,
+                                      context,
+                                      "accessibility",
+                                      error))
+        return;
+
+      if (!g_markup_collect_attributes (element_name, names, values, error,
+                                        G_MARKUP_COLLECT_STRING, "name", &name,
+                                        G_MARKUP_COLLECT_BOOLEAN | G_MARKUP_COLLECT_OPTIONAL, "translatable", &translatable,
+                                        G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "context", &ctx,
+                                        G_MARKUP_COLLECT_INVALID))
+        {
+          _gtk_builder_prefix_error (accessibility_data->builder, context, error);
+          return;
+        }
+
+      pinfo = g_new0 (AccessibilityAttributeInfo, 1);
+      pinfo->name = g_strdup (name);
+      pinfo->translatable = translatable;
+      pinfo->context = g_strdup (ctx);
+      pinfo->value = g_string_new (NULL);
+
+      accessibility_data->cur_attribute = pinfo;
+    }
+  else if (strcmp (element_name, "accessibility") == 0)
+    {
+      if (!_gtk_builder_check_parent (accessibility_data->builder,
+                                      context,
+                                      "object",
+                                      error))
+        return;
+    }
+  else
+    {
+      _gtk_builder_error_unhandled_tag (accessibility_data->builder, context,
+                                        "GtkWidget", element_name,
+                                        error);
+    }
+}
+
+static void
+accessibility_text (GtkBuildableParseContext  *context,
+                    const char                *text,
+                    gsize                      text_len,
+                    gpointer                   user_data,
+                    GError                   **error)
+{
+  AccessibilityParserData *accessibility_data = user_data;
+
+  if (accessibility_data->cur_attribute != NULL)
+    g_string_append_len (accessibility_data->cur_attribute->value, text, text_len);
+}
+
+static void
+accessibility_end_element (GtkBuildableParseContext  *context,
+                           const char                *element_name,
+                           gpointer                   user_data,
+                           GError                   **error)
+{
+  AccessibilityParserData *accessibility_data = user_data;
+
+  if (accessibility_data->cur_attribute != NULL)
+    {
+      AccessibilityAttributeInfo *pinfo = g_steal_pointer (&accessibility_data->cur_attribute);
+
+      /* Translate the string, if needed */
+      if (pinfo->value->len != 0 && pinfo->translatable)
+        {
+          const char *translated;
+          const char *domain;
+
+          domain = gtk_builder_get_translation_domain (accessibility_data->builder);
+
+          translated = _gtk_builder_parser_translate (domain, pinfo->context, pinfo->value->str);
+
+          g_string_assign (pinfo->value, translated);
+        }
+
+      /* We assign all properties at the end of the `accessibility` section */
+      if (strcmp (element_name, "property") == 0)
+        accessibility_data->properties = g_slist_prepend (accessibility_data->properties, pinfo);
+      else if (strcmp (element_name, "relation") == 0)
+        accessibility_data->relations = g_slist_prepend (accessibility_data->relations, pinfo);
+      else if (strcmp (element_name, "state") == 0)
+        accessibility_data->states = g_slist_prepend (accessibility_data->states, pinfo);
+      else
+        {
+          _gtk_builder_error_unhandled_tag (accessibility_data->builder, context,
+                                            "GtkWidget", element_name,
+                                            error);
+          accessibility_attribute_info_free (pinfo);
+        }
+    }
+}
+
+static const GtkBuildableParser accessibility_parser = {
+  accessibility_start_element,
+  accessibility_end_element,
+  accessibility_text,
+};
+
 static gboolean
 gtk_widget_buildable_custom_tag_start (GtkBuildable       *buildable,
                                        GtkBuilder         *builder,
@@ -8476,6 +8642,20 @@ gtk_widget_buildable_custom_tag_start (GtkBuildable       *buildable,
       return TRUE;
     }
 
+  if (strcmp (tagname, "accessibility") == 0)
+    {
+      AccessibilityParserData *data;
+
+      data = g_slice_new0 (AccessibilityParserData);
+      data->builder = builder;
+      data->object = (GObject *) g_object_ref (buildable);
+
+      *parser = accessibility_parser;
+      *parser_data = data;
+
+      return TRUE;
+    }
+
   return FALSE;
 }
 
@@ -8554,6 +8734,165 @@ gtk_widget_buildable_finish_layout_properties (GtkWidget *widget,
   g_slist_free_full (layout_properties, layout_property_info_free);
 }
 
+static void
+gtk_widget_buildable_finish_accessibility_properties (GtkWidget *widget,
+                                                      gpointer   data)
+{
+  AccessibilityParserData *accessibility_data = data;
+  GSList *attributes, *l;
+  GtkATContext *context;
+
+  context = gtk_accessible_get_at_context (GTK_ACCESSIBLE (widget));
+  if (context == NULL)
+    return;
+
+  attributes = g_slist_reverse (accessibility_data->properties);
+  accessibility_data->properties = NULL;
+
+  for (l = attributes; l != NULL; l = l->next)
+    {
+      AccessibilityAttributeInfo *pinfo = l->data;
+      int property;
+      GError *error = NULL;
+      GtkAccessibleValue *value;
+
+      _gtk_builder_enum_from_string (GTK_TYPE_ACCESSIBLE_PROPERTY,
+                                     pinfo->name,
+                                     &property,
+                                     &error);
+      if (error != NULL)
+        {
+          g_warning ("Failed to find accessible property “%s”: %s",
+                     pinfo->name,
+                     error->message);
+          g_error_free (error);
+          continue;
+        }
+
+      value = gtk_accessible_value_parse_for_property (property,
+                                                       pinfo->value->str,
+                                                       pinfo->value->len,
+                                                       &error);
+      if (error != NULL)
+        {
+          g_warning ("Failed to set accessible property “%s” to “%s”: %s",
+                     pinfo->name,
+                     pinfo->value->str,
+                     error->message);
+          g_error_free (error);
+          continue;
+        }
+
+      gtk_at_context_set_accessible_property (context, property, value);
+      gtk_accessible_value_unref (value);
+    }
+
+  g_slist_free_full (attributes, accessibility_attribute_info_free);
+
+  attributes = g_slist_reverse (accessibility_data->relations);
+  accessibility_data->relations = NULL;
+
+  for (l = attributes; l != NULL; l = l->next)
+    {
+      AccessibilityAttributeInfo *pinfo = l->data;
+      int relation;
+      GError *error = NULL;
+      GtkAccessibleValue *value;
+
+      _gtk_builder_enum_from_string (GTK_TYPE_ACCESSIBLE_RELATION,
+                                     pinfo->name,
+                                     &relation,
+                                     &error);
+      if (error != NULL)
+        {
+          g_warning ("Failed to find accessible relation “%s”: %s",
+                     pinfo->name,
+                     error->message);
+          g_error_free (error);
+          continue;
+        }
+
+      value = gtk_accessible_value_parse_for_relation (relation,
+                                                       pinfo->value->str,
+                                                       pinfo->value->len,
+                                                       &error);
+      if (error != NULL)
+        {
+          g_warning ("Failed to set accessible relation “%s” to “%s”: %s",
+                     pinfo->name,
+                     pinfo->value->str,
+                     error->message);
+          g_error_free (error);
+          continue;
+        }
+
+      if (value == NULL)
+        {
+          GObject *obj = gtk_builder_get_object (accessibility_data->builder,
+                                                 pinfo->value->str);
+
+          if (obj == NULL)
+            {
+              g_warning ("Failed to find accessible object “%s” for relation “%s”",
+                         pinfo->value->str,
+                         pinfo->name);
+              continue;
+            }
+
+          /* FIXME: Need to distinguish between refs and refslist types */
+          value = gtk_reference_list_accessible_value_new (g_list_append (NULL, obj));
+        }
+
+      gtk_at_context_set_accessible_relation (context, relation, value);
+      gtk_accessible_value_unref (value);
+    }
+
+  g_slist_free_full (attributes, accessibility_attribute_info_free);
+
+  attributes = g_slist_reverse (accessibility_data->states);
+  accessibility_data->states = NULL;
+
+  for (l = attributes; l != NULL; l = l->next)
+    {
+      AccessibilityAttributeInfo *pinfo = l->data;
+      int state;
+      GError *error = NULL;
+      GtkAccessibleValue *value;
+
+      _gtk_builder_enum_from_string (GTK_TYPE_ACCESSIBLE_STATE,
+                                     pinfo->name,
+                                     &state,
+                                     &error);
+      if (error != NULL)
+        {
+          g_warning ("Failed to find accessible state “%s”: %s",
+                     pinfo->name,
+                     error->message);
+          g_error_free (error);
+          continue;
+        }
+
+      value = gtk_accessible_value_parse_for_state (state,
+                                                    pinfo->value->str,
+                                                    pinfo->value->len,
+                                                    &error);
+      if (error != NULL)
+        {
+          g_warning ("Failed to set accessible state “%s” to “%s”: %s",
+                     pinfo->name,
+                     pinfo->value->str,
+                     error->message);
+          g_error_free (error);
+          continue;
+        }
+
+      gtk_at_context_set_accessible_state (context, state, value);
+      gtk_accessible_value_unref (value);
+    }
+
+  g_slist_free_full (attributes, accessibility_attribute_info_free);
+}
+
 static void
 gtk_widget_buildable_custom_finished (GtkBuildable *buildable,
                                       GtkBuilder   *builder,
@@ -8587,6 +8926,22 @@ gtk_widget_buildable_custom_finished (GtkBuildable *buildable,
       g_object_unref (layout_data->object);
       g_slice_free (LayoutParserData, layout_data);
     }
+  else if (strcmp (tagname, "accessibility") == 0)
+    {
+      AccessibilityParserData *accessibility_data = user_data;
+
+      gtk_widget_buildable_finish_accessibility_properties (GTK_WIDGET (buildable),
+                                                            accessibility_data);
+
+      g_slist_free_full (accessibility_data->properties,
+                         accessibility_attribute_info_free);
+      g_slist_free_full (accessibility_data->relations,
+                         accessibility_attribute_info_free);
+      g_slist_free_full (accessibility_data->states,
+                         accessibility_attribute_info_free);
+      g_object_unref (accessibility_data->object);
+      g_slice_free (AccessibilityParserData, accessibility_data);
+    }
 }
 
 static GtkSizeRequestMode
diff --git a/gtk/ui/gtkcoloreditor.ui b/gtk/ui/gtkcoloreditor.ui
index eade0a9bb18fb0363565314cd66528f0d388e078..c34f6a008ab75eb3ca9fa4bcdc32065262f54964 100644
--- a/gtk/ui/gtkcoloreditor.ui
+++ b/gtk/ui/gtkcoloreditor.ui
@@ -49,6 +49,9 @@
                   <property name="column">0</property>
                   <property name="row">0</property>
                 </layout>
+                <accessibility>
+                  <property name="label" translatable="yes">Pick a color from the screen</property>
+                </accessibility>
               </object>
             </child>
             <child>
@@ -73,6 +76,9 @@
                   <property name="column">2</property>
                   <property name="row">0</property>
                 </layout>
+                <accessibility>
+                  <property name="label" translatable="yes">Hexadecimal color or color name</property>
+                </accessibility>
               </object>
             </child>
             <child>
@@ -85,6 +91,9 @@
                   <property name="column">0</property>
                   <property name="row">1</property>
                 </layout>
+                <accessibility>
+                  <property name="label" translatable="yes">Hue</property>
+                </accessibility>
               </object>
             </child>
             <child>
@@ -101,6 +110,9 @@
                   <property name="row">2</property>
                   <property name="column-span">2</property>
                 </layout>
+                <accessibility>
+                  <property name="label" translatable="yes">Alpha value</property>
+                </accessibility>
               </object>
             </child>
             <child>
@@ -116,6 +128,9 @@
                   <property name="row">1</property>
                   <property name="column-span">2</property>
                 </layout>
+                <accessibility>
+                  <property name="label" translatable="yes">Saturation and value</property>
+                </accessibility>
               </object>
             </child>
           </object>
diff --git a/testsuite/gtk/ui/a11y1.expected b/testsuite/gtk/ui/a11y1.expected
new file mode 100644
index 0000000000000000000000000000000000000000..ff43ca409150a5479415981803955ee1d40e4d16
--- /dev/null
+++ b/testsuite/gtk/ui/a11y1.expected
@@ -0,0 +1 @@
+SUCCESS
diff --git a/testsuite/gtk/ui/a11y1.ui b/testsuite/gtk/ui/a11y1.ui
new file mode 100644
index 0000000000000000000000000000000000000000..e185ca9842c99c2c4e1e8ec1c7827b8be75f476c
--- /dev/null
+++ b/testsuite/gtk/ui/a11y1.ui
@@ -0,0 +1,15 @@
+<!-- test accessible states with a variety of values -->
+<interface>
+  <object class="GtkButton">
+    <accessibility>
+      <state name="busy">t</state>
+      <state name="checked">mixed</state>
+      <state name="disabled">true</state>
+      <state name="expanded">undefined</state>
+      <state name="hidden">True</state>
+      <state name="invalid">grammar</state>
+      <state name="pressed">undefined</state>
+      <state name="selected">0</state>
+    </accessibility>
+  </object>
+</interface>
diff --git a/testsuite/gtk/ui/a11y2.expected b/testsuite/gtk/ui/a11y2.expected
new file mode 100644
index 0000000000000000000000000000000000000000..ff43ca409150a5479415981803955ee1d40e4d16
--- /dev/null
+++ b/testsuite/gtk/ui/a11y2.expected
@@ -0,0 +1 @@
+SUCCESS
diff --git a/testsuite/gtk/ui/a11y2.ui b/testsuite/gtk/ui/a11y2.ui
new file mode 100644
index 0000000000000000000000000000000000000000..8dc8bbfb1511bb25fc4f92a29ceb7c9f6c93656a
--- /dev/null
+++ b/testsuite/gtk/ui/a11y2.ui
@@ -0,0 +1,30 @@
+<interface>
+  <!-- test some accessible properties -->
+  <object class="GtkBox">
+    <child>
+      <object class="GtkButton">
+        <accessibility>
+          <property name="autocomplete">both</property>
+          <property name="description" translatable="yes">Bah</property>
+          <property name="has-popup">1</property>
+          <property name="key-shortcuts">shortcuts go here</property>
+          <property name="label" translatable="yes">label?</property>
+          <property name="level">99</property>
+          <property name="modal">no</property>
+          <property name="multi-line">0</property>
+          <property name="multi-selectable">false</property>
+          <property name="orientation">horizontal</property>
+          <property name="placeholder" translatable="yes">placeholder?</property>
+          <property name="read-only">F</property>
+          <property name="required">False</property>
+          <property name="role-description">Dunno</property>
+          <property name="sort">ascending</property>
+          <property name="value-max">11</property>
+          <property name="value-min">0</property>
+          <property name="value-now">10</property>
+          <property name="value-text" translatable="yes">Ten</property>
+        </accessibility>
+      </object>
+    </child>
+  </object>
+</interface>
diff --git a/testsuite/gtk/ui/a11y3.expected b/testsuite/gtk/ui/a11y3.expected
new file mode 100644
index 0000000000000000000000000000000000000000..ff43ca409150a5479415981803955ee1d40e4d16
--- /dev/null
+++ b/testsuite/gtk/ui/a11y3.expected
@@ -0,0 +1 @@
+SUCCESS
diff --git a/testsuite/gtk/ui/a11y3.ui b/testsuite/gtk/ui/a11y3.ui
new file mode 100644
index 0000000000000000000000000000000000000000..1979f9bbb762be028c20508321049239b0182666
--- /dev/null
+++ b/testsuite/gtk/ui/a11y3.ui
@@ -0,0 +1,16 @@
+<!-- test accessible relations -->
+<interface>
+  <object class="GtkBox">
+    <child>
+      <object class="GtkButton">
+        <accessibility>
+          <relation name="labelled-by">label</relation>
+          <relation name="controls">label</relation>
+        </accessibility>
+      </object>
+    </child>
+    <child>
+      <object class="GtkLabel" id="label"/>
+    </child>
+  </object>
+</interface>