From 183fffa566f2ebfe3833e99df2e91fad7b49676f Mon Sep 17 00:00:00 2001
From: jrmoulton <jaredmoulton3@gmail.com>
Date: Mon, 10 Nov 2025 15:19:19 -0700
Subject: [PATCH 1/2] accesskit

---
 Cargo.toml              |  1 +
 src/app.rs              |  3 ++
 src/app_handle.rs       |  8 ++++
 src/id.rs               | 89 +++++++++++++++++++++++++++++++++++++----
 src/lib.rs              |  1 +
 src/view.rs             | 40 ++++++++++++++++++
 src/view_state.rs       |  2 +
 src/views/button.rs     |  8 ++++
 src/views/text_input.rs | 26 ++++++++++++
 src/window_state.rs     | 12 ++++++
 10 files changed, 182 insertions(+), 8 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 14751e940..ac66277fa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -93,6 +93,7 @@ wgpu.workspace = true
 fluent-bundle = { version = "0.16", optional = true }
 unic-langid = { version = "0.9", optional = true }
 sys-locale = {version = "0.3.2", optional = true }
+accesskit = {version = "0.21.1"}
 
 [target.'cfg(any(target_os = "windows", target_os = "macos"))'.dependencies]
 muda = { workspace = true }
diff --git a/src/app.rs b/src/app.rs
index 5b6dd4ecf..208c35363 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -136,6 +136,9 @@ pub(crate) enum AppUpdateEvent {
     ThemeChanged {
         theme: Theme,
     },
+    AccessibilityAction {
+        request: accesskit::ActionRequest,
+    },
 }
 
 pub(crate) fn add_app_update_event(event: AppUpdateEvent) {
diff --git a/src/app_handle.rs b/src/app_handle.rs
index 0bb313261..9d338ed18 100644
--- a/src/app_handle.rs
+++ b/src/app_handle.rs
@@ -161,6 +161,14 @@ impl ApplicationHandle {
                         window_handle.set_theme(Some(theme), false);
                     }
                 }
+                AppUpdateEvent::AccessibilityAction { request } => {
+                    // Find which window contains the target node and handle the action
+                    for (_, handle) in self.window_handles.iter_mut() {
+                        if handle.handle_accessibility_action(&request) {
+                            break;
+                        }
+                    }
+                }
             }
         }
     }
diff --git a/src/id.rs b/src/id.rs
index 01e23ff28..79cf77a3d 100644
--- a/src/id.rs
+++ b/src/id.rs
@@ -7,7 +7,7 @@
 use std::{any::Any, cell::RefCell, rc::Rc};
 
 use peniko::kurbo::{Insets, Point, Rect, Size};
-use slotmap::new_key_type;
+use slotmap::{Key, new_key_type};
 use taffy::{Display, Layout, NodeId, TaffyTree};
 use winit::window::WindowId;
 
@@ -82,6 +82,43 @@ impl ViewId {
         self.state().borrow().node
     }
 
+    /// Get the accessibility node for this ViewId by converting it directly
+    pub fn accessibility_node(&self) -> accesskit::NodeId {
+        // Use the ViewId's internal representation as the NodeId
+        // SlotMap keys have a data() method that returns the internal KeyData
+        accesskit::NodeId(self.data().as_ffi())
+    }
+
+    /// Set the accessibility role for this view
+    pub fn set_accessibility_role(&self, role: accesskit::Role) {
+        self.state().borrow_mut().accessibility_node = accesskit::Node::new(role);
+    }
+
+    /// Set the accessibility label for this view
+    pub fn set_accessibility_label(&self, label: String) {
+        self.state().borrow_mut().accessibility_node.set_label(label);
+    }
+
+    /// Set the accessibility value for this view
+    pub fn set_accessibility_value(&self, value: String) {
+        self.state().borrow_mut().accessibility_node.set_value(value);
+    }
+
+    /// Add an accessibility action for this view
+    pub fn add_accessibility_action(&self, action: accesskit::Action) {
+        self.state().borrow_mut().accessibility_node.add_action(action);
+    }
+
+    /// Set accessibility children (called when children are modified)
+    pub fn set_accessibility_children(&self, children: Vec<accesskit::NodeId>) {
+        self.state().borrow_mut().accessibility_node.set_children(children);
+    }
+
+    /// Get a reference to the accessibility node
+    pub fn get_accessibility_node(&self) -> accesskit::Node {
+        self.state().borrow().accessibility_node.clone()
+    }
+
     pub(crate) fn state(&self) -> Rc<RefCell<ViewState>> {
         VIEW_STORAGE.with_borrow_mut(|s| {
             if !s.view_ids.contains_key(*self) {
@@ -112,18 +149,26 @@ impl ViewId {
 
     /// Add a child View to this Id's list of children
     pub fn add_child(&self, child: Box<dyn View>) {
+        let child_id = child.id();
         VIEW_STORAGE.with_borrow_mut(|s| {
-            let child_id = child.id();
             s.children.entry(*self).unwrap().or_default().push(child_id);
             s.parent.insert(child_id, Some(*self));
             s.views.insert(child_id, Rc::new(RefCell::new(child)));
         });
+        
+        // Update accessibility children
+        let children = self.children();
+        let accessibility_children: Vec<accesskit::NodeId> = children
+            .into_iter()
+            .map(|child_id| child_id.accessibility_node())
+            .collect();
+        self.set_accessibility_children(accessibility_children);
     }
 
     /// Set the children views of this Id
     /// See also [`Self::set_children_vec`]
     pub fn set_children<const N: usize, V: IntoView>(&self, children: [V; N]) {
-        VIEW_STORAGE.with_borrow_mut(|s| {
+        let children_ids = VIEW_STORAGE.with_borrow_mut(|s| {
             let mut children_ids = Vec::new();
             for child in children {
                 let child_view = child.into_view();
@@ -133,14 +178,22 @@ impl ViewId {
                 s.views
                     .insert(child_view_id, Rc::new(RefCell::new(child_view.into_any())));
             }
-            s.children.insert(*self, children_ids);
+            s.children.insert(*self, children_ids.clone());
+            children_ids
         });
+        
+        // Update accessibility children
+        let accessibility_children: Vec<accesskit::NodeId> = children_ids
+            .into_iter()
+            .map(|child_id| child_id.accessibility_node())
+            .collect();
+        self.set_accessibility_children(accessibility_children);
     }
 
     /// Set the children views of this Id using a Vector
     /// See also [`Self::set_children`]
     pub fn set_children_vec(&self, children: Vec<impl IntoView>) {
-        VIEW_STORAGE.with_borrow_mut(|s| {
+        let children_ids = VIEW_STORAGE.with_borrow_mut(|s| {
             let mut children_ids = Vec::new();
             for child in children {
                 let child_view = child.into_view();
@@ -150,8 +203,16 @@ impl ViewId {
                 s.views
                     .insert(child_view_id, Rc::new(RefCell::new(child_view.into_any())));
             }
-            s.children.insert(*self, children_ids);
+            s.children.insert(*self, children_ids.clone());
+            children_ids
         });
+        
+        // Update accessibility children
+        let accessibility_children: Vec<accesskit::NodeId> = children_ids
+            .into_iter()
+            .map(|child_id| child_id.accessibility_node())
+            .collect();
+        self.set_accessibility_children(accessibility_children);
     }
 
     /// Set the view that should be associated with this Id
@@ -174,11 +235,23 @@ impl ViewId {
 
     /// Set the Ids that should be used as the children of this Id
     pub fn set_children_ids(&self, children: Vec<ViewId>) {
-        VIEW_STORAGE.with_borrow_mut(|s| {
+        let should_update = VIEW_STORAGE.with_borrow_mut(|s| {
             if s.view_ids.contains_key(*self) {
-                s.children.insert(*self, children);
+                s.children.insert(*self, children.clone());
+                true
+            } else {
+                false
             }
         });
+        
+        if should_update {
+            // Update accessibility children
+            let accessibility_children: Vec<accesskit::NodeId> = children
+                .into_iter()
+                .map(|child_id| child_id.accessibility_node())
+                .collect();
+            self.set_accessibility_children(accessibility_children);
+        }
     }
 
     /// Get the list of `ViewId`s that are associated with the children views of this `ViewId`
diff --git a/src/lib.rs b/src/lib.rs
index 9ec4e249a..5d75ab6bc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -229,6 +229,7 @@ pub mod receiver_signal {
     pub use stream_signal::*;
 }
 
+pub use accesskit;
 pub use app::{AppConfig, AppEvent, Application, launch, quit_app, reopen};
 pub use clipboard::{Clipboard, ClipboardError};
 pub use floem_reactive as reactive;
diff --git a/src/view.rs b/src/view.rs
index 14a04350f..987587597 100644
--- a/src/view.rs
+++ b/src/view.rs
@@ -336,6 +336,29 @@ pub trait View {
         cx.paint_children(self.id());
     }
 
+    /// Get the accessibility role for this view. Default implementation returns None,
+    /// which will use a role based on the view type.
+    fn accessibility_role(&self) -> Option<accesskit::Role> {
+        None
+    }
+
+    /// Get the accessibility label/name for this view. Default implementation returns None.
+    fn accessibility_label(&self) -> Option<String> {
+        None
+    }
+
+    /// Get the accessibility value for this view (e.g., current text in a text input).
+    /// Default implementation returns None.
+    fn accessibility_value(&self) -> Option<String> {
+        None
+    }
+
+    /// Get the accessibility actions supported by this view.
+    /// Default implementation returns None.
+    fn accessibility_actions(&self) -> Option<Vec<accesskit::Action>> {
+        None
+    }
+
     /// Scrolls the view and all direct and indirect children to bring the `target` view to be
     /// visible. Returns true if this view contains or is the target.
     fn scroll_to(&mut self, cx: &mut WindowState, target: ViewId, rect: Option<Rect>) -> bool {
@@ -399,6 +422,22 @@ impl View for Box<dyn View> {
     fn scroll_to(&mut self, cx: &mut WindowState, target: ViewId, rect: Option<Rect>) -> bool {
         (**self).scroll_to(cx, target, rect)
     }
+
+    fn accessibility_role(&self) -> Option<accesskit::Role> {
+        (**self).accessibility_role()
+    }
+
+    fn accessibility_label(&self) -> Option<String> {
+        (**self).accessibility_label()
+    }
+
+    fn accessibility_value(&self) -> Option<String> {
+        (**self).accessibility_value()
+    }
+
+    fn accessibility_actions(&self) -> Option<Vec<accesskit::Action>> {
+        (**self).accessibility_actions()
+    }
 }
 
 /// Computes the layout of the view's children, if any.
@@ -917,3 +956,4 @@ pub(crate) const fn radii_max(radii: RoundedRectRadii) -> f64 {
 fn radii_add(radii: RoundedRectRadii, offset: f64) -> RoundedRectRadii {
     radii_map(radii, |r| r + offset)
 }
+
diff --git a/src/view_state.rs b/src/view_state.rs
index 24ddb81cd..2a06f4673 100644
--- a/src/view_state.rs
+++ b/src/view_state.rs
@@ -170,6 +170,7 @@ impl IsHiddenState {
 /// View state stores internal state associated with a view which is owned and managed by Floem.
 pub struct ViewState {
     pub(crate) node: NodeId,
+    pub(crate) accessibility_node: accesskit::Node,
     pub(crate) requested_changes: ChangeFlags,
     pub(crate) style: Stack<Style>,
     /// Layout is requested on all direct and indirect children.
@@ -206,6 +207,7 @@ impl ViewState {
     pub(crate) fn new(taffy: &mut taffy::TaffyTree) -> Self {
         Self {
             node: taffy.new_leaf(taffy::style::Style::DEFAULT).unwrap(),
+            accessibility_node: accesskit::Node::new(accesskit::Role::Group),
             viewport: None,
             style: Default::default(),
             layout_rect: Rect::ZERO,
diff --git a/src/views/button.rs b/src/views/button.rs
index 4160bb48d..b93a985c8 100644
--- a/src/views/button.rs
+++ b/src/views/button.rs
@@ -45,6 +45,14 @@ impl View for Button {
     fn id(&self) -> ViewId {
         self.id
     }
+
+    fn accessibility_role(&self) -> Option<accesskit::Role> {
+        Some(accesskit::Role::Button)
+    }
+
+    fn accessibility_actions(&self) -> Option<Vec<accesskit::Action>> {
+        Some(vec![accesskit::Action::Click])
+    }
 }
 
 impl Button {
diff --git a/src/views/text_input.rs b/src/views/text_input.rs
index 614a6aacd..1c6cd3fa0 100644
--- a/src/views/text_input.rs
+++ b/src/views/text_input.rs
@@ -1440,6 +1440,32 @@ impl View for TextInput {
             id.request_paint();
         });
     }
+
+    fn accessibility_role(&self) -> Option<accesskit::Role> {
+        Some(accesskit::Role::TextInput)
+    }
+
+    fn accessibility_value(&self) -> Option<String> {
+        Some(self.buffer.get_untracked())
+    }
+
+    fn accessibility_actions(&self) -> Option<Vec<accesskit::Action>> {
+        Some(vec![
+            accesskit::Action::Focus,
+            accesskit::Action::SetTextSelection,
+            accesskit::Action::SetValue,
+        ])
+    }
+
+    fn accessibility_label(&self) -> Option<String> {
+        // If there's placeholder text and the input is empty, use it as the label
+        if let Some(placeholder) = &self.placeholder_text {
+            if self.buffer.with_untracked(|buf| buf.is_empty()) {
+                return Some(placeholder.clone());
+            }
+        }
+        None
+    }
 }
 
 #[cfg(test)]
diff --git a/src/window_state.rs b/src/window_state.rs
index 86447b00d..cec520128 100644
--- a/src/window_state.rs
+++ b/src/window_state.rs
@@ -118,6 +118,18 @@ impl WindowState {
             }
         }
         let _ = taffy.remove(node);
+        
+        // Clean up accessibility: if this view has a parent, update the parent's accessibility children
+        if let Some(parent_id) = id.parent() {
+            let siblings = parent_id.children();
+            let accessibility_children: Vec<accesskit::NodeId> = siblings
+                .into_iter()
+                .filter(|sibling_id| *sibling_id != id) // Exclude the view being removed
+                .map(|sibling_id| sibling_id.accessibility_node())
+                .collect();
+            parent_id.set_accessibility_children(accessibility_children);
+        }
+        
         id.remove();
         self.dragging_over.remove(&id);
         self.clicking.remove(&id);

From 8b377a8e514861f3d534c953d2088a6ba5cc8bb3 Mon Sep 17 00:00:00 2001
From: jrmoulton <jaredmoulton3@gmail.com>
Date: Mon, 10 Nov 2025 15:59:16 -0700
Subject: [PATCH 2/2] add accesskit winit

---
 Cargo.toml                 |   5 +-
 src/app_handle.rs          |   6 +-
 src/context.rs             |  69 ++++++++++-
 src/id.rs                  |  53 ++++-----
 src/style.rs               |  25 ++++
 src/view.rs                |  52 +++-----
 src/view_state.rs          |  22 ++--
 src/views/button.rs        |  17 +--
 src/views/label.rs         |  11 ++
 src/views/list.rs          |  12 +-
 src/views/resizable.rs     |   6 +-
 src/views/stack.rs         |   9 +-
 src/views/svg.rs           |   1 +
 src/views/text_input.rs    |  38 ++----
 src/views/tooltip.rs       |   1 +
 src/views/virtual_stack.rs |   1 +
 src/window_handle.rs       | 238 ++++++++++++++++++++++++++++++++++++-
 src/window_state.rs        |   4 +-
 18 files changed, 447 insertions(+), 123 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index ac66277fa..9d8ccabb4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -93,13 +93,14 @@ wgpu.workspace = true
 fluent-bundle = { version = "0.16", optional = true }
 unic-langid = { version = "0.9", optional = true }
 sys-locale = {version = "0.3.2", optional = true }
-accesskit = {version = "0.21.1"}
+accesskit = {version = "0.18.0"}
 
 [target.'cfg(any(target_os = "windows", target_os = "macos"))'.dependencies]
 muda = { workspace = true }
 
 [target.'cfg(any(target_os = "linux"))'.dependencies]
 muda = { workspace = true, default-features = false, features = ["gtk"] }
+accesskit_unix = "0.17.1"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen-futures = { version = "0.4" }
@@ -108,6 +109,7 @@ wgpu = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 clipboard-win = "5.4"
+accesskit_windows = "0.29.1"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 objc2 = { version = "0.6", default-features = false }
@@ -117,6 +119,7 @@ objc2-app-kit = { version = "0.3", features = [
   "NSResponder",
   "NSView"
 ] }
+accesskit_macos = "0.19.0"
 
 [features]
 default = ["editor", "default-image-formats", "vger"]
diff --git a/src/app_handle.rs b/src/app_handle.rs
index 9d338ed18..696998564 100644
--- a/src/app_handle.rs
+++ b/src/app_handle.rs
@@ -221,6 +221,9 @@ impl ApplicationHandle {
             )
         });
 
+        // Process accessibility events first
+        window_handle.process_accessibility_event(&event);
+
         match window_handle
             .event_reducer
             .reduce(window_handle.scale, &event)
@@ -548,7 +551,7 @@ impl ApplicationHandle {
             }
         }
         let window_id = window.id();
-        let window_handle = WindowHandle::new(
+        let mut window_handle = WindowHandle::new(
             window,
             self.gpu_resources.clone(),
             self.config.wgpu_features,
@@ -557,6 +560,7 @@ impl ApplicationHandle {
             apply_default_theme,
             font_embolden,
         );
+        window_handle.init_accessibility_with_event_loop(event_loop);
         self.window_handles.insert(window_id, window_handle);
     }
 
diff --git a/src/context.rs b/src/context.rs
index 9617037c2..0006b4ed4 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -642,17 +642,30 @@ impl<'a> StyleCx<'a> {
         let view_state = view_id.state();
         {
             let mut view_state = view_state.borrow_mut();
-            if !view_state.requested_changes.contains(ChangeFlags::STYLE) {
+            if !view_state.requested_changes.contains(ChangeFlags::STYLE)
+                && !view_state
+                    .requested_changes
+                    .contains(ChangeFlags::VIEW_STYLE)
+            {
                 self.restore();
                 return;
             }
             view_state.requested_changes.remove(ChangeFlags::STYLE);
         }
 
-        let view_style = view.borrow().view_style();
         let view_class = view.borrow().view_class();
         {
             let mut view_state = view_state.borrow_mut();
+            if view_state
+                .requested_changes
+                .contains(ChangeFlags::VIEW_STYLE)
+            {
+                view_state.requested_changes.remove(ChangeFlags::VIEW_STYLE);
+                if let Some(view_style) = view.borrow().view_style() {
+                    let offest = view_state.view_style_offset;
+                    view_state.style.set(offest, view_style);
+                }
+            }
 
             // Propagate style requests to children if needed.
             if view_state.request_style_recursive {
@@ -670,7 +683,6 @@ impl<'a> StyleCx<'a> {
         let view_interact_state = self.get_interact_state(&view_id);
         self.disabled = view_interact_state.is_disabled;
         let (mut new_frame, classes_applied) = view_id.state().borrow_mut().compute_combined(
-            view_style,
             view_interact_state,
             self.window_state.screen_size_bp,
             view_class,
@@ -702,13 +714,20 @@ impl<'a> StyleCx<'a> {
             self.window_state.focusable.remove(&view_id);
         }
         view_state.borrow_mut().computed_style = computed_style;
-        self.hidden |= view_id.is_hidden();
+        let view_hidden = view_id.is_hidden();
+        self.hidden |= view_hidden;
 
         // This is used by the `request_transition` and `style` methods below.
         self.current_view = view_id;
 
         {
             let mut view_state = view_state.borrow_mut();
+            if view_hidden {
+                view_state.accessibility_node.set_hidden();
+            } else {
+                view_state.accessibility_node.clear_hidden();
+            }
+
             // Extract the relevant layout properties so the content rect can be calculated
             // when painting.
             view_state.layout_props.read_explicit(
@@ -731,6 +750,30 @@ impl<'a> StyleCx<'a> {
             if new_frame && !self.hidden {
                 self.window_state.schedule_style(view_id);
             }
+
+            if view_state.accessibility_props.read_explicit(
+                &self.direct,
+                &self.current,
+                &self.now,
+                &mut false,
+            ) {
+                view_id.request_accessibility_update();
+                if let Some(role) = view_state.accessibility_props.role() {
+                    view_state.accessibility_node.set_role(role);
+                }
+                if let Some(label) = view_state.accessibility_props.label() {
+                    view_state.accessibility_node.set_label(label);
+                }
+                if let Some(value) = view_state.accessibility_props.value() {
+                    view_state.accessibility_node.set_value(value);
+                }
+                if let Some(actions) = view_state.accessibility_props.actions() {
+                    view_state.accessibility_node.clear_actions();
+                    for action in actions {
+                        view_state.accessibility_node.add_action(action);
+                    }
+                }
+            }
         }
         // If there's any changes to the Taffy style, request layout.
         let layout_style = view_state.borrow().layout_props.to_style();
@@ -849,6 +892,7 @@ impl<'a> StyleCx<'a> {
 }
 
 pub struct ComputeLayoutCx<'a> {
+    pub scale: f64,
     pub window_state: &'a mut WindowState,
     pub(crate) viewport: Rect,
     pub(crate) window_origin: Point,
@@ -857,8 +901,9 @@ pub struct ComputeLayoutCx<'a> {
 }
 
 impl<'a> ComputeLayoutCx<'a> {
-    pub(crate) fn new(window_state: &'a mut WindowState, viewport: Rect) -> Self {
+    pub(crate) fn new(window_state: &'a mut WindowState, viewport: Rect, scale: f64) -> Self {
         Self {
+            scale,
             window_state,
             viewport,
             window_origin: Point::ZERO,
@@ -977,7 +1022,19 @@ impl<'a> ComputeLayoutCx<'a> {
         let transform = view_state.borrow().transform;
         let layout_rect = transform.transform_rect_bbox(layout_rect);
 
-        view_state.borrow_mut().layout_rect = layout_rect;
+        {
+            let mut view_state_ref = view_state.borrow_mut();
+            let scale = self.window_state.scale * self.scale;
+            view_state_ref.layout_rect = layout_rect;
+            view_state_ref
+                .accessibility_node
+                .set_bounds(accesskit::Rect {
+                    x0: layout_rect.x0 * scale,
+                    y0: layout_rect.y0 * scale,
+                    x1: layout_rect.x1 * scale,
+                    y1: layout_rect.y1 * scale,
+                });
+        }
 
         self.restore();
 
diff --git a/src/id.rs b/src/id.rs
index 79cf77a3d..3640c2d0e 100644
--- a/src/id.rs
+++ b/src/id.rs
@@ -83,40 +83,28 @@ impl ViewId {
     }
 
     /// Get the accessibility node for this ViewId by converting it directly
-    pub fn accessibility_node(&self) -> accesskit::NodeId {
+    pub(crate) fn accessibility_node(&self) -> accesskit::NodeId {
         // Use the ViewId's internal representation as the NodeId
         // SlotMap keys have a data() method that returns the internal KeyData
+        // TODO: Find a better implementation
         accesskit::NodeId(self.data().as_ffi())
     }
 
-    /// Set the accessibility role for this view
-    pub fn set_accessibility_role(&self, role: accesskit::Role) {
-        self.state().borrow_mut().accessibility_node = accesskit::Node::new(role);
-    }
-
-    /// Set the accessibility label for this view
-    pub fn set_accessibility_label(&self, label: String) {
-        self.state().borrow_mut().accessibility_node.set_label(label);
-    }
-
-    /// Set the accessibility value for this view
-    pub fn set_accessibility_value(&self, value: String) {
-        self.state().borrow_mut().accessibility_node.set_value(value);
-    }
-
-    /// Add an accessibility action for this view
-    pub fn add_accessibility_action(&self, action: accesskit::Action) {
-        self.state().borrow_mut().accessibility_node.add_action(action);
-    }
-
     /// Set accessibility children (called when children are modified)
-    pub fn set_accessibility_children(&self, children: Vec<accesskit::NodeId>) {
-        self.state().borrow_mut().accessibility_node.set_children(children);
+    pub(crate) fn set_accessibility_children(&self, children: Vec<accesskit::NodeId>) {
+        self.state()
+            .borrow_mut()
+            .accessibility_node
+            .set_children(children);
     }
 
-    /// Get a reference to the accessibility node
-    pub fn get_accessibility_node(&self) -> accesskit::Node {
-        self.state().borrow().accessibility_node.clone()
+    /// Request an accessibility tree update for this view's window
+    pub(crate) fn request_accessibility_update(&self) {
+        // Find the root window and request accessibility update
+        if let Some(root_id) = self.root() {
+            // The accessibility update will be triggered during the next update cycle
+            root_id.request_changes(crate::view_state::ChangeFlags::ACCESSIBILITY);
+        }
     }
 
     pub(crate) fn state(&self) -> Rc<RefCell<ViewState>> {
@@ -155,7 +143,7 @@ impl ViewId {
             s.parent.insert(child_id, Some(*self));
             s.views.insert(child_id, Rc::new(RefCell::new(child)));
         });
-        
+
         // Update accessibility children
         let children = self.children();
         let accessibility_children: Vec<accesskit::NodeId> = children
@@ -181,7 +169,7 @@ impl ViewId {
             s.children.insert(*self, children_ids.clone());
             children_ids
         });
-        
+
         // Update accessibility children
         let accessibility_children: Vec<accesskit::NodeId> = children_ids
             .into_iter()
@@ -206,7 +194,7 @@ impl ViewId {
             s.children.insert(*self, children_ids.clone());
             children_ids
         });
-        
+
         // Update accessibility children
         let accessibility_children: Vec<accesskit::NodeId> = children_ids
             .into_iter()
@@ -243,7 +231,7 @@ impl ViewId {
                 false
             }
         });
-        
+
         if should_update {
             // Update accessibility children
             let accessibility_children: Vec<accesskit::NodeId> = children
@@ -454,6 +442,11 @@ impl ViewId {
         self.request_changes(ChangeFlags::STYLE)
     }
 
+    /// use this when you want the `view_style` method from the `View` trait to be rerun
+    pub fn request_view_style(&self) {
+        self.request_changes(ChangeFlags::VIEW_STYLE)
+    }
+
     pub(crate) fn request_changes(&self, flags: ChangeFlags) {
         let state = self.state();
         if state.borrow().requested_changes.contains(flags) {
diff --git a/src/style.rs b/src/style.rs
index 0ff9ffaff..bfa437746 100644
--- a/src/style.rs
+++ b/src/style.rs
@@ -128,6 +128,7 @@
 //!
 //! You can create custom extractors and embed them in your custom views so that you can get out any built in prop, or any of your custom props from the final combined style that is applied to your `View`.
 
+use accesskit::{Action, Role};
 use floem_reactive::{RwSignal, SignalGet, SignalUpdate as _, create_updater};
 use floem_renderer::Renderer;
 use floem_renderer::text::{LineHeightValue, Weight};
@@ -3463,6 +3464,17 @@ impl StylePropValue for Margin {
         }
     }
 }
+impl StylePropValue for Role {
+    fn debug_view(&self) -> Option<Box<dyn View>> {
+        Some(text(format!("{self:?}")).into_any())
+    }
+}
+
+impl StylePropValue for Action {
+    fn debug_view(&self) -> Option<Box<dyn View>> {
+        Some(text(format!("{self:?}")).into_any())
+    }
+}
 
 /// The value for a [`Style`] property
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
@@ -3628,6 +3640,10 @@ define_builtin_props!(
     Hidden set_hidden: bool { inherited } = false,
     Focusable focusable: bool { } = false,
     Draggable draggable: bool { } = false,
+    AccessibilityRole role: Option<Role> { } = None,
+    AccessibilityLabel label: Option<String> {} = None,
+    AccessibilityValue value: Option<String> {} = None,
+    AccessibilityActions actions: Option<SmallVec<[Action; 2]>> {} = None,
 );
 
 impl BuiltinStyle<'_> {
@@ -3752,6 +3768,15 @@ impl LayoutProps {
     }
 }
 
+prop_extractor!(
+    pub AccessibilityProps {
+        pub role: AccessibilityRole,
+        pub label: AccessibilityLabel,
+        pub value: AccessibilityValue,
+        pub actions: AccessibilityActions,
+    }
+);
+
 prop_extractor! {
     pub SelectionStyle {
         pub corner_radius: SelectionCornerRadius,
diff --git a/src/view.rs b/src/view.rs
index 987587597..e8adfa67a 100644
--- a/src/view.rs
+++ b/src/view.rs
@@ -257,6 +257,7 @@ pub fn recursively_layout_view(id: ViewId, cx: &mut LayoutCx) -> NodeId {
 pub trait View {
     fn id(&self) -> ViewId;
 
+    /// View style will be rerun only if you use `id.request_view_style()`.
     fn view_style(&self) -> Option<Style> {
         None
     }
@@ -336,27 +337,15 @@ pub trait View {
         cx.paint_children(self.id());
     }
 
-    /// Get the accessibility role for this view. Default implementation returns None,
-    /// which will use a role based on the view type.
-    fn accessibility_role(&self) -> Option<accesskit::Role> {
-        None
-    }
-
-    /// Get the accessibility label/name for this view. Default implementation returns None.
-    fn accessibility_label(&self) -> Option<String> {
-        None
-    }
-
-    /// Get the accessibility value for this view (e.g., current text in a text input).
-    /// Default implementation returns None.
-    fn accessibility_value(&self) -> Option<String> {
-        None
-    }
-
-    /// Get the accessibility actions supported by this view.
-    /// Default implementation returns None.
-    fn accessibility_actions(&self) -> Option<Vec<accesskit::Action>> {
-        None
+    /// Handle an accessbiliity event
+    fn accessibility_action(
+        &mut self,
+        action: accesskit::Action,
+        data: Option<&accesskit::ActionData>,
+    ) -> bool {
+        let _action = action;
+        let _data = data;
+        false
     }
 
     /// Scrolls the view and all direct and indirect children to bring the `target` view to be
@@ -423,20 +412,12 @@ impl View for Box<dyn View> {
         (**self).scroll_to(cx, target, rect)
     }
 
-    fn accessibility_role(&self) -> Option<accesskit::Role> {
-        (**self).accessibility_role()
-    }
-
-    fn accessibility_label(&self) -> Option<String> {
-        (**self).accessibility_label()
-    }
-
-    fn accessibility_value(&self) -> Option<String> {
-        (**self).accessibility_value()
-    }
-
-    fn accessibility_actions(&self) -> Option<Vec<accesskit::Action>> {
-        (**self).accessibility_actions()
+    fn accessibility_action(
+        &mut self,
+        action: accesskit::Action,
+        data: Option<&accesskit::ActionData>,
+    ) -> bool {
+        (**self).accessibility_action(action, data)
     }
 }
 
@@ -956,4 +937,3 @@ pub(crate) const fn radii_max(radii: RoundedRectRadii) -> f64 {
 fn radii_add(radii: RoundedRectRadii, offset: f64) -> RoundedRectRadii {
     radii_map(radii, |r| r + offset)
 }
-
diff --git a/src/view_state.rs b/src/view_state.rs
index 2a06f4673..fcf8fdf3f 100644
--- a/src/view_state.rs
+++ b/src/view_state.rs
@@ -8,8 +8,9 @@ use crate::{
     prop_extractor,
     responsive::ScreenSizeBp,
     style::{
-        Background, BorderColorProp, BorderRadiusProp, BoxShadowProp, LayoutProps, Outline,
-        OutlineColor, Style, StyleClassRef, StyleSelectors, resolve_nested_maps,
+        AccessibilityProps, Background, BorderColorProp, BorderRadiusProp, BoxShadowProp,
+        LayoutProps, Outline, OutlineColor, Style, StyleClassRef, StyleSelectors,
+        resolve_nested_maps,
     },
 };
 use bitflags::bitflags;
@@ -104,6 +105,8 @@ bitflags! {
     pub(crate) struct ChangeFlags: u8 {
         const STYLE = 1;
         const LAYOUT = 1 << 1;
+        const VIEW_STYLE = 1 << 2;
+        const ACCESSIBILITY = 1 << 3;
     }
 }
 
@@ -173,12 +176,15 @@ pub struct ViewState {
     pub(crate) accessibility_node: accesskit::Node,
     pub(crate) requested_changes: ChangeFlags,
     pub(crate) style: Stack<Style>,
+    /// we store the stack offset to the view style to keep the api consistent but it should always be the first offset
+    pub(crate) view_style_offset: StackOffset<Style>,
     /// Layout is requested on all direct and indirect children.
     pub(crate) request_style_recursive: bool,
     pub(crate) has_style_selectors: StyleSelectors,
     pub(crate) viewport: Option<Rect>,
     pub(crate) layout_rect: Rect,
     pub(crate) layout_props: LayoutProps,
+    pub(crate) accessibility_props: AccessibilityProps,
     pub(crate) view_style_props: ViewStyleProps,
     pub(crate) animations: Stack<Animation>,
     pub(crate) classes: Vec<StyleClassRef>,
@@ -205,14 +211,19 @@ pub struct ViewState {
 
 impl ViewState {
     pub(crate) fn new(taffy: &mut taffy::TaffyTree) -> Self {
+        let mut style = Stack::<Style>::default();
+        let view_style_offset = style.next_offset();
+        style.push(Style::new());
         Self {
             node: taffy.new_leaf(taffy::style::Style::DEFAULT).unwrap(),
             accessibility_node: accesskit::Node::new(accesskit::Role::Group),
             viewport: None,
-            style: Default::default(),
+            style,
+            view_style_offset,
             layout_rect: Rect::ZERO,
             layout_props: Default::default(),
             view_style_props: Default::default(),
+            accessibility_props: Default::default(),
             requested_changes: ChangeFlags::all(),
             request_style_recursive: false,
             has_style_selectors: StyleSelectors::default(),
@@ -245,7 +256,6 @@ impl ViewState {
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn compute_combined(
         &mut self,
-        view_style: Option<Style>,
         interact_state: InteractionState,
         screen_size_bp: ScreenSizeBp,
         view_class: Option<StyleClassRef>,
@@ -281,10 +291,6 @@ impl ViewState {
         combined_style = resolved_style;
         new_classes |= classes_applied;
 
-        if let Some(view_style) = &view_style {
-            combined_style.apply_mut(view_style.clone());
-        }
-
         let self_style = self.style();
 
         combined_style.apply_mut(self_style.clone());
diff --git a/src/views/button.rs b/src/views/button.rs
index b93a985c8..71ecc414d 100644
--- a/src/views/button.rs
+++ b/src/views/button.rs
@@ -1,5 +1,8 @@
 #![deny(missing_docs)]
-use crate::{IntoView, View, ViewId, style_class, views::Decorators};
+use accesskit::{Action, Role};
+use smallvec::smallvec;
+
+use crate::{IntoView, View, ViewId, style::Style, style_class, views::Decorators};
 
 style_class!(
     /// The style class that is applied to buttons.
@@ -46,12 +49,12 @@ impl View for Button {
         self.id
     }
 
-    fn accessibility_role(&self) -> Option<accesskit::Role> {
-        Some(accesskit::Role::Button)
-    }
-
-    fn accessibility_actions(&self) -> Option<Vec<accesskit::Action>> {
-        Some(vec![accesskit::Action::Click])
+    fn view_style(&self) -> Option<crate::style::Style> {
+        Some(
+            Style::new()
+                .role(Role::Button)
+                .actions(smallvec![Action::Click]),
+        )
     }
 }
 
diff --git a/src/views/label.rs b/src/views/label.rs
index 16f05e3aa..5ac5536a6 100644
--- a/src/views/label.rs
+++ b/src/views/label.rs
@@ -16,6 +16,7 @@ use crate::{
     unit::PxPct,
     view::View,
 };
+use accesskit::Role;
 use floem_reactive::create_updater;
 use floem_renderer::{Renderer, text::Cursor};
 use peniko::{
@@ -302,6 +303,15 @@ impl View for Label {
         format!("Label: {:?}", self.label).into()
     }
 
+    fn view_style(&self) -> Option<Style> {
+        Some(
+            Style::new()
+                .role(Role::Label)
+                .label("Label".to_string())
+                .value(self.label.clone()),
+        )
+    }
+
     fn update(&mut self, _cx: &mut UpdateCx, state: Box<dyn Any>) {
         if let Ok(state) = state.downcast() {
             self.label = *state;
@@ -310,6 +320,7 @@ impl View for Label {
             self.available_width = None;
             self.available_text_layout = None;
             self.id.request_layout();
+            self.id.request_view_style();
         }
     }
 
diff --git a/src/views/list.rs b/src/views/list.rs
index 27b82aa7a..bbc1addd9 100644
--- a/src/views/list.rs
+++ b/src/views/list.rs
@@ -10,6 +10,7 @@ use crate::{
     event::{Event, EventListener},
     view::View,
 };
+use accesskit::Role;
 use floem_reactive::{RwSignal, SignalGet, SignalUpdate, create_rw_signal};
 use ui_events::keyboard::{Key, KeyState, KeyboardEvent};
 use winit::keyboard::NamedKey;
@@ -187,6 +188,10 @@ impl View for List {
         self.id
     }
 
+    fn view_style(&self) -> Option<Style> {
+        Some(Style::new().role(Role::List).label("List".to_string()))
+    }
+
     fn update(&mut self, _cx: &mut crate::context::UpdateCx, state: Box<dyn std::any::Any>) {
         if let Ok(change) = state.downcast::<ListUpdate>() {
             match *change {
@@ -217,7 +222,12 @@ impl View for Item {
     }
 
     fn view_style(&self) -> Option<crate::style::Style> {
-        Some(Style::new().flex_col())
+        Some(
+            Style::new()
+                .flex_col()
+                .role(Role::ListItem)
+                .label("List Item".to_string()),
+        )
     }
 
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
diff --git a/src/views/resizable.rs b/src/views/resizable.rs
index b69f3ce89..8538d8514 100644
--- a/src/views/resizable.rs
+++ b/src/views/resizable.rs
@@ -200,6 +200,7 @@ impl View for ResizableStack {
                             }
                         };
                         self.id.request_style();
+                        self.id.request_view_style();
                         self.style = self.style.clone().cursor(cursor);
                     };
 
@@ -221,6 +222,7 @@ impl View for ResizableStack {
                     self.id.request_all();
                     let cursor = CursorStyle::Default;
                     self.id.request_style();
+                    self.id.request_view_style();
                     self.style = self.style.clone().cursor(cursor);
                     return EventPropagation::Stop;
                 }
@@ -238,6 +240,7 @@ impl View for ResizableStack {
                     };
                     self.style = self.style.clone().cursor(cursor);
                     self.id.request_style();
+                    self.id.request_view_style();
                     self.id.request_layout();
                     return EventPropagation::Stop;
                 } else if let Some(handle_idx) = self.find_handle_at_position(point) {
@@ -250,12 +253,13 @@ impl View for ResizableStack {
                     };
                     self.style = self.style.clone().cursor(cursor);
                     self.id.request_style();
+                    self.id.request_view_style();
                     return EventPropagation::Stop;
                 } else {
                     self.handle_state = HandleState::None;
                     let cursor = CursorStyle::default();
                     self.style = self.style.clone().cursor(cursor);
-                    self.id.request_style();
+                    self.id.request_view_style();
                 }
             }
             _ => {}
diff --git a/src/views/stack.rs b/src/views/stack.rs
index 42ef7fee3..10c73b3d5 100644
--- a/src/views/stack.rs
+++ b/src/views/stack.rs
@@ -1,3 +1,4 @@
+use accesskit::Role;
 use taffy::style::FlexDirection;
 
 use crate::{
@@ -105,8 +106,12 @@ impl View for Stack {
     }
 
     fn view_style(&self) -> Option<crate::style::Style> {
-        self.direction
-            .map(|direction| Style::new().flex_direction(direction))
+        self.direction.map(|direction| {
+            Style::new()
+                .flex_direction(direction)
+                .role(Role::GenericContainer)
+                .label(self.debug_name().to_string())
+        })
     }
 
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
diff --git a/src/views/svg.rs b/src/views/svg.rs
index 3581916e6..0558adfee 100644
--- a/src/views/svg.rs
+++ b/src/views/svg.rs
@@ -143,6 +143,7 @@ impl View for Svg {
             if self.aspect_ratio != aspect_ratio {
                 self.aspect_ratio = aspect_ratio;
                 self.id.request_style();
+                self.id.request_view_style();
             }
         }
         if let Some(prop_reader) = &mut self.css_prop {
diff --git a/src/views/text_input.rs b/src/views/text_input.rs
index 1c6cd3fa0..f1106eaa9 100644
--- a/src/views/text_input.rs
+++ b/src/views/text_input.rs
@@ -8,6 +8,7 @@ use crate::style::{FontStyle, FontWeight, TextColor};
 use crate::unit::{PxPct, PxPctAuto};
 use crate::views::editor::text::Preedit;
 use crate::{Clipboard, prop_extractor, style_class};
+use accesskit::Role;
 use floem_reactive::{SignalGet, SignalUpdate, SignalWith, create_rw_signal};
 use taffy::prelude::{Layout, NodeId};
 
@@ -1132,6 +1133,17 @@ impl View for TextInput {
         format!("TextInput: {:?}", self.buffer.get_untracked()).into()
     }
 
+    fn view_style(&self) -> Option<Style> {
+        Some(
+            Style::new()
+                .role(Role::TextInput)
+                .value(self.buffer.get_untracked())
+                .apply_opt(self.placeholder_text.as_ref(), |s, v| {
+                    s.label(v.to_string())
+                }),
+        )
+    }
+
     fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn Any>) {
         if let Ok(state) = state.downcast::<bool>() {
             let is_focused = *state;
@@ -1440,32 +1452,6 @@ impl View for TextInput {
             id.request_paint();
         });
     }
-
-    fn accessibility_role(&self) -> Option<accesskit::Role> {
-        Some(accesskit::Role::TextInput)
-    }
-
-    fn accessibility_value(&self) -> Option<String> {
-        Some(self.buffer.get_untracked())
-    }
-
-    fn accessibility_actions(&self) -> Option<Vec<accesskit::Action>> {
-        Some(vec![
-            accesskit::Action::Focus,
-            accesskit::Action::SetTextSelection,
-            accesskit::Action::SetValue,
-        ])
-    }
-
-    fn accessibility_label(&self) -> Option<String> {
-        // If there's placeholder text and the input is empty, use it as the label
-        if let Some(placeholder) = &self.placeholder_text {
-            if self.buffer.with_untracked(|buf| buf.is_empty()) {
-                return Some(placeholder.clone());
-            }
-        }
-        None
-    }
 }
 
 #[cfg(test)]
diff --git a/src/views/tooltip.rs b/src/views/tooltip.rs
index 3127c1495..87c1c097f 100644
--- a/src/views/tooltip.rs
+++ b/src/views/tooltip.rs
@@ -230,6 +230,7 @@ impl View for ToolTipOverlay {
             if self.offset != new_offset {
                 self.offset = new_offset;
                 self.id().request_style();
+                self.id().request_view_style();
             }
         }
 
diff --git a/src/views/virtual_stack.rs b/src/views/virtual_stack.rs
index e99f22bef..69465f45f 100644
--- a/src/views/virtual_stack.rs
+++ b/src/views/virtual_stack.rs
@@ -223,6 +223,7 @@ where
     create_effect(move |_| {
         direction.track();
         id.request_style();
+        id.request_view_style();
     });
 
     create_effect(move |prev| {
diff --git a/src/window_handle.rs b/src/window_handle.rs
index 1c85d4d7f..13f6989ee 100644
--- a/src/window_handle.rs
+++ b/src/window_handle.rs
@@ -85,6 +85,15 @@ pub(crate) struct WindowHandle {
     pub(crate) window_menu_actions: HashMap<MenuId, Box<dyn Fn()>>,
     pub(crate) window_menu: Option<muda::Menu>,
     pub(crate) event_reducer: WindowEventReducer,
+    // TODO: clean up this mess.
+    #[cfg(target_os = "macos")]
+    pub(crate) accessibility_adapter: Option<accesskit_macos::SubclassingAdapter>,
+    #[cfg(target_os = "windows")]
+    pub(crate) accessibility_adapter: Option<accesskit_windows::SubclassingAdapter>,
+    #[cfg(target_os = "linux")]
+    pub(crate) accessibility_adapter: Option<accesskit_unix::Adapter>,
+    #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
+    pub(crate) accessibility_adapter: Option<()>,
 }
 
 impl WindowHandle {
@@ -203,6 +212,7 @@ impl WindowHandle {
             window_menu_actions: HashMap::new(),
             window_menu: None,
             event_reducer: WindowEventReducer::default(),
+            accessibility_adapter: None,
         };
         if paint_state_initialized {
             window_handle.init_renderer(gpu_resources);
@@ -218,6 +228,7 @@ impl WindowHandle {
             window_handle.window_state.light_dark_theme,
         ));
         window_handle.size(size.get_untracked());
+
         window_handle
     }
 
@@ -596,6 +607,11 @@ impl WindowHandle {
     }
 
     pub(crate) fn focused(&mut self, focused: bool) {
+        if let Some(acc_adapter) = &mut self.accessibility_adapter {
+            if let Some(events) = acc_adapter.update_view_focus_state(focused) {
+                events.raise();
+            }
+        }
         if focused {
             #[cfg(target_os = "macos")]
             if let Some(window_menu) = &self.window_menu {
@@ -636,7 +652,7 @@ impl WindowHandle {
     fn compute_layout(&mut self) {
         self.window_state.request_compute_layout = false;
         let viewport = (self.window_state.root_size / self.window_state.scale).to_rect();
-        let mut cx = ComputeLayoutCx::new(&mut self.window_state, viewport);
+        let mut cx = ComputeLayoutCx::new(&mut self.window_state, viewport, self.scale);
         cx.compute_view_layout(self.id);
     }
 
@@ -816,6 +832,10 @@ impl WindowHandle {
             self.process_deferred_update_messages();
         }
 
+        if self.needs_accessibility() {
+            self.update_accessibility_tree();
+        }
+
         self.set_cursor();
 
         // TODO: This should only use `self.window_state.request_paint)`
@@ -942,8 +962,12 @@ impl WindowHandle {
                             .scroll_to(cx.window_state, id, rect);
                     }
                     UpdateMessage::State { id, state } => {
+                        // let vstate = id.state();
+                        // let node = &mut vstate.borrow_mut().accessibility_node;
                         let view = id.view();
+                        // cx.accesskit_node = Some(node);
                         view.borrow_mut().update(&mut cx, state);
+                        // cx.accesskit_node = None;
                     }
                     UpdateMessage::DragWindow => {
                         let _ = self.window.drag_window();
@@ -1111,7 +1135,15 @@ impl WindowHandle {
             .state()
             .borrow()
             .requested_changes
-            .contains(ChangeFlags::STYLE)
+            .contains(ChangeFlags::STYLE | ChangeFlags::VIEW_STYLE)
+    }
+
+    fn needs_accessibility(&mut self) -> bool {
+        self.id
+            .state()
+            .borrow()
+            .requested_changes
+            .contains(ChangeFlags::ACCESSIBILITY)
     }
 
     fn has_deferred_update_messages(&self) -> bool {
@@ -1299,6 +1331,208 @@ impl WindowHandle {
         }
         self.modifiers = modifiers;
     }
+
+    /// Initialize the accessibility adapter using platform-specific adapters
+    pub(crate) fn init_accessibility_with_event_loop(
+        &mut self,
+        #[allow(unused_variables, reason = "unused on some platforms")]
+        event_loop: &dyn winit::event_loop::ActiveEventLoop,
+    ) {
+        let root_id = self.id;
+        let activation_handler = Self::create_activation_handler(root_id);
+        let action_handler = Self::create_action_handler();
+
+        // Initialize platform-specific accessibility adapter
+        #[cfg(target_os = "macos")]
+        {
+            use raw_window_handle::HasWindowHandle;
+            if let Ok(window_handle) = self.window.window_handle() {
+                if let raw_window_handle::RawWindowHandle::AppKit(appkit_handle) =
+                    window_handle.as_raw()
+                {
+                    let adapter = unsafe {
+                        accesskit_macos::SubclassingAdapter::new(
+                            appkit_handle.ns_view.as_ptr(),
+                            activation_handler,
+                            action_handler,
+                        )
+                    };
+                    self.accessibility_adapter = Some(adapter);
+                }
+            }
+        }
+
+        #[cfg(target_os = "windows")]
+        {
+            use raw_window_handle::HasWindowHandle;
+            if let Ok(window_handle) = self.window.window_handle() {
+                if let raw_window_handle::RawWindowHandle::Win32(win32_handle) =
+                    window_handle.as_raw()
+                {
+                    let adapter = accesskit_windows::SubclassingAdapter::new(
+                        win32_handle.hwnd.get() as _,
+                        activation_handler,
+                        action_handler,
+                    );
+                    self.accessibility_adapter = Some(adapter);
+                }
+            }
+        }
+
+        #[cfg(target_os = "linux")]
+        {
+            let adapter = accesskit_unix::UnixAdapter::new(
+                activation_handler,
+                action_handler,
+                deactivation_handler,
+            );
+            self.accessibility_adapter = Some(adapter);
+        }
+    }
+
+    /// Create activation handler for accessibility
+    fn create_activation_handler(root_id: ViewId) -> impl accesskit::ActivationHandler {
+        struct FloemActivationHandler {
+            root_id: ViewId,
+        }
+
+        impl accesskit::ActivationHandler for FloemActivationHandler {
+            fn request_initial_tree(&mut self) -> Option<accesskit::TreeUpdate> {
+                Some(WindowHandle::build_accessibility_tree_for_root(
+                    self.root_id,
+                ))
+            }
+        }
+
+        FloemActivationHandler { root_id }
+    }
+
+    /// Create action handler for accessibility
+    fn create_action_handler() -> impl accesskit::ActionHandler {
+        struct FloemActionHandler;
+
+        impl accesskit::ActionHandler for FloemActionHandler {
+            fn do_action(&mut self, request: accesskit::ActionRequest) {
+                crate::app::add_app_update_event(crate::app::AppUpdateEvent::AccessibilityAction {
+                    request,
+                });
+            }
+        }
+
+        FloemActionHandler
+    }
+
+    /// Build accessibility tree for the given root ViewId
+    fn build_accessibility_tree_for_root(root_id: ViewId) -> accesskit::TreeUpdate {
+        use std::collections::HashMap;
+
+        let mut nodes = HashMap::new();
+        let root_accessibility_id = root_id.accessibility_node();
+
+        // Recursively build nodes for the entire view tree
+        Self::build_accessibility_nodes_recursive(root_id, &mut nodes);
+
+        // Convert HashMap to Vec of tuples as expected by TreeUpdate
+        let nodes_vec: Vec<(accesskit::NodeId, accesskit::Node)> = nodes.into_iter().collect();
+
+        accesskit::TreeUpdate {
+            nodes: nodes_vec,
+            tree: Some(accesskit::Tree::new(root_accessibility_id)),
+            focus: root_accessibility_id, // Set root as default focus
+        }
+    }
+
+    /// Recursively build accessibility nodes for a view and its children
+    fn build_accessibility_nodes_recursive(
+        view_id: ViewId,
+        nodes: &mut std::collections::HashMap<accesskit::NodeId, accesskit::Node>,
+    ) {
+        // Get the view and state
+        let state = view_id.state();
+        let state_ref = state.borrow();
+
+        // Use the accessibility node from state if available
+        let accessibility_id = view_id.accessibility_node();
+        nodes.insert(accessibility_id, state_ref.accessibility_node.clone());
+
+        // Recursively process children
+        for child_id in view_id.children() {
+            Self::build_accessibility_nodes_recursive(child_id, nodes);
+        }
+    }
+
+    /// Handle accessibility action requests
+    pub(crate) fn handle_accessibility_action(
+        &mut self,
+        request: &accesskit::ActionRequest,
+    ) -> bool {
+        // Find the view that corresponds to the target accessibility node
+        if let Some(view_id) = self.find_view_by_accessibility_id(request.target) {
+            return self.handle_action_for_view(view_id, request.action, request.data.as_ref());
+        }
+        false
+    }
+
+    /// Find a ViewId by its accessibility node ID
+    fn find_view_by_accessibility_id(&self, target_id: accesskit::NodeId) -> Option<ViewId> {
+        Self::find_view_by_accessibility_id_recursive(self.id, target_id)
+    }
+
+    /// Recursively search for a view by its accessibility ID
+    fn find_view_by_accessibility_id_recursive(
+        current_id: ViewId,
+        target_id: accesskit::NodeId,
+    ) -> Option<ViewId> {
+        // Check if this view matches the target
+        if current_id.accessibility_node() == target_id {
+            return Some(current_id);
+        }
+
+        // Search children
+        for child_id in current_id.children() {
+            if let Some(found) = Self::find_view_by_accessibility_id_recursive(child_id, target_id)
+            {
+                return Some(found);
+            }
+        }
+
+        None
+    }
+
+    /// Handle an accessibility action for a specific view
+    fn handle_action_for_view(
+        &mut self,
+        view_id: ViewId,
+        action: accesskit::Action,
+        data: Option<&accesskit::ActionData>,
+    ) -> bool {
+        let handled = view_id
+            .view()
+            .borrow_mut()
+            .accessibility_action(action, data);
+        match action {
+            accesskit::Action::Focus => {
+                // Set focus to the view
+                self.window_state.update_focus(view_id, false);
+                true
+            }
+            _ => handled,
+        }
+    }
+
+    /// Process accessibility events through the adapter
+    pub(crate) fn process_accessibility_event(&mut self, _event: &winit::event::WindowEvent) {
+        // Platform-specific adapters handle events differently
+        // Most events are handled automatically by the underlying platform adapter
+    }
+
+    /// Update the accessibility tree when views change
+    pub(crate) fn update_accessibility_tree(&mut self) {
+        if let Some(adapter) = &mut self.accessibility_adapter {
+            let tree_update = Self::build_accessibility_tree_for_root(self.id);
+            adapter.update_if_active(|| tree_update.clone());
+        }
+    }
 }
 
 fn request_recursive_changes(id: ViewId, changes: ChangeFlags) {
diff --git a/src/window_state.rs b/src/window_state.rs
index cec520128..26ea95fea 100644
--- a/src/window_state.rs
+++ b/src/window_state.rs
@@ -118,7 +118,7 @@ impl WindowState {
             }
         }
         let _ = taffy.remove(node);
-        
+
         // Clean up accessibility: if this view has a parent, update the parent's accessibility children
         if let Some(parent_id) = id.parent() {
             let siblings = parent_id.children();
@@ -129,7 +129,7 @@ impl WindowState {
                 .collect();
             parent_id.set_accessibility_children(accessibility_children);
         }
-        
+
         id.remove();
         self.dragging_over.remove(&id);
         self.clicking.remove(&id);