diff --git a/src/home/navigation_tab_bar.rs b/src/home/navigation_tab_bar.rs
index bc23d32d..da284e9c 100644
--- a/src/home/navigation_tab_bar.rs
+++ b/src/home/navigation_tab_bar.rs
@@ -31,10 +31,10 @@
 use makepad_widgets::*;
 use crate::{
     avatar_cache::{self, AvatarCacheEntry}, login::login_screen::LoginAction, logout::logout_confirm_modal::LogoutAction, profile::{
-        user_profile::{AvatarState, UserProfile},
+        user_profile::UserProfile,
         user_profile_cache::{self, UserProfileUpdate},
     }, shared::{
-        avatar::AvatarWidgetExt,
+        avatar::{AvatarState, AvatarWidgetExt},
         callout_tooltip::{CalloutTooltipOptions, TooltipAction, TooltipPosition},
         styles::*,
         verification_badge::VerificationBadgeWidgetExt,
diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 7f9ccec3..5a0799c2 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -26,12 +26,12 @@ use ruma::{OwnedUserId, events::{AnySyncMessageLikeEvent, AnySyncTimelineEvent,
 
 use crate::{
     app::AppStateAction, avatar_cache, event_preview::{plaintext_body_of_timeline_item, text_preview_of_encrypted_message, text_preview_of_member_profile_change, text_preview_of_other_message_like, text_preview_of_other_state, text_preview_of_room_membership_change, text_preview_of_timeline_item}, home::{edited_indicator::EditedIndicatorWidgetRefExt, link_preview::{LinkPreviewCache, LinkPreviewRef, LinkPreviewWidgetRefExt}, loading_pane::{LoadingPaneState, LoadingPaneWidgetExt}, room_image_viewer::{get_image_name_and_filesize, populate_matrix_image_modal}, rooms_list::RoomsListRef, tombstone_footer::SuccessorRoomDetails}, media_cache::{MediaCache, MediaCacheEntry}, profile::{
-        user_profile::{AvatarState, ShowUserProfileAction, UserProfile, UserProfileAndRoomId, UserProfilePaneInfo, UserProfileSlidingPaneRef, UserProfileSlidingPaneWidgetExt},
+        user_profile::{ShowUserProfileAction, UserProfile, UserProfileAndRoomId, UserProfilePaneInfo, UserProfileSlidingPaneRef, UserProfileSlidingPaneWidgetExt},
         user_profile_cache,
     },
     room::{BasicRoomDetails, room_input_bar::RoomInputBarState, typing_notice::TypingNoticeWidgetExt},
     shared::{
-        avatar::AvatarWidgetRefExt, callout_tooltip::{CalloutTooltipOptions, TooltipAction, TooltipPosition}, confirmation_modal::ConfirmationModalContent, html_or_plaintext::{HtmlOrPlaintextRef, HtmlOrPlaintextWidgetRefExt, RobrixHtmlLinkAction}, image_viewer::{ImageViewerAction, ImageViewerMetaData, LoadState}, jump_to_bottom_button::{JumpToBottomButtonWidgetExt, UnreadMessageCount}, popup_list::{PopupItem, PopupKind, enqueue_popup_notification}, restore_status_view::RestoreStatusViewWidgetExt, styles::*, text_or_image::{TextOrImageAction, TextOrImageRef, TextOrImageWidgetRefExt}, timestamp::TimestampWidgetRefExt
+        avatar::{AvatarState, AvatarWidgetRefExt}, callout_tooltip::{CalloutTooltipOptions, TooltipAction, TooltipPosition}, confirmation_modal::ConfirmationModalContent, html_or_plaintext::{HtmlOrPlaintextRef, HtmlOrPlaintextWidgetRefExt, RobrixHtmlLinkAction}, image_viewer::{ImageViewerAction, ImageViewerMetaData, LoadState}, jump_to_bottom_button::{JumpToBottomButtonWidgetExt, UnreadMessageCount}, popup_list::{PopupItem, PopupKind, enqueue_popup_notification}, restore_status_view::RestoreStatusViewWidgetExt, styles::*, text_or_image::{TextOrImageAction, TextOrImageRef, TextOrImageWidgetRefExt}, timestamp::TimestampWidgetRefExt
     },
     sliding_sync::{BackwardsPaginateUntilEventRequest, MatrixRequest, PaginationDirection, TimelineEndpoints, TimelineRequestSender, UserPowerLevels, get_client, submit_async_request, take_timeline_endpoints}, utils::{self, ImageFormat, MEDIA_THUMBNAIL_FORMAT, RoomNameId, unix_time_millis_to_datetime}
 };
diff --git a/src/home/rooms_list.rs b/src/home/rooms_list.rs
index 165a037d..e49a9d1b 100644
--- a/src/home/rooms_list.rs
+++ b/src/home/rooms_list.rs
@@ -358,7 +358,7 @@ pub enum InviteState {
 
 /// The value in the RoomsList's `space_map` that contains info about a space.
 #[derive(Default)]
-struct SpaceMapValue { 
+struct SpaceMapValue {
     /// Whether this space is fully paginated, meaning that our client has obtained
     /// the full list of direct children within this space.
     ///
@@ -1034,6 +1034,8 @@ impl RoomsList {
                     kind: PopupKind::Error,
                 });
             }
+            // DetailedChildren is handled by SpaceLobbyScreen, not RoomsList.
+            SpaceRoomListAction::DetailedChildren { .. } => { }
         }
     }
 
@@ -1395,6 +1397,22 @@ impl RoomsListRef {
     pub fn get_selected_space_id(&self) -> Option<OwnedRoomId> {
         self.borrow()?.selected_space.as_ref().map(|ss| ss.room_id().clone())
     }
+
+    /// Returns a clone of the space request sender channel, if available.
+    ///
+    /// This allows other widgets to submit space-related requests directly
+    /// to the background space service.
+    pub fn get_space_request_sender(&self) -> Option<UnboundedSender<SpaceRequest>> {
+        self.borrow()?.space_request_sender.clone()
+    }
+
+    /// Returns the parent chain of the given space, if known.
+    pub fn get_space_parent_chain(&self, space_id: &OwnedRoomId) -> Option<ParentChain> {
+        self.borrow()?
+            .space_map
+            .get(space_id)
+            .map(|smv| smv.parent_chain.clone())
+    }
 }
 
 pub struct RoomsListScopeProps {
diff --git a/src/home/space_lobby.rs b/src/home/space_lobby.rs
index 9a7c60d4..2a6f27b6 100644
--- a/src/home/space_lobby.rs
+++ b/src/home/space_lobby.rs
@@ -6,8 +6,16 @@
 //!    that allows the user to click on it to show the `SpaceLobby`.
 //!
 
+use std::collections::{HashMap, HashSet};
+use imbl::Vector;
 use makepad_widgets::*;
-use crate::utils::RoomNameId;
+use matrix_sdk::{RoomState, ruma::OwnedRoomId};
+use matrix_sdk_ui::spaces::SpaceRoom;
+use ruma::room::JoinRuleSummary;
+use tokio::sync::mpsc::UnboundedSender;
+use crate::{
+    home::rooms_list::RoomsListRef, shared::avatar::{AvatarState, AvatarWidgetExt, AvatarWidgetRefExt}, space_service_sync::{SpaceRequest, SpaceRoomExt, SpaceRoomListAction}, utils::{self, RoomNameId}
+};
 
 
 live_design! {
@@ -19,6 +27,8 @@ live_design! {
     use crate::shared::helpers::*;
     use crate::shared::avatar::*;
 
+    ICON_COLLAPSE = dep("crate://self/resources/icons/triangle_fill.svg")
+
     // An entry in the RoomsList that will show the SpaceLobby when clicked.
     pub SpaceLobbyEntry = {{SpaceLobbyEntry}}<RoundedView> {
         visible: false, // only visible when a space is selected
@@ -171,26 +181,270 @@ live_design! {
         }
     }
 
+    // A view that draws the hierarchical tree structure lines.
+    DrawTreeLine = {{DrawTreeLine}} { }
+
+    TreeLines = {{TreeLines}} {
+        width: 0, height: Fill
+        draw_bg: {
+            indent_width: 44.0
+            level: 0.0
+            is_last: 0.0
+            parent_mask: 0.0
+
+            fn pixel(self) -> vec4 {
+                let pos = self.pos * self.rect_size;
+                let indent = self.indent_width;
+                // Yes, this should be 0.5, but 0.6 makes it line up nicely
+                // with the middle of the parent-level avatar, which is better.
+                let half_indent = indent * 0.6;
+                let line_width = 1.0;
+                let half_line = 0.5;
+
+                let c = vec4(0.0);
+
+                // Dumb approach, but it works.
+                for i in 0..20 {
+                    if float(i) > self.level { break; }
+                    
+                    if float(i) < self.level {
+                        // Check mask for parent levels
+                        let mask_bit = mod(floor(self.parent_mask / pow(2.0, float(i))), 2.0);
+                        if mask_bit > 0.5 {
+                             // Draw full vertical line
+                             if abs(pos.x - (float(i) * indent + half_indent)) < half_line && pos.y < self.rect_size.y {
+                                  return vec4(0.8, 0.8, 0.8, 1.0);
+                             }
+                        }
+                    } else {
+                        // Current level: connection to self
+                        
+                        // Horizontal line to content
+                        let hy = self.rect_size.y * 0.5;
+                        if abs(pos.y - hy) < half_line && pos.x > (float(i) * indent + half_indent) {
+                             return vec4(0.8, 0.8, 0.8, 1.0);
+                        }
+                        
+                        // Vertical line (L shape)
+                        if abs(pos.x - (float(i) * indent + half_indent)) < half_line && pos.y < (self.rect_size.y * (1.0 - 0.5 * self.is_last)) {
+                              return vec4(0.8, 0.8, 0.8, 1.0);
+                        }
+                    }
+                }
+                return c;
+            }
+        }
+    }
+
+    // Entry for a child subspace (can be expanded)
+    pub SubspaceEntry = {{SubspaceEntry}} {
+        width: Fill,
+        height: 44,
+        flow: Right,
+        align: {y: 0.5}
+        padding: {left: 8, right: 12}
+        cursor: Hand
+
+        show_bg: true
+        draw_bg: {
+            instance hover: 0.0
+            color: #fff
+            uniform color_hover: #f5f5f5
+            fn pixel(self) -> vec4 {
+                return mix(self.color, self.color_hover, self.hover);
+            }
+        }
+
+        // The connecting hierarchical lines on the left.
+        tree_lines = <TreeLines> {}
+
+        // Expand/collapse icon
+        expand_icon = <IconRotated> {
+            width: 16,
+            height: 16,
+            margin: { top: 7, left: -8, right: 2 }
+            draw_icon: {
+                svg_file: (ICON_COLLAPSE)
+                rotation_angle: 90.0
+                color: #888
+            }
+            icon_walk: { width: 10, height: 10 }
+        }
+
+        avatar = <Avatar> { width: 32, height: 32, margin: {right: 8} }
+
+        content = <View> {
+            width: Fill, height: Fit, flow: Down, spacing: 5,
+            name_label = <Label> {
+                margin: 0
+                padding: 0
+                width: Fill, height: Fit,
+                draw_text: { text_style: <REGULAR_TEXT>{font_size: 10.5}, color: #1a1a1a, wrap: Ellipsis }
+            }
+            info_label = <Label> {
+                margin: 0
+                padding: 0
+                width: Fill, height: Fit,
+                draw_text: { text_style: <REGULAR_TEXT>{font_size: 8.5}, color: #737373, wrap: Ellipsis }
+            }
+        }
+
+        animator: {
+            hover = {
+                default: off
+                off = { from: {all: Forward {duration: 0.1}}, apply: { draw_bg: {hover: 0.0} } }
+                on = { from: {all: Snap}, apply: { draw_bg: {hover: 1.0} } }
+            }
+        }
+    }
+
+    // Entry for a child room within a space, which cannot be expanded.
+    pub RoomEntry = {{RoomEntry}}<SubspaceEntry> {
+        cursor: Default
+
+        expand_icon = <View> {
+            width: 10
+            height: 16
+        }
+    }
+
+    StatusLabel = <View> {
+        width: Fill, height: Fit,
+        flow: Right,
+        align: { x: 0.5, y: 0.5 }
+        padding: 20.0,
+
+        loading_spinner = <LoadingSpinner> {
+            width: 18,
+            height: 18,
+            draw_bg: {
+                color: (COLOR_ACTIVE_PRIMARY)
+                border_size: 2.5,
+            }
+        }
+
+        label = <Label> {
+            padding: {left: 10}
+            width: Fit,
+            flow: RightWrap,
+            align: { x: 0.5, y: 0.5 }
+            draw_text: {
+                wrap: Word,
+                color: #737373,
+                text_style: <REGULAR_TEXT>{font_size: 10}
+            }
+            text: "Loading rooms and spaces..."
+        }
+    }
+
+    // Small loading indicator shown inline when loading subspace children
+    SubspaceLoadingEntry = <View> {
+        width: Fill, height: 36,
+        flow: Right,
+        align: { y: 0.5 }
+        padding: {left: 8, right: 12}
+
+        // Tree lines replace the spacer
+        tree_lines = <TreeLines> {}
+
+        loading_spinner = <LoadingSpinner> {
+            width: 14,
+            height: 14,
+            margin: {left: 8, right: 10}
+            draw_bg: {
+                color: (COLOR_ACTIVE_PRIMARY)
+                border_size: 2.0,
+            }
+        }
+
+        label = <Label> {
+            width: Fit,
+            height: Fit,
+            draw_text: {
+                text_style: <REGULAR_TEXT>{font_size: 9},
+                color: #888,
+            }
+            text: "Loading..."
+        }
+    }
+
     // The main view that shows the lobby (homepage) for a space.
     pub SpaceLobbyScreen = {{SpaceLobbyScreen}} {
         width: Fill, height: Fill,
-        padding: {top: 100}
-        align: {x: 0.5}
+        flow: Down,
 
         show_bg: true
         draw_bg: {
-            color: (COLOR_PRIMARY)
+            color: #fff
         }
 
-        title = <Label> {
-            flow: RightWrap,
-            align: {x: 0.5}
-            draw_text: {
-                text_style: <TITLE_TEXT>{font_size: 13},
-                color: #000
-                wrap: Word
+        // Header with parent space info
+        header = <View> {
+            width: Fill,
+            height: Fit,
+            flow: Down,
+            padding: {left: 16, right: 16, top: 16, bottom: 8}
+
+            show_bg: true,
+            draw_bg: {
+                color: #fafafa
+            }
+
+            title = <Label> {
+                width: Fill,
+                height: Fit,
+                draw_text: {
+                    text_style: <REGULAR_TEXT>{font_size: 9},
+                    color: #737373,
+                    wrap: Word,
+                }
+                text: "Rooms and Spaces in"
+            }
+            
+            // Parent space row with avatar and name
+            parent_space_row = <View> {
+                width: Fill,
+                height: Fit,
+                flow: Right,
+                align: { y: 0.5 }
+                padding: { top: 8 }
+                
+                parent_avatar = <Avatar> {
+                    width: 36,
+                    height: 36,
+                    margin: { right: 12 }
+                }
+                
+                parent_name = <Label> {
+                    width: Fill,
+                    height: Fit,
+                    draw_text: {
+                        text_style: <TITLE_TEXT>{font_size: 14},
+                        color: #1a1a1a,
+                        wrap: Ellipsis,
+                    }
+                    text: ""
+                }
+            }
+        }
+
+        // The hierarchical tree list
+        tree_list = <PortalList> {
+            keep_invisible: false,
+            max_pull_down: 0.0,
+            auto_tail: false,
+            width: Fill, height: Fill
+            flow: Down,
+            spacing: 0.0
+
+            subspace_entry = <SubspaceEntry> {}
+            room_entry = <RoomEntry> {}
+            subspace_loading = <SubspaceLoadingEntry> {}
+            status_label = <StatusLabel> {}
+            bottom_filler = <View> {
+                width: Fill,
+                height: 80.0,
             }
-            text: "Space Lobby Screen is not yet implemented"
         }
     }
 }
@@ -246,39 +500,525 @@ pub enum SpaceLobbyAction {
     SpaceLobbyEntryClicked,
 }
 
+#[derive(Live, LiveHook, LiveRegister)]
+#[repr(C)]
+pub struct DrawTreeLine {
+    #[deref] draw_super: DrawQuad,
+    #[live] indent_width: f32,
+    #[live] level: f32,
+    #[live] is_last: f32,
+    #[live] parent_mask: f32,
+}
+
+#[derive(Live, LiveHook, Widget)]
+pub struct TreeLines {
+    #[redraw] #[live] draw_bg: DrawTreeLine,
+    #[walk] walk: Walk,
+}
+
+impl Widget for TreeLines {
+    fn handle_event(&mut self, _cx: &mut Cx, _event: &Event, _scope: &mut Scope) { }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, _scope: &mut Scope, walk: Walk) -> DrawStep {
+        let indent_pixel = (self.draw_bg.level + 1.0) * self.draw_bg.indent_width;
+        let mut walk = walk;
+        walk.width = Size::Fixed(indent_pixel as f64);
+        
+        self.draw_bg.draw_walk(cx, walk);
+        DrawStep::done()
+    }
+}
+
+/// A clickable entry for a child subspace.
+#[derive(Live, LiveHook, Widget)]
+pub struct SubspaceEntry {
+    #[deref] view: View,
+    #[animator] animator: Animator,
+    #[rust] space_id: Option<OwnedRoomId>,
+}
+
+/// A clickable entry for a child room.
+#[derive(Live, LiveHook, Widget)]
+pub struct RoomEntry {
+    #[deref] view: View,
+    #[animator] animator: Animator,
+    #[rust] room_id: Option<OwnedRoomId>,
+}
+
+/// Action emitted when a subspace entry is clicked.
+#[derive(Clone, Debug, DefaultNone)]
+pub enum SubspaceEntryAction {
+    Clicked { space_id: OwnedRoomId },
+    None,
+}
+
+/// Action emitted when a room entry is clicked.
+#[derive(Clone, Debug, DefaultNone)]
+pub enum RoomEntryAction {
+    Clicked { room_id: OwnedRoomId },
+    None,
+}
+
+impl Widget for SubspaceEntry {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        if self.animator_handle_event(cx, event).must_redraw() {
+            self.redraw(cx);
+        }
+
+        match event.hits(cx, self.view.area()) {
+            Hit::FingerHoverIn(_) => { self.animator_play(cx, ids!(hover.on)); }
+            Hit::FingerHoverOut(_) => { self.animator_play(cx, ids!(hover.off)); }
+            Hit::FingerDown(_) => { cx.set_key_focus(self.view.area()); }
+            Hit::FingerUp(fe) if fe.is_over && fe.is_primary_hit() && fe.was_tap() => {
+                if let Some(space_id) = self.space_id.clone() {
+                    cx.widget_action(
+                        self.widget_uid(),
+                        &scope.path, 
+                        SubspaceEntryAction::Clicked { space_id },
+                    );
+                }
+            }
+            _ => {}
+        }
+        self.view.handle_event(cx, event, scope);
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        self.view.draw_walk(cx, scope, walk)
+    }
+}
+
+impl Widget for RoomEntry {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        if self.animator_handle_event(cx, event).must_redraw() {
+            self.redraw(cx);
+        }
+
+        match event.hits(cx, self.view.area()) {
+            Hit::FingerHoverIn(_) => { self.animator_play(cx, ids!(hover.on)); }
+            Hit::FingerHoverOut(_) => { self.animator_play(cx, ids!(hover.off)); }
+            Hit::FingerDown(_) => { cx.set_key_focus(self.view.area()); }
+            Hit::FingerUp(fe) if fe.is_over && fe.is_primary_hit() && fe.was_tap() => {
+                if let Some(room_id) = self.room_id.clone() {
+                    cx.widget_action(self.widget_uid(), &scope.path,
+                        RoomEntryAction::Clicked { room_id });
+                }
+            }
+            _ => {}
+        }
+        self.view.handle_event(cx, event, scope);
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        self.view.draw_walk(cx, scope, walk)
+    }
+}
+
+/// The subset of info in [`SpaceRoom`] that we display for each room/space.
+struct SpaceRoomInfo {
+    id: OwnedRoomId,
+    name: String,
+    #[allow(unused)]
+    topic: Option<String>,
+    #[allow(unused)]
+    room_avatar: AvatarState,
+    num_joined_members: u64,
+    #[allow(unused)]
+    state: Option<RoomState>,
+    #[allow(unused)]
+    join_rule: Option<JoinRuleSummary>,
+    /// If `Some`, this is a space. If `None`, it's a room.
+    children_count: Option<u64>,
+}
+impl SpaceRoomInfo {
+    fn is_space(&self) -> bool {
+        self.children_count.is_some()
+    }
+}
+impl From<&SpaceRoom> for SpaceRoomInfo {
+    fn from(space_room: &SpaceRoom) -> Self {
+        SpaceRoomInfo {
+            id: space_room.room_id.clone(),
+            name: space_room.display_name.clone(),
+            topic: space_room.topic.clone(),
+            room_avatar: AvatarState::Known(space_room.avatar_url.clone()),
+            num_joined_members: space_room.num_joined_members,
+            state: space_room.state,
+            join_rule: space_room.join_rule.clone(),
+            children_count: space_room.is_space().then_some(space_room.children_count),
+        }
+    }
+}
+impl From<SpaceRoom> for SpaceRoomInfo {
+    fn from(space_room: SpaceRoom) -> Self {
+        SpaceRoomInfo {
+            children_count: space_room.is_space().then_some(space_room.children_count),
+            id: space_room.room_id,
+            name: space_room.display_name,
+            topic: space_room.topic,
+            room_avatar: AvatarState::Known(space_room.avatar_url),
+            num_joined_members: space_room.num_joined_members,
+            state: space_room.state,
+            join_rule: space_room.join_rule,
+        }
+    }
+}
+
+/// An entry in the tree to be displayed.
+#[allow(clippy::large_enum_variant)]
+enum TreeEntry {
+    /// A regular space or room entry.
+    Item {
+        /// The info needed to display this space or room.
+        info: SpaceRoomInfo,
+        /// The nesting level (0 = direct child of the displayed space).
+        level: usize,
+        /// Whether this entry is the last child of its parent.
+        is_last: bool,
+        /// Bitmask of which parent levels need continuation lines.
+        parent_mask: u32,
+    },
+    /// A loading indicator for a subspace that's still loading.
+    Loading {
+        /// The nesting level for proper indentation.
+        level: usize,
+        /// Bitmask of which parent levels need continuation lines.
+        parent_mask: u32,
+    },
+}
 
 /// The view showing the lobby/homepage for a given space.
 #[derive(Live, LiveHook, Widget)]
 pub struct SpaceLobbyScreen {
     #[deref] view: View,
+
+    /// The space that is currently being displayed.
     #[rust] space_name_id: Option<RoomNameId>,
+
+    /// The sender channel to submit space requests to the background service.
+    #[rust] space_request_sender: Option<UnboundedSender<SpaceRequest>>,
+
+    /// Cache of detailed children for each space we've fetched.
+    /// Key is the space_id, value is the list of its direct children.
+    #[rust] children_cache: HashMap<OwnedRoomId, Vector<SpaceRoom>>,
+
+    /// The set of space IDs that are currently expanded (showing their children).
+    #[rust] expanded_spaces: HashSet<OwnedRoomId>,
+
+    /// The ordered list of children to display in the space tree.
+    #[rust] tree_entries: Vec<TreeEntry>,
+
+    /// The set of space IDs that are currently loading their children.
+    #[rust] loading_subspaces: HashSet<OwnedRoomId>,
+
+    /// Whether we are currently loading the initial data.
+    #[rust] is_loading: bool,
 }
 
 impl Widget for SpaceLobbyScreen {
     fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
         self.view.handle_event(cx, event, scope);
+
+        if let Event::Actions(actions) = event {
+            for action in actions {
+                if let Some(SpaceRoomListAction::DetailedChildren { space_id, children, .. }) = action.downcast_ref() {
+                    self.update_children_in_space(cx, space_id, children);
+                }
+
+                // Handle SubspaceEntry clicks
+                if let SubspaceEntryAction::Clicked { space_id: room_id } = action.as_widget_action().cast() {
+                    self.toggle_space_expansion(cx, &room_id);
+                }
+
+                // Handle RoomEntry clicks
+                if let RoomEntryAction::Clicked { room_id: _ } = action.as_widget_action().cast() {
+                    // TODO: Navigate to the room
+                }
+            }
+        }
     }
-    
+
     fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
-        self.view.draw_walk(cx, scope, walk)
+        while let Some(widget_to_draw) = self.view.draw_walk(cx, scope, walk).step() {
+            let portal_list_ref = widget_to_draw.as_portal_list();
+            let Some(mut list) = portal_list_ref.borrow_mut() else { continue };
+
+            let entry_count = self.tree_entries.len();
+            let total_count = if self.is_loading || entry_count == 0 {
+                2 // status label + filler
+            } else {
+                entry_count + 1 // entries + filler
+            };
+
+            list.set_item_range(cx, 0, total_count);
+
+            while let Some(item_id) = list.next_visible_item(cx) {
+                // Draw loading indicator
+                let item = if self.is_loading && item_id == 0 {
+                    let item = list.item(cx, item_id, id!(status_label));
+                    item.label(ids!(label)).set_text(cx, "Loading rooms and spaces...");
+                    item
+                }
+                // No entries found
+                else if entry_count == 0 && item_id == 0 {
+                    let item = list.item(cx, item_id, id!(status_label));
+                    item.label(ids!(label)).set_text(cx, "No rooms or spaces found.");
+                    item.view(ids!(loading_spinner)).apply_over(cx, live! { visible: false });
+                    item
+                }
+                // Draw a regular entrty
+                else if let Some(entry) = self.tree_entries.get(item_id) {
+                    match entry {
+                        TreeEntry::Item { info, level, is_last, parent_mask } => {
+                            let item = if info.is_space() {
+                                let item = list.item(cx, item_id, id!(subspace_entry));
+                                if let Some(mut inner) = item.borrow_mut::<SubspaceEntry>() {
+                                    inner.space_id = Some(info.id.clone());
+                                }
+                                // Expand icon
+                                let is_expanded = self.expanded_spaces.contains(&info.id);
+                                let angle = if is_expanded { 180.0 } else { 90.0 };
+                                item.icon(ids!(expand_icon)).apply_over(cx, live! {
+                                    draw_icon: { rotation_angle: (angle) }
+                                });
+                                item
+                            } else {
+                                let item = list.item(cx, item_id, id!(room_entry));
+                                if let Some(mut inner) = item.borrow_mut::<RoomEntry>() {
+                                    inner.room_id = Some(info.id.clone());
+                                }
+                                item
+                            };
+
+                            // Below, draw things that are common to child rooms and subspaces.
+                            item.label(ids!(content.name_label)).set_text(cx, &info.name);
+                            // TODO: query (and update) room/space avatar from the avatar_cache
+                            let avatar_ref = item.avatar(ids!(avatar));
+                            let first_char = utils::user_name_first_letter(&info.name);
+                            avatar_ref.show_text(cx, None, None, first_char.unwrap_or("#"));
+
+                            if let Some(mut lines) = item.widget(ids!(tree_lines)).borrow_mut::<TreeLines>() {
+                                lines.draw_bg.level = *level as f32;
+                                lines.draw_bg.is_last = if *is_last { 1.0 } else { 0.0 };
+                                lines.draw_bg.parent_mask = *parent_mask as f32;
+                                lines.draw_bg.indent_width = 44.0; // Hardcoded to match
+                            }
+
+                            let info_label = item.label(ids!(content.info_label));
+                            if let Some(c) = info.children_count && c > 0 {
+                                info_label.set_text(cx, &format!(
+                                    "{} {} | ~{} {}",
+                                    info.num_joined_members,
+                                    match info.num_joined_members {
+                                        1 => "member",
+                                        _ => "members",
+                                    },
+                                    c,
+                                    match c {
+                                        1 => "room",
+                                        _ => "rooms",
+                                    }
+                                ));
+                            } else {
+                                match info.num_joined_members {
+                                    1 => info_label.set_text(cx, "1 member"),
+                                    n => info_label.set_text(cx, &format!("{n} members")),
+                                }
+                            };
+
+                            item
+                        }
+                        TreeEntry::Loading { level, parent_mask } => {
+                            // Draw loading indicator for subspace
+                            let item = list.item(cx, item_id, id!(subspace_loading));
+                            // Configure tree lines
+                            if let Some(mut lines) = item.widget(ids!(tree_lines)).borrow_mut::<TreeLines>() {
+                                lines.draw_bg.level = *level as f32;
+                                lines.draw_bg.is_last = 1.0; 
+                                lines.draw_bg.parent_mask = *parent_mask as f32;
+                                lines.draw_bg.indent_width = 44.0;
+                            }
+                            item
+                        }
+                    }
+                } else {
+                    list.item(cx, item_id, id!(bottom_filler))
+                };
+                item.draw_all(cx, scope);
+            }
+        }
+
+        DrawStep::done()
     }
 }
 
 impl SpaceLobbyScreen {
-    pub fn set_displayed_space(&mut self, cx: &mut Cx, space_name_id: &RoomNameId) {
-        // If this space is already being displayed, then do nothing.
-        if self.space_name_id.as_ref().is_some_and(|sni| sni.room_id() == space_name_id.room_id()) { return; }
 
-        self.view.label(ids!(title)).set_text(cx, &format!(
-            "Space Lobby Screen is not yet implemented.\n\n\
-            Space Name: {}\n\nSpace ID: {}",
-            space_name_id,
-            space_name_id.room_id(),
-        ));
+    /// Handle receiving detailed children for a space.
+    fn update_children_in_space(&mut self, cx: &mut Cx, space_id: &OwnedRoomId, children: &Vector<SpaceRoom>) {
+        self.children_cache.insert(space_id.clone(), children.clone());
+        self.loading_subspaces.remove(space_id);
 
-        // TODO: populate the rest of the space lobby screen content
+        // If this is for our displayed space, mark as loaded and rebuild tree
+        if self.space_name_id.as_ref().is_some_and(|sni| sni.room_id() == space_id) {
+            self.is_loading = false;
+            // Auto-expand the top-level space (we don't show it, just its children)
+            self.expanded_spaces.insert(space_id.clone());
+        }
+
+        self.rebuild_tree_entries();
+        self.redraw(cx);
+    }
+
+    /// Toggle the expansion state of a space.
+    fn toggle_space_expansion(&mut self, cx: &mut Cx, space_id: &OwnedRoomId) {
+        if self.expanded_spaces.contains(space_id) {
+            self.expanded_spaces.remove(space_id);
+            self.loading_subspaces.remove(space_id);
+        } else {
+            self.expanded_spaces.insert(space_id.clone());
+
+            // Request children if we don't have them yet
+            if !self.children_cache.contains_key(space_id) {
+                self.loading_subspaces.insert(space_id.clone());
+                if let Some(sender) = &self.space_request_sender {
+                    let parent_chain = cx.get_global::<RoomsListRef>()
+                        .get_space_parent_chain(space_id)
+                        .unwrap_or_default();
+                    let _ = sender.send(SpaceRequest::GetDetailedChildren {
+                        space_id: space_id.clone(),
+                        parent_chain,
+                    });
+                }
+            }
+        }
+
+        self.rebuild_tree_entries();
+        self.redraw(cx);
+    }
+
+    /// Rebuild the flattened tree entries based on the current expansion state.
+    fn rebuild_tree_entries(&mut self) {
+        let Some(space_name_id) = &self.space_name_id else { return };
+        let root_space_id = space_name_id.room_id().clone();
+        // Build tree starting from root
+        let mut new_tree_entries = Vec::new();
+        Self::build_tree_for_space(
+            &self.children_cache,
+            &self.expanded_spaces,
+            &self.loading_subspaces,
+            &mut new_tree_entries,
+            &root_space_id,
+            0,
+            0,
+        );
+        self.tree_entries = new_tree_entries;
+    }
+
+    /// Recursively build the tree of spaces and their expanded children such that they
+    /// can be displayed in the SpaceLobbyScreen's PortalList.
+    //
+    // Note: this is intentionally *not* a method (it doesn't take &mut self),
+    // in order to make it possible to recursively call it while immutably borrowing
+    // only select fields of `Self`.
+    fn build_tree_for_space(
+        children_cache: &HashMap<OwnedRoomId, Vector<SpaceRoom>>,
+        expanded_spaces: &HashSet<OwnedRoomId>,
+        loading_subspaces: &HashSet<OwnedRoomId>,
+        tree_entries: &mut Vec<TreeEntry>,
+        space_id: &OwnedRoomId,
+        level: usize,
+        parent_mask: u32,
+    ) {
+        let Some(children) = children_cache.get(space_id) else { return };
+
+        // Sort: spaces first, then rooms, both alphabetically
+        let mut sorted_children: Vec<_> = children.iter().collect();
+        sorted_children.sort_by(|a, b| {
+            match (a.is_space(), b.is_space()) {
+                (true, false) => std::cmp::Ordering::Less,
+                (false, true) => std::cmp::Ordering::Greater,
+                _ => a.display_name.to_lowercase().cmp(&b.display_name.to_lowercase()),
+            }
+        });
+
+        
+        let count = sorted_children.len();
+        for (i, child) in sorted_children.into_iter().enumerate() {
+            let is_last = i == count - 1;
+            
+            tree_entries.push(TreeEntry::Item {
+                info: SpaceRoomInfo::from(child),
+                level,
+                is_last,
+                parent_mask,
+            });
+
+            // If this is an expanded space, recursively add its children or a loading indicator
+            if child.is_space() && expanded_spaces.contains(&child.room_id) {
+                // Calculate mask for children:
+                // If we are NOT the last child, our level needs a continuation line for our children.
+                // If we ARE the last child, our level does NOT need a line.
+                // Parent levels are preserved.
+                let child_mask = if is_last {
+                    parent_mask
+                } else {
+                    parent_mask | (1 << level)
+                };
+
+                if children_cache.contains_key(&child.room_id) {
+                    Self::build_tree_for_space(
+                        children_cache,
+                        expanded_spaces,
+                        loading_subspaces,
+                        tree_entries,
+                        &child.room_id,
+                        level + 1,
+                        child_mask,
+                    );
+                } else if loading_subspaces.contains(&child.room_id) {
+                    // Show loading indicator
+                    tree_entries.push(TreeEntry::Loading { 
+                        level: level + 1,
+                        parent_mask: child_mask,
+                    });
+                }
+            }
+        }
+    }
+
+    pub fn set_displayed_space(&mut self, cx: &mut Cx, space_name_id: &RoomNameId) {
+        let space_name = space_name_id.to_string();
+        let parent_name = self.view.label(ids!(header.parent_space_row.parent_name));
+        parent_name.set_text(cx, &space_name);
+
+        // If this space is already being displayed, then the only thing we may need to do
+        // is update its name in the top-level header (already done above).
+        if self.space_name_id.as_ref().is_some_and(|sni| sni.room_id() == space_name_id.room_id()) {
+            return;
+        }
 
         self.space_name_id = Some(space_name_id.clone());
+        let rooms_list_ref = cx.get_global::<RoomsListRef>();
+        if let Some(sender) = rooms_list_ref.get_space_request_sender() {
+            // Request detailed children for this space so we can start populating it.
+            let parent_chain_opt = rooms_list_ref.get_space_parent_chain(space_name_id.room_id());
+            let _ = sender.send(SpaceRequest::GetDetailedChildren {
+                space_id: space_name_id.room_id().clone(),
+                parent_chain: parent_chain_opt.unwrap_or_default(),
+            });
+            self.space_request_sender = Some(sender);
+        }
+
+        self.tree_entries.clear();
+        self.expanded_spaces.clear();
+        self.is_loading = true;
+
+        // Set parent avatar
+        let avatar_ref = self.view.avatar(ids!(header.parent_space_row.parent_avatar));
+        let first_char = utils::user_name_first_letter(&space_name);
+        avatar_ref.show_text(cx, None, None, first_char.unwrap_or("#"));
+        self.redraw(cx);
     }
 }
 
diff --git a/src/profile/user_profile.rs b/src/profile/user_profile.rs
index 3d985862..b2594b21 100644
--- a/src/profile/user_profile.rs
+++ b/src/profile/user_profile.rs
@@ -1,53 +1,13 @@
-use std::{borrow::Cow, ops::{Deref, DerefMut}, sync::Arc};
+//! Widgets and types related to displaying info about a user profile.
+
+use std::{borrow::Cow, ops::{Deref, DerefMut}};
 use makepad_widgets::*;
-use matrix_sdk::{room::{RoomMember, RoomMemberRole}, ruma::{events::room::member::MembershipState, OwnedMxcUri, OwnedRoomId, OwnedUserId}};
+use matrix_sdk::{room::{RoomMember, RoomMemberRole}, ruma::{events::room::member::MembershipState, OwnedRoomId, OwnedUserId}};
 use crate::{
-    avatar_cache::{self, AvatarCacheEntry}, shared::{avatar::AvatarWidgetExt, popup_list::{enqueue_popup_notification, PopupItem, PopupKind}}, sliding_sync::{current_user_id, is_user_ignored, submit_async_request, MatrixRequest}, utils
+    avatar_cache::{self, AvatarCacheEntry}, shared::{avatar::{AvatarState, AvatarWidgetExt}, popup_list::{PopupItem, PopupKind, enqueue_popup_notification}}, sliding_sync::{MatrixRequest, current_user_id, is_user_ignored, submit_async_request}, utils
 };
 use super::user_profile_cache;
 
-/// The currently-known state of a user's avatar.
-#[derive(Clone)]
-pub enum AvatarState {
-    /// It isn't yet known if this user has an avatar.
-    Unknown,
-    /// It is known that this user does or does not have an avatar.
-    Known(Option<OwnedMxcUri>),
-    /// This user does have an avatar, and it has been fetched successfully.
-    Loaded(Arc<[u8]>),
-    /// This user does have an avatar, but we failed to fetch it.
-    Failed,
-}
-impl std::fmt::Debug for AvatarState {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            AvatarState::Unknown        => write!(f, "Unknown"),
-            AvatarState::Known(Some(_)) => write!(f, "Known(Some)"),
-            AvatarState::Known(None)    => write!(f, "Known(None)"),
-            AvatarState::Loaded(data)   => write!(f, "Loaded({} bytes)", data.len()),
-            AvatarState::Failed         => write!(f, "Failed"),
-        }
-    }
-}
-impl AvatarState {
-    /// Returns the avatar data, if in the `Loaded` state.
-    pub fn data(&self) -> Option<&Arc<[u8]>> {
-        if let AvatarState::Loaded(data) = self {
-            Some(data)
-        } else {
-            None
-        }
-    }
-
-    /// Returns the avatar URI, if in the `Known` state and it exists.
-    pub fn uri(&self) -> Option<&OwnedMxcUri> {
-        if let AvatarState::Known(Some(uri)) = self {
-            Some(uri)
-        } else {
-            None
-        }
-    }
-}
 
 /// Information retrieved about a user: their displayable name, ID, and known avatar state.
 #[derive(Clone, Debug)]
diff --git a/src/profile/user_profile_cache.rs b/src/profile/user_profile_cache.rs
index df18651d..15de2012 100644
--- a/src/profile/user_profile_cache.rs
+++ b/src/profile/user_profile_cache.rs
@@ -7,7 +7,7 @@ use makepad_widgets::{warning, Cx, SignalToUI};
 use matrix_sdk::{room::RoomMember, ruma::{OwnedRoomId, OwnedUserId, UserId}};
 use std::{cell::RefCell, collections::{btree_map::Entry, BTreeMap}};
 
-use crate::{profile::user_profile::AvatarState, sliding_sync::{submit_async_request, MatrixRequest}};
+use crate::{shared::avatar::AvatarState, sliding_sync::{submit_async_request, MatrixRequest}};
 
 use super::user_profile::UserProfile;
 
diff --git a/src/shared/avatar.rs b/src/shared/avatar.rs
index b09b9437..0936c9b7 100644
--- a/src/shared/avatar.rs
+++ b/src/shared/avatar.rs
@@ -11,9 +11,10 @@ use std::sync::Arc;
 use makepad_widgets::*;
 use matrix_sdk::{ruma::{EventId, OwnedRoomId, OwnedUserId, RoomId, UserId}};
 use matrix_sdk_ui::timeline::{Profile, TimelineDetails};
+use ruma::OwnedMxcUri;
 
 use crate::{
-    avatar_cache::{self, AvatarCacheEntry}, profile::{user_profile::{AvatarState, ShowUserProfileAction, UserProfile, UserProfileAndRoomId}, user_profile_cache}, sliding_sync::{submit_async_request, MatrixRequest}, utils
+    avatar_cache::{self, AvatarCacheEntry}, profile::{user_profile::{ShowUserProfileAction, UserProfile, UserProfileAndRoomId}, user_profile_cache}, sliding_sync::{submit_async_request, MatrixRequest}, utils
 };
 
 live_design! {
@@ -450,3 +451,47 @@ impl From<(OwnedUserId, Option<String>, OwnedRoomId, Arc<[u8]>)> for AvatarImage
         Self { user_id, username, room_id, img_data }
     }
 }
+
+
+/// The currently-known state of an avatar for a user, room, or space.
+#[derive(Clone)]
+pub enum AvatarState {
+    /// It isn't yet known if this user/room/space has an avatar.
+    Unknown,
+    /// It is known that this user/room/space does or does not have an avatar.
+    Known(Option<OwnedMxcUri>),
+    /// The avatar is known to exist and has been fetched successfully.
+    Loaded(Arc<[u8]>),
+    /// The avatar is known to exist but could not be fetched.
+    Failed,
+}
+impl std::fmt::Debug for AvatarState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AvatarState::Unknown        => write!(f, "Unknown"),
+            AvatarState::Known(Some(_)) => write!(f, "Known(Some)"),
+            AvatarState::Known(None)    => write!(f, "Known(None)"),
+            AvatarState::Loaded(data)   => write!(f, "Loaded({} bytes)", data.len()),
+            AvatarState::Failed         => write!(f, "Failed"),
+        }
+    }
+}
+impl AvatarState {
+    /// Returns the avatar data, if in the `Loaded` state.
+    pub fn data(&self) -> Option<&Arc<[u8]>> {
+        if let AvatarState::Loaded(data) = self {
+            Some(data)
+        } else {
+            None
+        }
+    }
+
+    /// Returns the avatar URI, if in the `Known` state and it exists.
+    pub fn uri(&self) -> Option<&OwnedMxcUri> {
+        if let AvatarState::Known(Some(uri)) = self {
+            Some(uri)
+        } else {
+            None
+        }
+    }
+}
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 4e29baa5..a49b0929 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -32,12 +32,10 @@ use crate::{
     app::AppStateAction, app_data_dir, avatar_cache::AvatarUpdate, event_preview::text_preview_of_timeline_item, home::{
         add_room::KnockResultAction, invite_screen::{JoinRoomResultAction, LeaveRoomResultAction}, link_preview::{LinkPreviewData, LinkPreviewDataNonNumeric, LinkPreviewRateLimitResponse}, room_screen::TimelineUpdate, rooms_list::{self, InvitedRoomInfo, InviterInfo, JoinedRoomInfo, RoomsListUpdate, enqueue_rooms_list_update}, rooms_list_header::RoomsListHeaderAction, tombstone_footer::SuccessorRoomDetails
     }, login::login_screen::LoginAction, logout::{logout_confirm_modal::LogoutAction, logout_state_machine::{LogoutConfig, is_logout_in_progress, logout_with_state_machine}}, media_cache::{MediaCacheEntry, MediaCacheEntryRef}, persistence::{self, ClientSessionPersisted, load_app_state}, profile::{
-        user_profile::{AvatarState, UserProfile},
+        user_profile::UserProfile,
         user_profile_cache::{UserProfileUpdate, enqueue_user_profile_update},
     }, room::{FetchedRoomAvatar, FetchedRoomPreview, RoomPreviewAction}, shared::{
-        html_or_plaintext::MatrixLinkPillState,
-        jump_to_bottom_button::UnreadMessageCount,
-        popup_list::{PopupItem, PopupKind, enqueue_popup_notification}
+        avatar::AvatarState, html_or_plaintext::MatrixLinkPillState, jump_to_bottom_button::UnreadMessageCount, popup_list::{PopupItem, PopupKind, enqueue_popup_notification}
     }, space_service_sync::space_service_loop, utils::{self, AVATAR_THUMBNAIL_FORMAT, RoomNameId, avatar_from_room_name}, verification::add_verification_event_handlers_and_sync_client
 };
 
diff --git a/src/space_service_sync.rs b/src/space_service_sync.rs
index 8833c773..35c95ab7 100644
--- a/src/space_service_sync.rs
+++ b/src/space_service_sync.rs
@@ -38,21 +38,39 @@ pub enum SpaceRequest {
         space_id: OwnedRoomId,
     },
     /// Paginate the given space's room list, i.e., fetch the next batch of rooms in the list.
+    ///
+    /// This will result in a [`SpaceRoomListAction::PaginationState`] action being emitted,
+    /// or a [`SpaceRoomListAction::PaginationError`] action being emitted if it failed.
     PaginateSpaceRoomList {
         space_id: OwnedRoomId,
         parent_chain: ParentChain,
     },
-    /// Get a copy of the currently-known children (rooms and spaces) in the given space.
+    /// Get a minimal copy of the currently-known children (rooms and subspaces) in the given space.
+    ///
+    /// This is intended for cases when you only need an overview of the basic hierarchy of spaces.
+    /// This will result in a [`SpaceRoomListAction::UpdatedChildren`] action being emitted.
     GetChildren {
         space_id: OwnedRoomId,
         parent_chain: ParentChain,
-    }
+    },
+    /// Get fully-detailed info about all children (rooms and subspaces) in this space.
+    ///
+    /// This is intended for cases when you need all info about subspaces and child rooms.
+    /// This will result in a [`SpaceRoomListAction::DetailedChildren`] action being emitted.
+    GetDetailedChildren {
+        space_id: OwnedRoomId,
+        parent_chain: ParentChain,
+    },
 }
 
 /// Internal requests sent from the [`space_service_loop`] to a specific space's [`space_room_list_loop`].
 enum SpaceRoomListRequest {
-    /// Get a copy of the currently-known chil.ren (rooms & spaces) in this space.
+    /// Get a copy of the currently-known children (rooms & spaces) in this space.
+    /// This is intended for cases when you only need an overview of the basic hierarchy of spaces.
     GetChildren,
+    /// Get fully-detailed info about all children in this space.
+    /// This is intended for cases when you need all info about subspaces and child rooms.
+    GetDetailedChildren,
     /// Paginate this space to get info about more of its children.
     Paginate,
     Shutdown,
@@ -133,6 +151,12 @@ pub async fn space_service_loop(client: Client) -> anyhow::Result<()> {
                         let _ = join_handle.await;
                     }
                 }
+                SpaceRequest::GetDetailedChildren { space_id, parent_chain } => {
+                    let sender = get_or_spawn_space_room_list(&mut space_room_list_tasks, &space_id, &parent_chain).await;
+                    if sender.send(SpaceRoomListRequest::GetDetailedChildren).is_err() {
+                        error!("BUG: failed to send GetDetailedChildren request to space room list loop for space {space_id}");
+                    }
+                }
             }
         }
 
@@ -511,15 +535,22 @@ async fn fetch_space_avatar(url: OwnedMxcUri, client: &Client) -> matrix_sdk::Re
 }
 
 
-/// Returns true if the given `SpaceRoom` is a space itself;
-/// otherwise, returns false, indicating it is a regular room.
-#[inline]
-fn is_space(sr: &SpaceRoom) -> bool {
-    sr.children_count > 0
-    || matches!(sr.room_type, Some(RoomType::Space))
+
+/// Extension trait for `SpaceRoom` to provide utility methods.
+pub trait SpaceRoomExt {
+    /// Returns true if this `SpaceRoom` is a space itself;
+    /// otherwise, returns false, indicating it is a regular room.
+    fn is_space(&self) -> bool;
+}
+impl SpaceRoomExt for SpaceRoom {
+    #[inline]
+    fn is_space(&self) -> bool {
+        self.children_count > 0 || matches!(self.room_type, Some(RoomType::Space))
+    }
 }
 
 
+
 /// A loop that listens for changes to the set of rooms in a given space.
 async fn space_room_list_loop(
     space_id: OwnedRoomId,
@@ -567,6 +598,15 @@ async fn space_room_list_loop(
                         direct_subspaces: Arc::clone(&cached_hash_sets.1),
                     });
                 }
+                SpaceRoomListRequest::GetDetailedChildren => {
+                    Cx::post_action(SpaceRoomListAction::DetailedChildren {
+                        space_id: space_id.clone(),
+                        parent_chain: parent_chain.clone(),
+                        // The `imbl::Vector` type is very cheap to clone here
+                        // because we're not modifying it, so we just send that value directly.
+                        children: all_rooms_in_space.clone(),
+                    });
+                }
                 SpaceRoomListRequest::Paginate => {
                     paginate_once().await;
                 }
@@ -624,7 +664,7 @@ fn handle_subspaces<'a>(
     changed_space_rooms: impl Iterator<Item = &'a SpaceRoom>,
     request_sender: &UnboundedSender<SpaceRequest>,
 ) {
-    for sr in changed_space_rooms.filter(|&sr| is_space(sr)) {        
+    for sr in changed_space_rooms.filter(|&sr| sr.is_space()) {        
         if known_subspaces.contains(&sr.room_id) {
             continue;
         }
@@ -654,7 +694,7 @@ fn space_children_to_hash_sets(
     let mut direct_child_rooms = HashSet::new();
     let mut direct_subspaces = HashSet::new();
     for sr in all_rooms_in_space.iter() {
-        if is_space(sr) {
+        if sr.is_space() {
             direct_subspaces.insert(sr.room_id.clone());
         } else {
             direct_child_rooms.insert(sr.room_id.clone());
@@ -690,6 +730,14 @@ pub enum SpaceRoomListAction {
         space_id: OwnedRoomId,
         error: matrix_sdk::Error,
     },
+    /// Detailed information about all direct children in the given space.
+    ///
+    /// This is sent in response to a `SpaceRequest::GetDetailedChildren` request.
+    DetailedChildren {
+        space_id: OwnedRoomId,
+        parent_chain: ParentChain,
+        children: Vector<SpaceRoom>,
+    },
 }
 impl std::fmt::Debug for SpaceRoomListAction {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -715,6 +763,13 @@ impl std::fmt::Debug for SpaceRoomListAction {
                     .field("error", error)
                     .finish()
             }
+            SpaceRoomListAction::DetailedChildren { space_id, parent_chain, children } => {
+                f.debug_struct("SpaceRoomListAction::DetailedChildren")
+                    .field("space_id", space_id)
+                    .field("parent_chain", &parent_chain)
+                    .field("num_children", &children.len())
+                    .finish()
+            }
         }
     }
 }