diff --git a/crates/bevy_ui/src/accessibility.rs b/crates/bevy_ui/src/accessibility.rs
index 85a8f0c5470d7..1220d2d5c990a 100644
--- a/crates/bevy_ui/src/accessibility.rs
+++ b/crates/bevy_ui/src/accessibility.rs
@@ -1,5 +1,5 @@
 use crate::{
-    experimental::UiChildren,
+    experimental::UiTree,
     prelude::{Button, Label},
     widget::TextUiReader,
     ComputedNode, UiImage,
@@ -66,11 +66,11 @@ fn calc_bounds(
 fn button_changed(
     mut commands: Commands,
     mut query: Query<(Entity, Option<&mut AccessibilityNode>), Changed<Button>>,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
     mut text_reader: TextUiReader,
 ) {
     for (entity, accessible) in &mut query {
-        let name = calc_name(&mut text_reader, ui_children.iter_ui_children(entity));
+        let name = calc_name(&mut text_reader, ui_tree.iter_children(entity));
         if let Some(mut accessible) = accessible {
             accessible.set_role(Role::Button);
             if let Some(name) = name {
@@ -93,11 +93,11 @@ fn button_changed(
 fn image_changed(
     mut commands: Commands,
     mut query: Query<(Entity, Option<&mut AccessibilityNode>), (Changed<UiImage>, Without<Button>)>,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
     mut text_reader: TextUiReader,
 ) {
     for (entity, accessible) in &mut query {
-        let name = calc_name(&mut text_reader, ui_children.iter_ui_children(entity));
+        let name = calc_name(&mut text_reader, ui_tree.iter_children(entity));
         if let Some(mut accessible) = accessible {
             accessible.set_role(Role::Image);
             if let Some(name) = name {
diff --git a/crates/bevy_ui/src/experimental/ghost_hierarchy.rs b/crates/bevy_ui/src/experimental/ghost_hierarchy.rs
deleted file mode 100644
index 42832c0483500..0000000000000
--- a/crates/bevy_ui/src/experimental/ghost_hierarchy.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-//! This module contains [`GhostNode`] and utilities to flatten the UI hierarchy, traversing past ghost nodes.
-
-use bevy_ecs::{prelude::*, system::SystemParam};
-use bevy_hierarchy::{Children, HierarchyQueryExt, Parent};
-use bevy_reflect::prelude::*;
-use bevy_render::view::Visibility;
-use bevy_transform::prelude::Transform;
-use core::marker::PhantomData;
-use smallvec::SmallVec;
-
-use crate::Node;
-
-/// Marker component for entities that should be ignored within UI hierarchies.
-///
-/// The UI systems will traverse past these and treat their first non-ghost descendants as direct children of their first non-ghost ancestor.
-///
-/// Any components necessary for transform and visibility propagation will be added automatically.
-///
-/// Instances of this type cannot be constructed unless the `ghost_nodes` feature is enabled.
-#[derive(Component, Debug, Copy, Clone, Reflect)]
-#[cfg_attr(feature = "ghost_nodes", derive(Default))]
-#[reflect(Component, Debug)]
-#[require(Visibility, Transform)]
-pub struct GhostNode {
-    // This is a workaround to ensure that GhostNode is only constructable when the appropriate feature flag is enabled
-    #[reflect(ignore)]
-    unconstructable: PhantomData<()>, // Spooky!
-}
-
-#[cfg(feature = "ghost_nodes")]
-impl GhostNode {
-    /// Creates a new ghost node.
-    ///
-    /// This method is only available when the `ghost_node` feature is enabled,
-    /// and will eventually be deprecated then removed in favor of simply using `GhostNode` as no meaningful data is stored.
-    pub const fn new() -> Self {
-        GhostNode {
-            unconstructable: PhantomData,
-        }
-    }
-}
-
-/// System param that allows iteration of all UI root nodes.
-///
-/// A UI root node is either a [`Node`] without a [`Parent`], or with only [`GhostNode`] ancestors.
-#[derive(SystemParam)]
-pub struct UiRootNodes<'w, 's> {
-    root_node_query: Query<'w, 's, Entity, (With<Node>, Without<Parent>)>,
-    root_ghost_node_query: Query<'w, 's, Entity, (With<GhostNode>, Without<Parent>)>,
-    all_nodes_query: Query<'w, 's, Entity, With<Node>>,
-    ui_children: UiChildren<'w, 's>,
-}
-
-impl<'w, 's> UiRootNodes<'w, 's> {
-    pub fn iter(&'s self) -> impl Iterator<Item = Entity> + 's {
-        self.root_node_query
-            .iter()
-            .chain(self.root_ghost_node_query.iter().flat_map(|root_ghost| {
-                self.all_nodes_query
-                    .iter_many(self.ui_children.iter_ui_children(root_ghost))
-            }))
-    }
-}
-
-/// System param that gives access to UI children utilities, skipping over [`GhostNode`].
-#[derive(SystemParam)]
-pub struct UiChildren<'w, 's> {
-    ui_children_query: Query<
-        'w,
-        's,
-        (Option<&'static Children>, Has<GhostNode>),
-        Or<(With<Node>, With<GhostNode>)>,
-    >,
-    changed_children_query: Query<'w, 's, Entity, Changed<Children>>,
-    children_query: Query<'w, 's, &'static Children>,
-    ghost_nodes_query: Query<'w, 's, Entity, With<GhostNode>>,
-    parents_query: Query<'w, 's, &'static Parent>,
-}
-
-impl<'w, 's> UiChildren<'w, 's> {
-    /// Iterates the children of `entity`, skipping over [`GhostNode`].
-    ///
-    /// Traverses the hierarchy depth-first to ensure child order.
-    ///
-    /// # Performance
-    ///
-    /// This iterator allocates if the `entity` node has more than 8 children (including ghost nodes).
-    pub fn iter_ui_children(&'s self, entity: Entity) -> UiChildrenIter<'w, 's> {
-        UiChildrenIter {
-            stack: self
-                .ui_children_query
-                .get(entity)
-                .map_or(SmallVec::new(), |(children, _)| {
-                    children.into_iter().flatten().rev().copied().collect()
-                }),
-            query: &self.ui_children_query,
-        }
-    }
-
-    /// Returns the UI parent of the provided entity, skipping over [`GhostNode`].
-    pub fn get_parent(&'s self, entity: Entity) -> Option<Entity> {
-        self.parents_query
-            .iter_ancestors(entity)
-            .find(|entity| !self.ghost_nodes_query.contains(*entity))
-    }
-
-    /// Iterates the [`GhostNode`]s between this entity and its UI children.
-    pub fn iter_ghost_nodes(&'s self, entity: Entity) -> Box<dyn Iterator<Item = Entity> + 's> {
-        Box::new(
-            self.children_query
-                .get(entity)
-                .into_iter()
-                .flat_map(|children| {
-                    self.ghost_nodes_query
-                        .iter_many(children)
-                        .flat_map(|entity| {
-                            core::iter::once(entity).chain(self.iter_ghost_nodes(entity))
-                        })
-                }),
-        )
-    }
-
-    /// Given an entity in the UI hierarchy, check if its set of children has changed, e.g if children has been added/removed or if the order has changed.
-    pub fn is_changed(&'s self, entity: Entity) -> bool {
-        self.changed_children_query.contains(entity)
-            || self
-                .iter_ghost_nodes(entity)
-                .any(|entity| self.changed_children_query.contains(entity))
-    }
-
-    /// Returns `true` if the given entity is either a [`Node`] or a [`GhostNode`].
-    pub fn is_ui_node(&'s self, entity: Entity) -> bool {
-        self.ui_children_query.contains(entity)
-    }
-}
-
-pub struct UiChildrenIter<'w, 's> {
-    stack: SmallVec<[Entity; 8]>,
-    query: &'s Query<
-        'w,
-        's,
-        (Option<&'static Children>, Has<GhostNode>),
-        Or<(With<Node>, With<GhostNode>)>,
-    >,
-}
-
-impl<'w, 's> Iterator for UiChildrenIter<'w, 's> {
-    type Item = Entity;
-    fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            let entity = self.stack.pop()?;
-            if let Ok((children, has_ghost_node)) = self.query.get(entity) {
-                if !has_ghost_node {
-                    return Some(entity);
-                }
-                if let Some(children) = children {
-                    self.stack.extend(children.iter().rev().copied());
-                }
-            }
-        }
-    }
-}
-
-#[cfg(all(test, feature = "ghost_nodes"))]
-mod tests {
-    use bevy_ecs::{
-        prelude::Component,
-        system::{Query, SystemState},
-        world::World,
-    };
-    use bevy_hierarchy::{BuildChildren, ChildBuild};
-
-    use super::{GhostNode, Node, UiChildren, UiRootNodes};
-
-    #[derive(Component, PartialEq, Debug)]
-    struct A(usize);
-
-    #[test]
-    fn iterate_ui_root_nodes() {
-        let world = &mut World::new();
-
-        // Normal root
-        world
-            .spawn((A(1), Node::default()))
-            .with_children(|parent| {
-                parent.spawn((A(2), Node::default()));
-                parent
-                    .spawn((A(3), GhostNode::new()))
-                    .with_child((A(4), Node::default()));
-            });
-
-        // Ghost root
-        world
-            .spawn((A(5), GhostNode::new()))
-            .with_children(|parent| {
-                parent.spawn((A(6), Node::default()));
-                parent
-                    .spawn((A(7), GhostNode::new()))
-                    .with_child((A(8), Node::default()))
-                    .with_child(A(9));
-            });
-
-        let mut system_state = SystemState::<(UiRootNodes, Query<&A>)>::new(world);
-        let (ui_root_nodes, a_query) = system_state.get(world);
-
-        let result: Vec<_> = a_query.iter_many(ui_root_nodes.iter()).collect();
-
-        assert_eq!([&A(1), &A(6), &A(8)], result.as_slice());
-    }
-
-    #[test]
-    fn iterate_ui_children() {
-        let world = &mut World::new();
-
-        let n1 = world.spawn((A(1), Node::default())).id();
-        let n2 = world.spawn((A(2), GhostNode::new())).id();
-        let n3 = world.spawn((A(3), GhostNode::new())).id();
-        let n4 = world.spawn((A(4), Node::default())).id();
-        let n5 = world.spawn((A(5), Node::default())).id();
-
-        let n6 = world.spawn((A(6), GhostNode::new())).id();
-        let n7 = world.spawn((A(7), GhostNode::new())).id();
-        let n8 = world.spawn((A(8), Node::default())).id();
-        let n9 = world.spawn((A(9), GhostNode::new())).id();
-        let n10 = world.spawn((A(10), Node::default())).id();
-
-        let no_ui = world.spawn_empty().id();
-
-        world.entity_mut(n1).add_children(&[n2, n3, n4, n6]);
-        world.entity_mut(n2).add_children(&[n5]);
-
-        world.entity_mut(n6).add_children(&[n7, no_ui, n9]);
-        world.entity_mut(n7).add_children(&[n8]);
-        world.entity_mut(n9).add_children(&[n10]);
-
-        let mut system_state = SystemState::<(UiChildren, Query<&A>)>::new(world);
-        let (ui_children, a_query) = system_state.get(world);
-
-        let result: Vec<_> = a_query
-            .iter_many(ui_children.iter_ui_children(n1))
-            .collect();
-
-        assert_eq!([&A(5), &A(4), &A(8), &A(10)], result.as_slice());
-    }
-}
diff --git a/crates/bevy_ui/src/experimental/mod.rs b/crates/bevy_ui/src/experimental/mod.rs
index a8f2740c30424..cf8f684b0119c 100644
--- a/crates/bevy_ui/src/experimental/mod.rs
+++ b/crates/bevy_ui/src/experimental/mod.rs
@@ -12,6 +12,6 @@
 //! Be careful when using these features, especially in concert with third-party crates,
 //! as they may not be fully supported, functional or stable.
 
-mod ghost_hierarchy;
+mod ui_tree;
 
-pub use ghost_hierarchy::*;
+pub use ui_tree::*;
diff --git a/crates/bevy_ui/src/experimental/ui_tree.rs b/crates/bevy_ui/src/experimental/ui_tree.rs
new file mode 100644
index 0000000000000..06f325834161c
--- /dev/null
+++ b/crates/bevy_ui/src/experimental/ui_tree.rs
@@ -0,0 +1,523 @@
+//! This module contains [`GhostNode`] and utilities to flatten the UI hierarchy, traversing past ghost nodes.
+
+use bevy_ecs::{prelude::*, system::SystemParam};
+use bevy_hierarchy::{Children, HierarchyQueryExt, Parent};
+use bevy_reflect::prelude::*;
+use bevy_render::view::Visibility;
+use bevy_transform::prelude::Transform;
+use core::marker::PhantomData;
+use smallvec::SmallVec;
+
+use crate::Node;
+
+/// Marker component for entities that should be ignored within UI hierarchies.
+///
+/// The UI systems will traverse past these and treat their first non-ghost descendants as direct children of their first non-ghost ancestor.
+///
+/// Any components necessary for transform and visibility propagation will be added automatically.
+///
+/// Instances of this type cannot be constructed unless the `ghost_nodes` feature is enabled.
+#[derive(Component, Debug, Copy, Clone, Reflect)]
+#[cfg_attr(feature = "ghost_nodes", derive(Default))]
+#[reflect(Component, Debug)]
+#[require(Visibility, Transform)]
+pub struct GhostNode {
+    // This is a workaround to ensure that GhostNode is only constructable when the appropriate feature flag is enabled
+    #[reflect(ignore)]
+    unconstructable: PhantomData<()>, // Spooky!
+}
+
+#[cfg(feature = "ghost_nodes")]
+impl GhostNode {
+    /// Creates a new ghost node.
+    ///
+    /// This method is only available when the `ghost_node` feature is enabled,
+    /// and will eventually be deprecated then removed in favor of simply using `GhostNode` as no meaningful data is stored.
+    pub const fn new() -> Self {
+        GhostNode {
+            unconstructable: PhantomData,
+        }
+    }
+}
+
+/// System param that allows iteration of all UI root nodes.
+///
+/// A UI root node is either a [`Node`] without a [`Parent`], or with only [`GhostNode`] ancestors.
+#[derive(SystemParam)]
+pub struct UiRootNodes<'w, 's> {
+    root_node_query: Query<'w, 's, Entity, (With<Node>, Without<Parent>)>,
+    root_ghost_node_query: Query<'w, 's, Entity, (With<GhostNode>, Without<Parent>)>,
+    all_nodes_query: Query<'w, 's, Entity, With<Node>>,
+    ui_tree: UiTree<'w, 's>,
+}
+
+impl<'w, 's> UiRootNodes<'w, 's> {
+    pub fn iter(&'s self) -> impl Iterator<Item = Entity> + 's {
+        self.root_node_query
+            .iter()
+            .chain(self.root_ghost_node_query.iter().flat_map(|root_ghost| {
+                self.all_nodes_query
+                    .iter_many(self.ui_tree.iter_children(root_ghost))
+            }))
+    }
+}
+
+/// System param that gives access to UI tree utilities, skipping over [`GhostNode`] and stopping traversal at non-UI entities.
+#[derive(SystemParam)]
+pub struct UiTree<'w, 's> {
+    ui_children_query: Query<
+        'w,
+        's,
+        (Option<&'static Children>, Has<GhostNode>),
+        Or<(With<Node>, With<GhostNode>)>,
+    >,
+    changed_children_query: Query<'w, 's, Entity, Changed<Children>>,
+    nodes_query: Query<'w, 's, Entity, With<Node>>,
+    ghost_nodes_query: Query<'w, 's, Entity, With<GhostNode>>,
+    children_query: Query<'w, 's, &'static Children, Or<(With<Node>, With<GhostNode>)>>,
+    parents_query: Query<'w, 's, &'static Parent, Or<(With<Node>, With<GhostNode>)>>,
+}
+
+impl<'w, 's> UiTree<'w, 's> {
+    /// Iterates the [`Node`] children of `entity`, skipping over [`GhostNode`].
+    ///
+    /// Traverses the hierarchy depth-first to ensure child order.
+    ///
+    /// # Performance
+    ///
+    /// This iterator allocates if the `entity` node has more than 8 children (including ghost nodes).
+    pub fn iter_children(&'s self, entity: Entity) -> UiChildrenIter<'w, 's> {
+        UiChildrenIter {
+            stack: self
+                .ui_children_query
+                .get(entity)
+                .map_or(SmallVec::new(), |(children, _)| {
+                    children.into_iter().flatten().rev().copied().collect()
+                }),
+            query: &self.ui_children_query,
+        }
+    }
+
+    /// Returns the [`Node`] parent of the provided entity, skipping over [`GhostNode`].
+    pub fn parent(&'s self, entity: Entity) -> Option<Entity> {
+        self.parents_query
+            .iter_ancestors(entity)
+            .find(|entity| self.nodes_query.contains(*entity))
+    }
+
+    /// Returns the topmost [`Node`] ancestor of the given `entity`.
+    ///
+    /// This may be the entity itself if it has no parent or if it isn't part of a UI tree.
+    pub fn root_ancestor(&'s self, entity: Entity) -> Entity {
+        // Recursively search up the tree until we're out of parents
+        match self.parent(entity) {
+            Some(parent) => self.root_ancestor(parent),
+            None => entity,
+        }
+    }
+
+    /// Returns an [`Iterator`] of [`Node`] entities over all `entity`s ancestors within the current UI tree.
+    ///
+    /// Does not include the entity itself.
+    pub fn iter_ancestors(&'s self, entity: Entity) -> impl Iterator<Item = Entity> + 's {
+        self.parents_query
+            .iter_ancestors(entity)
+            .filter(|entity| self.nodes_query.contains(*entity))
+    }
+
+    /// Returns an [`Iterator`] of [`Node`] entities over all of `entity`s descendants within the current UI tree.
+    ///
+    /// Traverses the hierarchy breadth-first and does not include the entity itself.
+    pub fn iter_descendants(&'s self, entity: Entity) -> impl Iterator<Item = Entity> + 's {
+        self.children_query
+            .iter_descendants(entity)
+            .filter(|entity| self.nodes_query.contains(*entity))
+    }
+
+    /// Returns an [`Iterator`] of [`Node`] entities over all of `entity`s descendants within the current UI tree.
+    ///
+    /// Traverses the hierarchy depth-first and does not include the entity itself.
+    pub fn iter_descendants_depth_first(
+        &'s self,
+        entity: Entity,
+    ) -> impl Iterator<Item = Entity> + 's {
+        self.children_query
+            .iter_descendants_depth_first(entity)
+            .filter(|entity| self.nodes_query.contains(*entity))
+    }
+
+    /// Returns an [`Iterator`] of [`Node`] entities over the leaves of the UI tree underneath this `entity`.
+    ///
+    /// Only entities which have no [`Node`] descendants are considered leaves.
+    /// This will not include the entity itself, and will not include any entities which are not descendants of the entity,
+    /// even if they are leaves in the same hierarchical tree.
+    ///
+    /// Traverses the hierarchy depth-first.
+    pub fn iter_leaves(&'s self, entity: Entity) -> impl Iterator<Item = Entity> + 's {
+        UiLeavesIter {
+            stack: self
+                .ui_children_query
+                .get(entity)
+                .map_or(SmallVec::new(), |(children, _)| {
+                    children.into_iter().flatten().rev().copied().collect()
+                }),
+            query: &self.ui_children_query,
+            potential_leaf: None,
+        }
+    }
+
+    /// Returns an [`Iterator`] of [`Node`] entities over the `entity`s immediate siblings, who share the same first [`Node`] ancestor within the UI tree.
+    ///
+    /// The entity itself is not included in the iterator.
+    pub fn iter_siblings(&'s self, entity: Entity) -> impl Iterator<Item = Entity> + 's {
+        self.parent(entity).into_iter().flat_map(move |parent| {
+            self.iter_children(parent)
+                .filter(move |child| *child != entity)
+        })
+    }
+
+    /// Returns the index of a [`Node`] among its siblings, or [`None`] if it does not have a parent.
+    pub fn child_index(&'s self, entity: Entity) -> Option<usize> {
+        self.parent(entity)
+            .and_then(|parent| self.iter_children(parent).position(|child| child == entity))
+    }
+
+    /// Iterates the [`GhostNode`]s between this entity and its UI children.
+    pub fn iter_ghost_nodes(&'s self, entity: Entity) -> Box<dyn Iterator<Item = Entity> + 's> {
+        Box::new(
+            self.children_query
+                .get(entity)
+                .into_iter()
+                .flat_map(|children| {
+                    self.ghost_nodes_query
+                        .iter_many(children)
+                        .flat_map(|entity| {
+                            core::iter::once(entity).chain(self.iter_ghost_nodes(entity))
+                        })
+                }),
+        )
+    }
+
+    /// Given an entity in the UI tree, check if its children has changed, e.g if children has been added/removed or if the order has changed.
+    pub fn children_is_changed(&'s self, entity: Entity) -> bool {
+        self.changed_children_query.contains(entity)
+            || self
+                .iter_ghost_nodes(entity)
+                .any(|entity| self.changed_children_query.contains(entity))
+    }
+
+    /// Returns `true` if the given entity is either a [`Node`] or a [`GhostNode`].
+    pub fn is_ui_entity(&'s self, entity: Entity) -> bool {
+        self.ui_children_query.contains(entity)
+    }
+
+    /// Returns `true` if the given entity is a root in the UI tree.
+    ///
+    /// A [`Node`] is a root if it has no parent, or if all ancestors are ghost nodes.
+    ///
+    /// A [`GhostNode`] is a root if it has no parent.
+    pub fn is_root(&'s self, entity: Entity) -> bool {
+        self.parent(entity).is_none()
+    }
+
+    /// Returns `true` if the given entity is a leaf in the UI tree.
+    ///
+    /// A [`Node`] is a leaf if it has no [`Node`] descendants.
+    ///
+    /// A [`GhostNode`] is a leaf if it has no [`Node`] or [`GhostNode`] children.
+    pub fn is_leaf(&'s self, entity: Entity) -> bool {
+        if self.ghost_nodes_query.contains(entity) {
+            if let Ok(children) = self.children_query.get(entity) {
+                !children.iter().any(|child| {
+                    self.ghost_nodes_query.contains(*child) || self.nodes_query.contains(*child)
+                })
+            } else {
+                true
+            }
+        } else {
+            self.iter_descendants(entity).next().is_none()
+        }
+    }
+}
+
+pub struct UiChildrenIter<'w, 's> {
+    stack: SmallVec<[Entity; 8]>,
+    query: &'s Query<
+        'w,
+        's,
+        (Option<&'static Children>, Has<GhostNode>),
+        Or<(With<Node>, With<GhostNode>)>,
+    >,
+}
+
+impl<'w, 's> Iterator for UiChildrenIter<'w, 's> {
+    type Item = Entity;
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let entity = self.stack.pop()?;
+            if let Ok((children, has_ghost_node)) = self.query.get(entity) {
+                if !has_ghost_node {
+                    return Some(entity);
+                }
+                if let Some(children) = children {
+                    self.stack.extend(children.iter().rev().copied());
+                }
+            }
+        }
+    }
+}
+
+pub struct UiLeavesIter<'w, 's> {
+    stack: SmallVec<[Entity; 8]>,
+    query: &'s Query<
+        'w,
+        's,
+        (Option<&'static Children>, Has<GhostNode>),
+        Or<(With<Node>, With<GhostNode>)>,
+    >,
+    potential_leaf: Option<(usize, Entity)>,
+}
+
+impl<'w, 's> Iterator for UiLeavesIter<'w, 's> {
+    type Item = Entity;
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if let Some((stack_length, node_entity)) = self.potential_leaf {
+                if stack_length == self.stack.len() {
+                    // Confirmed leaf Node since no entities below it were Nodes
+                    self.potential_leaf = None;
+                    return Some(node_entity);
+                }
+            }
+
+            let entity = self.stack.pop()?;
+            if let Ok((children, has_ghost_node)) = self.query.get(entity) {
+                if !has_ghost_node {
+                    // This is a Node, store as potential leaf and continue traversing.
+                    self.potential_leaf = Some((self.stack.len(), entity));
+                }
+                if let Some(children) = children {
+                    self.stack.extend(children.iter().rev().copied());
+                }
+            }
+        }
+    }
+}
+
+#[cfg(all(test, feature = "ghost_nodes"))]
+mod tests {
+    use bevy_ecs::{
+        prelude::Component,
+        system::{Query, SystemState},
+        world::World,
+    };
+    use bevy_hierarchy::{BuildChildren, ChildBuild};
+
+    use super::{GhostNode, Node, UiRootNodes, UiTree};
+
+    #[derive(Component, PartialEq, Debug)]
+    struct A(usize);
+
+    #[test]
+    fn iterate_ui_root_nodes() {
+        let world = &mut World::new();
+
+        // Normal root
+        world
+            .spawn((A(1), Node::default()))
+            .with_children(|parent| {
+                parent.spawn((A(2), Node::default()));
+                parent
+                    .spawn((A(3), GhostNode::new()))
+                    .with_child((A(4), Node::default()));
+            });
+
+        // Ghost root
+        world
+            .spawn((A(5), GhostNode::new()))
+            .with_children(|parent| {
+                parent.spawn((A(6), Node::default()));
+                parent
+                    .spawn((A(7), GhostNode::new()))
+                    .with_child((A(8), Node::default()))
+                    .with_child(A(9));
+            });
+
+        let mut system_state = SystemState::<(UiRootNodes, Query<&A>)>::new(world);
+        let (ui_root_nodes, a_query) = system_state.get(world);
+
+        let result: Vec<_> = a_query.iter_many(ui_root_nodes.iter()).collect();
+
+        assert_eq!([&A(1), &A(6), &A(8)], result.as_slice());
+    }
+
+    #[test]
+    fn iterate_ui_children() {
+        let world = &mut World::new();
+
+        let n1 = world.spawn((A(1), Node::default())).id();
+        let n2 = world.spawn((A(2), GhostNode::new())).id();
+        let n3 = world.spawn((A(3), GhostNode::new())).id();
+        let n4 = world.spawn((A(4), Node::default())).id();
+        let n5 = world.spawn((A(5), Node::default())).id();
+
+        let n6 = world.spawn((A(6), GhostNode::new())).id();
+        let n7 = world.spawn((A(7), GhostNode::new())).id();
+        let n8 = world.spawn((A(8), Node::default())).id();
+        let n9 = world.spawn((A(9), GhostNode::new())).id();
+        let n10 = world.spawn((A(10), Node::default())).id();
+        let n11 = world.spawn((A(11), Node::default())).id();
+
+        let no_ui = world.spawn_empty().id();
+
+        world.entity_mut(n1).add_children(&[n2, n3, n4, n6]);
+        world.entity_mut(n2).add_children(&[n5]);
+
+        world.entity_mut(n6).add_children(&[n7, no_ui, n9]);
+        world.entity_mut(n7).add_children(&[n8]);
+        world.entity_mut(n9).add_children(&[n10]);
+        world.entity_mut(n10).add_children(&[n11]);
+
+        let mut system_state = SystemState::<(UiTree, Query<&A>)>::new(world);
+        let (ui_tree, a_query) = system_state.get(world);
+
+        let result: Vec<_> = a_query.iter_many(ui_tree.iter_children(n1)).collect();
+        assert_eq!([&A(5), &A(4), &A(8), &A(10)], result.as_slice());
+
+        assert_eq!(None, ui_tree.child_index(n1));
+        assert_eq!(Some(0), ui_tree.child_index(n5));
+        assert_eq!(Some(1), ui_tree.child_index(n4));
+        assert_eq!(Some(2), ui_tree.child_index(n8));
+        assert_eq!(Some(3), ui_tree.child_index(n10));
+
+        let result: Vec<_> = a_query.iter_many(ui_tree.iter_descendants(n1)).collect();
+        assert_eq!([&A(4), &A(5), &A(8), &A(10), &A(11)], result.as_slice());
+
+        let result: Vec<_> = a_query
+            .iter_many(ui_tree.iter_descendants_depth_first(n1))
+            .collect();
+        assert_eq!([&A(5), &A(4), &A(8), &A(10), &A(11)], result.as_slice());
+    }
+
+    #[test]
+    fn ancestors() {
+        let world = &mut World::new();
+
+        let n1 = world.spawn((A(1), Node::default())).id();
+        let n2 = world.spawn((A(2), GhostNode::new())).id();
+        let n3 = world.spawn((A(3), GhostNode::new())).id();
+        let n4 = world.spawn((A(4), Node::default())).id();
+        let n5 = world.spawn((A(5), Node::default())).id();
+
+        let n6 = world.spawn((A(6), GhostNode::new())).id();
+        let n7 = world.spawn((A(7), GhostNode::new())).id();
+        let n8 = world.spawn((A(8), Node::default())).id();
+
+        world.entity_mut(n1).add_children(&[n2, n3]);
+        world.entity_mut(n3).add_children(&[n4]);
+        world.entity_mut(n4).add_children(&[n5]);
+
+        world.entity_mut(n6).add_children(&[n7]);
+        world.entity_mut(n7).add_children(&[n8]);
+
+        let mut system_state = SystemState::<(UiTree, Query<&A>)>::new(world);
+        let (ui_tree, a_query) = system_state.get(world);
+
+        assert_eq!(&A(1), a_query.get(ui_tree.root_ancestor(n1)).unwrap());
+        assert_eq!(&A(1), a_query.get(ui_tree.root_ancestor(n2)).unwrap());
+        assert_eq!(&A(1), a_query.get(ui_tree.root_ancestor(n4)).unwrap());
+        assert_eq!(&A(1), a_query.get(ui_tree.root_ancestor(n5)).unwrap());
+        assert_eq!(&A(8), a_query.get(ui_tree.root_ancestor(n8)).unwrap());
+
+        assert_eq!(
+            [&A(1)],
+            a_query
+                .iter_many(ui_tree.iter_ancestors(n4))
+                .collect::<Vec<_>>()
+                .as_slice()
+        );
+
+        assert_eq!(
+            [&A(4), &A(1)],
+            a_query
+                .iter_many(ui_tree.iter_ancestors(n5))
+                .collect::<Vec<_>>()
+                .as_slice()
+        );
+
+        assert!(ui_tree.iter_ancestors(n8).next().is_none());
+    }
+
+    #[test]
+    fn iter_leaves() {
+        let world = &mut World::new();
+
+        let n1 = world.spawn((A(1), Node::default())).id();
+        let n2 = world.spawn((A(2), GhostNode::new())).id();
+        let n3 = world.spawn((A(3), Node::default())).id();
+        let n4 = world.spawn((A(4), Node::default())).id();
+        let n5 = world.spawn((A(5), Node::default())).id();
+        let n6 = world.spawn((A(6), GhostNode::default())).id();
+
+        world.entity_mut(n1).add_children(&[n2, n3]);
+        world.entity_mut(n2).add_children(&[n4]);
+        world.entity_mut(n3).add_children(&[n5]);
+        world.entity_mut(n5).add_children(&[n6]);
+
+        let mut system_state = SystemState::<(UiTree, Query<&A>)>::new(world);
+        let (ui_tree, a_query) = system_state.get(world);
+
+        let result: Vec<_> = a_query.iter_many(ui_tree.iter_leaves(n1)).collect();
+        assert_eq!([&A(4), &A(5)], result.as_slice());
+    }
+
+    #[test]
+    fn iter_siblings() {
+        let world = &mut World::new();
+
+        let n1 = world.spawn((A(1), Node::default())).id();
+        let n2 = world.spawn((A(2), GhostNode::new())).id();
+        let n3 = world.spawn((A(3), Node::default())).id();
+        let n4 = world.spawn((A(4), Node::default())).id();
+        let n5 = world.spawn((A(5), Node::default())).id();
+
+        world.entity_mut(n1).add_children(&[n2, n3]);
+        world.entity_mut(n2).add_children(&[n4, n5]);
+
+        let mut system_state = SystemState::<(UiTree, Query<&A>)>::new(world);
+        let (ui_tree, a_query) = system_state.get(world);
+
+        let result: Vec<_> = a_query.iter_many(ui_tree.iter_siblings(n5)).collect();
+        assert_eq!([&A(4), &A(3)], result.as_slice());
+    }
+
+    #[test]
+    fn is_root_or_leaf() {
+        let world = &mut World::new();
+
+        let n1 = world.spawn((A(1), Node::default())).id();
+        let n2 = world.spawn((A(2), GhostNode::new())).id();
+        let n3 = world.spawn((A(3), Node::default())).id();
+
+        let n4 = world.spawn((A(4), GhostNode::new())).id();
+        let n5 = world.spawn((A(5), Node::default())).id();
+
+        world.entity_mut(n1).add_children(&[n2, n3]);
+        world.entity_mut(n4).add_children(&[n5]);
+
+        let mut system_state = SystemState::<UiTree>::new(world);
+        let ui_tree = system_state.get(world);
+
+        assert!(ui_tree.is_root(n1));
+        assert!(!ui_tree.is_root(n2));
+        assert!(!ui_tree.is_root(n3));
+        assert!(ui_tree.is_root(n4));
+        assert!(ui_tree.is_root(n5));
+
+        assert!(!ui_tree.is_leaf(n1));
+        assert!(ui_tree.is_leaf(n2));
+        assert!(ui_tree.is_leaf(n3));
+        assert!(!ui_tree.is_leaf(n4));
+        assert!(ui_tree.is_leaf(n5));
+    }
+}
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 3cb680e15e25d..2a3ca3ebf2aac 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -1,5 +1,5 @@
 use crate::{
-    experimental::{UiChildren, UiRootNodes},
+    experimental::{UiRootNodes, UiTree},
     BorderRadius, ComputedNode, ContentSize, DefaultUiCamera, Display, Node, Outline, OverflowAxis,
     ScrollPosition, TargetCamera, UiScale,
 };
@@ -122,7 +122,7 @@ pub fn ui_layout_system(
         Option<&TargetCamera>,
     )>,
     computed_node_query: Query<(Entity, Option<Ref<Parent>>), With<ComputedNode>>,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
     mut removed_components: UiLayoutSystemRemovedComponentParam,
     mut node_transform_query: Query<(
         &mut ComputedNode,
@@ -263,7 +263,7 @@ pub fn ui_layout_system(
                 // Note: This does not cover the case where a parent's Node component was removed.
                 // Users are responsible for fixing hierarchies if they do that (it is not recommended).
                 // Detecting it here would be a permanent perf burden on the hot path.
-                if parent.is_changed() && !ui_children.is_ui_node(parent.get()) {
+                if parent.is_changed() && !ui_tree.is_ui_entity(parent.get()) {
                     warn!(
                         "Node ({entity}) is in a non-UI entity hierarchy. You are using an entity \
 with UI components as a child of an entity without UI components, your UI layout may be broken."
@@ -271,8 +271,8 @@ with UI components as a child of an entity without UI components, your UI layout
                 }
             }
 
-            if ui_children.is_changed(entity) {
-                ui_surface.update_children(entity, ui_children.iter_ui_children(entity));
+            if ui_tree.children_is_changed(entity) {
+                ui_surface.update_children(entity, ui_tree.iter_children(entity));
             }
         });
 
@@ -282,8 +282,8 @@ with UI components as a child of an entity without UI components, your UI layout
 
     // Re-sync changed children: avoid layout glitches caused by removed nodes that are still set as a child of another node
     computed_node_query.iter().for_each(|(entity, _)| {
-        if ui_children.is_changed(entity) {
-            ui_surface.update_children(entity, ui_children.iter_ui_children(entity));
+        if ui_tree.children_is_changed(entity) {
+            ui_surface.update_children(entity, ui_tree.iter_children(entity));
         }
     });
 
@@ -299,7 +299,7 @@ with UI components as a child of an entity without UI components, your UI layout
                 &ui_surface,
                 None,
                 &mut node_transform_query,
-                &ui_children,
+                &ui_tree,
                 inverse_target_scale_factor,
                 Vec2::ZERO,
                 Vec2::ZERO,
@@ -325,7 +325,7 @@ with UI components as a child of an entity without UI components, your UI layout
             Option<&Outline>,
             Option<&ScrollPosition>,
         )>,
-        ui_children: &UiChildren,
+        ui_tree: &UiTree,
         inverse_target_scale_factor: f32,
         parent_size: Vec2,
         parent_scroll_position: Vec2,
@@ -436,14 +436,14 @@ with UI components as a child of an entity without UI components, your UI layout
                     .insert(ScrollPosition::from(&clamped_scroll_position));
             }
 
-            for child_uinode in ui_children.iter_ui_children(entity) {
+            for child_uinode in ui_tree.iter_children(entity) {
                 update_uinode_geometry_recursive(
                     commands,
                     child_uinode,
                     ui_surface,
                     Some(viewport_size),
                     node_transform_query,
-                    ui_children,
+                    ui_tree,
                     inverse_target_scale_factor,
                     rounded_size,
                     clamped_scroll_position,
diff --git a/crates/bevy_ui/src/stack.rs b/crates/bevy_ui/src/stack.rs
index e419ce67fd771..cb08aa343f0fb 100644
--- a/crates/bevy_ui/src/stack.rs
+++ b/crates/bevy_ui/src/stack.rs
@@ -4,7 +4,7 @@ use bevy_ecs::prelude::*;
 use bevy_utils::HashSet;
 
 use crate::{
-    experimental::{UiChildren, UiRootNodes},
+    experimental::{UiRootNodes, UiTree},
     ComputedNode, GlobalZIndex, ZIndex,
 };
 
@@ -47,7 +47,7 @@ pub fn ui_stack_system(
     ui_root_nodes: UiRootNodes,
     root_node_query: Query<(Entity, Option<&GlobalZIndex>, Option<&ZIndex>)>,
     zindex_global_node_query: Query<(Entity, &GlobalZIndex, Option<&ZIndex>), With<ComputedNode>>,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
     zindex_query: Query<Option<&ZIndex>, (With<ComputedNode>, Without<GlobalZIndex>)>,
     mut update_query: Query<&mut ComputedNode>,
 ) {
@@ -85,7 +85,7 @@ pub fn ui_stack_system(
         update_uistack_recursive(
             &mut cache,
             root_entity,
-            &ui_children,
+            &ui_tree,
             &zindex_query,
             &mut ui_stack.uinodes,
         );
@@ -101,7 +101,7 @@ pub fn ui_stack_system(
 fn update_uistack_recursive(
     cache: &mut ChildBufferCache,
     node_entity: Entity,
-    ui_children: &UiChildren,
+    ui_tree: &UiTree,
     zindex_query: &Query<Option<&ZIndex>, (With<ComputedNode>, Without<GlobalZIndex>)>,
     ui_stack: &mut Vec<Entity>,
 ) {
@@ -109,8 +109,8 @@ fn update_uistack_recursive(
 
     let mut child_buffer = cache.pop();
     child_buffer.extend(
-        ui_children
-            .iter_ui_children(node_entity)
+        ui_tree
+            .iter_children(node_entity)
             .filter_map(|child_entity| {
                 zindex_query
                     .get(child_entity)
@@ -120,7 +120,7 @@ fn update_uistack_recursive(
     );
     child_buffer.sort_by_key(|k| k.1);
     for (child_entity, _) in child_buffer.drain(..) {
-        update_uistack_recursive(cache, child_entity, ui_children, zindex_query, ui_stack);
+        update_uistack_recursive(cache, child_entity, ui_tree, zindex_query, ui_stack);
     }
     cache.push(child_buffer);
 }
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index 428f0a6c3091e..970339b2c7cee 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -1,7 +1,7 @@
 //! This module contains systems that update the UI when something changes
 
 use crate::{
-    experimental::{UiChildren, UiRootNodes},
+    experimental::{UiRootNodes, UiTree},
     CalculatedClip, Display, Node, OverflowAxis, TargetCamera,
 };
 
@@ -26,22 +26,16 @@ pub fn update_clipping_system(
         &GlobalTransform,
         Option<&mut CalculatedClip>,
     )>,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
 ) {
     for root_node in root_nodes.iter() {
-        update_clipping(
-            &mut commands,
-            &ui_children,
-            &mut node_query,
-            root_node,
-            None,
-        );
+        update_clipping(&mut commands, &ui_tree, &mut node_query, root_node, None);
     }
 }
 
 fn update_clipping(
     commands: &mut Commands,
-    ui_children: &UiChildren,
+    ui_tree: &UiTree,
     node_query: &mut Query<(
         &Node,
         &ComputedNode,
@@ -128,8 +122,8 @@ fn update_clipping(
         Some(maybe_inherited_clip.map_or(clip_rect, |c| c.intersect(clip_rect)))
     };
 
-    for child in ui_children.iter_ui_children(entity) {
-        update_clipping(commands, ui_children, node_query, child, children_clip);
+    for child in ui_tree.iter_children(entity) {
+        update_clipping(commands, ui_tree, node_query, child, children_clip);
     }
 }
 
@@ -141,7 +135,7 @@ pub fn update_target_camera_system(
     >,
     node_query: Query<(Entity, Option<&TargetCamera>), With<Node>>,
     ui_root_nodes: UiRootNodes,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
 ) {
     // Track updated entities to prevent redundant updates, as `Commands` changes are deferred,
     // and updates done for changed_children_query can overlap with itself or with root_node_query
@@ -154,7 +148,7 @@ pub fn update_target_camera_system(
             root_node,
             target_camera,
             &node_query,
-            &ui_children,
+            &ui_tree,
             &mut commands,
             &mut updated_entities,
         );
@@ -164,7 +158,7 @@ pub fn update_target_camera_system(
     // by this point, and iteration will be skipped.
     // Otherwise, update changed children
     for (parent, target_camera) in &node_query {
-        if !ui_children.is_changed(parent) {
+        if !ui_tree.children_is_changed(parent) {
             continue;
         }
 
@@ -172,7 +166,7 @@ pub fn update_target_camera_system(
             parent,
             target_camera,
             &node_query,
-            &ui_children,
+            &ui_tree,
             &mut commands,
             &mut updated_entities,
         );
@@ -183,11 +177,11 @@ fn update_children_target_camera(
     entity: Entity,
     camera_to_set: Option<&TargetCamera>,
     node_query: &Query<(Entity, Option<&TargetCamera>), With<Node>>,
-    ui_children: &UiChildren,
+    ui_tree: &UiTree,
     commands: &mut Commands,
     updated_entities: &mut HashSet<Entity>,
 ) {
-    for child in ui_children.iter_ui_children(entity) {
+    for child in ui_tree.iter_children(entity) {
         // Skip if the child has already been updated or update is not needed
         if updated_entities.contains(&child)
             || camera_to_set == node_query.get(child).ok().and_then(|(_, camera)| camera)
@@ -209,7 +203,7 @@ fn update_children_target_camera(
             child,
             camera_to_set,
             node_query,
-            ui_children,
+            ui_tree,
             commands,
             updated_entities,
         );