diff --git a/Cargo.toml b/Cargo.toml
index 14751e940..9d8ccabb4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -93,12 +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.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" }
@@ -107,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 }
@@ -116,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.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..696998564 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;
+                        }
+                    }
+                }
             }
         }
     }
@@ -213,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)
@@ -540,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,
@@ -549,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 01e23ff28..3640c2d0e 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,31 @@ impl ViewId {
         self.state().borrow().node
     }
 
+    /// Get the accessibility node for this ViewId by converting it directly
+    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 accessibility children (called when children are modified)
+    pub(crate) fn set_accessibility_children(&self, children: Vec<accesskit::NodeId>) {
+        self.state()
+            .borrow_mut()
+            .accessibility_node
+            .set_children(children);
+    }
+
+    /// 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>> {
         VIEW_STORAGE.with_borrow_mut(|s| {
             if !s.view_ids.contains_key(*self) {
@@ -112,18 +137,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 +166,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 +191,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 +223,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`
@@ -381,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/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/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 14a04350f..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,6 +337,17 @@ pub trait View {
         cx.paint_children(self.id());
     }
 
+    /// 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
     /// 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 +411,14 @@ 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_action(
+        &mut self,
+        action: accesskit::Action,
+        data: Option<&accesskit::ActionData>,
+    ) -> bool {
+        (**self).accessibility_action(action, data)
+    }
 }
 
 /// Computes the layout of the view's children, if any.
diff --git a/src/view_state.rs b/src/view_state.rs
index 24ddb81cd..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;
     }
 }
 
@@ -170,14 +173,18 @@ 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>,
+    /// 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>,
@@ -204,13 +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(),
@@ -243,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>,
@@ -279,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 4160bb48d..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.
@@ -45,6 +48,14 @@ impl View for Button {
     fn id(&self) -> ViewId {
         self.id
     }
+
+    fn view_style(&self) -> Option<crate::style::Style> {
+        Some(
+            Style::new()
+                .role(Role::Button)
+                .actions(smallvec![Action::Click]),
+        )
+    }
 }
 
 impl Button {
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 614a6aacd..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;
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 86447b00d..26ea95fea 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);