diff --git a/src/app.rs b/src/app.rs
index 8737aa5a..d3ea88bd 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -4,7 +4,7 @@
 
 use std::{cell::RefCell, collections::HashMap};
 use makepad_widgets::*;
-use matrix_sdk::{RoomState, ruma::{OwnedRoomId, RoomId}};
+use matrix_sdk::{RoomState, ruma::{OwnedEventId, OwnedRoomId, RoomId}};
 use serde::{Deserialize, Serialize};
 use crate::{
     avatar_cache::clear_avatar_cache, home::{
@@ -374,18 +374,14 @@ impl MatchEvent for App {
                 continue;
             }
 
+            // A new room has been selected, update the app state and navigate to the main content view.
             if let RoomsListAction::Selected(selected_room) = action.as_widget_action().cast() {
-                // A room has been selected, update the app state and navigate to the main content view.
-                let display_name = match &selected_room {
-                    SelectedRoom::JoinedRoom { room_name_id } => room_name_id.to_string(),
-                    SelectedRoom::InvitedRoom { room_name_id } => room_name_id.to_string(),
-                    SelectedRoom::Space { space_name_id } => format!("[Space] {}", space_name_id),
-                };
-                self.app_state.selected_room = Some(selected_room);
                 // Set the Stack Navigation header to show the name of the newly-selected room.
                 self.ui
                     .label(ids!(main_content_view.header.content.title_container.title))
-                    .set_text(cx, &display_name);
+                    .set_text(cx, &selected_room.display_name());
+
+                self.app_state.selected_room = Some(selected_room);
 
                 // Navigate to the main content view
                 cx.widget_action(
@@ -852,12 +848,29 @@ pub struct SavedDockState {
 
 /// Represents a room currently or previously selected by the user.
 ///
-/// One `SelectedRoom` is considered equal to another if their `room_id`s are equal.
+/// ## PartialEq/Eq equality comparison behavior
+/// Room/Space names are ignored for the purpose of equality comparison.
+/// Two `SelectedRoom`s are considered equal if their `room_id`s are equal,
+/// unless they are `Thread`s,` in which case their `thread_root_event_id`s
+/// are also compared for equality.
+/// A `Thread` is never considered equal to a non-`Thread`, even if their `room_id`s are equal.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum SelectedRoom {
-    JoinedRoom { room_name_id: RoomNameId },
-    InvitedRoom { room_name_id: RoomNameId },
-    Space { space_name_id: RoomNameId },
+    JoinedRoom {
+        room_name_id: RoomNameId,
+    },
+    Thread {
+        room_name_id: RoomNameId,
+        /// The event ID of the root message of this thread,
+        /// which is used to distinguish this thread from the main room timeline.
+        thread_root_event_id: OwnedEventId,
+    },
+    InvitedRoom {
+        room_name_id: RoomNameId,
+    },
+    Space {
+        space_name_id: RoomNameId,
+    },
 }
 
 impl SelectedRoom {
@@ -866,6 +879,7 @@ impl SelectedRoom {
             SelectedRoom::JoinedRoom { room_name_id } => room_name_id.room_id(),
             SelectedRoom::InvitedRoom { room_name_id } => room_name_id.room_id(),
             SelectedRoom::Space { space_name_id } => space_name_id.room_id(),
+            SelectedRoom::Thread { room_name_id, .. } => room_name_id.room_id(),
         }
     }
 
@@ -874,6 +888,7 @@ impl SelectedRoom {
             SelectedRoom::JoinedRoom { room_name_id } => room_name_id,
             SelectedRoom::InvitedRoom { room_name_id } => room_name_id,
             SelectedRoom::Space { space_name_id } => space_name_id,
+            SelectedRoom::Thread { room_name_id, .. } => room_name_id,
         }
     }
 
@@ -895,10 +910,49 @@ impl SelectedRoom {
             _ => false,
         }
     }
+
+    /// Returns the `LiveId` of the room tab corresponding to this `SelectedRoom`.
+    pub fn tab_id(&self) -> LiveId {
+        match self {
+            SelectedRoom::Thread { room_name_id, thread_root_event_id } => {
+                LiveId::from_str(
+                    &format!("{}##{}", room_name_id.room_id(), thread_root_event_id)
+                )
+            }
+            other => LiveId::from_str(other.room_id().as_str()),
+        }
+    }
+
+    /// Returns the display name to be shown for this room in the UI.
+    pub fn display_name(&self) -> String {
+        match self {
+            SelectedRoom::JoinedRoom { room_name_id } => room_name_id.to_string(),
+            SelectedRoom::InvitedRoom { room_name_id } => room_name_id.to_string(),
+            SelectedRoom::Space { space_name_id } => format!("[Space] {space_name_id}"),
+            SelectedRoom::Thread { room_name_id, .. } => format!("[Thread] {room_name_id}"),
+        }
+    }
 }
+
 impl PartialEq for SelectedRoom {
     fn eq(&self, other: &Self) -> bool {
-        self.room_id() == other.room_id()
+        match (self, other) {
+            (
+                SelectedRoom::Thread {
+                    room_name_id: lhs_room_name_id,
+                    thread_root_event_id: lhs_thread_root_event_id,
+                },
+                SelectedRoom::Thread {
+                    room_name_id: rhs_room_name_id,
+                    thread_root_event_id: rhs_thread_root_event_id,
+                },
+            ) => {
+                lhs_room_name_id.room_id() == rhs_room_name_id.room_id()
+                    && lhs_thread_root_event_id == rhs_thread_root_event_id
+            }
+            (SelectedRoom::Thread { .. }, _) | (_, SelectedRoom::Thread { .. }) => false,
+            _ => self.room_id() == other.room_id(),
+        }
     }
 }
 impl Eq for SelectedRoom {}
diff --git a/src/event_preview.rs b/src/event_preview.rs
index 75b9b0be..d4e0cde2 100644
--- a/src/event_preview.rs
+++ b/src/event_preview.rs
@@ -7,7 +7,7 @@
 
 use std::borrow::Cow;
 
-use matrix_sdk::{ruma::{events::{room::{guest_access::GuestAccess, history_visibility::HistoryVisibility, join_rules::JoinRule, message::{MessageFormat, MessageType}}, AnySyncMessageLikeEvent, AnySyncTimelineEvent, FullStateEventContent, SyncMessageLikeEvent}, serde::Raw, UserId}};
+use matrix_sdk::{ruma::{OwnedUserId, events::{room::{guest_access::GuestAccess, history_visibility::HistoryVisibility, join_rules::JoinRule, message::{MessageFormat, MessageType}}, AnySyncMessageLikeEvent, AnySyncTimelineEvent, FullStateEventContent, SyncMessageLikeEvent}, serde::Raw, UserId}};
 use matrix_sdk_base::crypto::types::events::UtdCause;
 use matrix_sdk_ui::timeline::{self, AnyOtherFullStateEventContent, EncryptedMessage, EventTimelineItem, MemberProfileChange, MembershipChange, MsgLikeKind, OtherMessageLike, RoomMembershipChange, TimelineItemContent};
 
@@ -69,7 +69,7 @@ pub fn text_preview_of_timeline_item(
     match content {
         TimelineItemContent::MsgLike(msg_like_content) => {
             match &msg_like_content.kind {
-                MsgLikeKind::Message(msg) => text_preview_of_message(msg, sender_username),
+                MsgLikeKind::Message(msg) => text_preview_of_message(msg.msgtype(), sender_username),
                 MsgLikeKind::Sticker(sticker) => TextPreview::from((
                     format!("[Sticker]: <i>{}</i>", htmlize::escape_text(&sticker.content().body)),
                     BeforeText::UsernameWithColon,
@@ -206,11 +206,11 @@ pub fn plaintext_body_of_timeline_item(
 
 
 /// Returns a text preview of the given message as an Html-formatted string.
-pub fn text_preview_of_message(
-    message: &timeline::Message,
+fn text_preview_of_message(
+    msg: &MessageType,
     sender_username: &str,
 ) -> TextPreview {
-    let text = match message.msgtype() {
+    let text = match msg {
         MessageType::Audio(audio) => format!(
             "[Audio]: <i>{}</i>",
             if let Some(formatted_body) = audio.formatted.as_ref() {
@@ -300,6 +300,36 @@ pub fn text_preview_of_message(
     TextPreview::from((text, BeforeText::UsernameWithColon))
 }
 
+/// Returns a preview of the given raw timeline event.
+pub fn text_preview_of_raw_timeline_event(
+    raw_event: &Raw<AnySyncTimelineEvent>,
+    sender_username: &str,
+) -> Option<TextPreview> {
+    match raw_event.deserialize().ok()? {
+        AnySyncTimelineEvent::MessageLike(
+            AnySyncMessageLikeEvent::RoomMessage(
+                SyncMessageLikeEvent::Original(ev)
+            )
+        ) => Some(text_preview_of_message(
+            &ev.content.msgtype,
+            sender_username,
+        )),
+        AnySyncTimelineEvent::MessageLike(
+            AnySyncMessageLikeEvent::RoomMessage(
+                SyncMessageLikeEvent::Redacted(_)
+            )
+        ) => {
+            let sender_user_id = raw_event.get_field::<OwnedUserId>("sender").ok().flatten()?;
+            Some(text_preview_of_redacted_message(
+                Some(raw_event),
+                sender_user_id.as_ref(),
+                sender_username,
+            ))
+        }
+        _ => None,
+    }
+}
+
 
 /// Returns a plaintext preview of the given redacted message.
 ///
diff --git a/src/home/editing_pane.rs b/src/home/editing_pane.rs
index 42005192..842682ad 100644
--- a/src/home/editing_pane.rs
+++ b/src/home/editing_pane.rs
@@ -2,7 +2,6 @@ use makepad_widgets::{text::selection::Cursor, *};
 use matrix_sdk::{
     room::edit::EditedContent,
     ruma::{
-        OwnedRoomId,
         events::{
             poll::unstable_start::{UnstablePollAnswer, UnstablePollStartContentBlock},
             room::message::{FormattedBody, MessageType, RoomMessageEventContentWithoutRelation},
@@ -13,7 +12,8 @@ use matrix_sdk_ui::timeline::{EventTimelineItem, MsgLikeKind, TimelineEventItemI
 
 use crate::shared::mentionable_text_input::MentionableTextInputWidgetExt;
 use crate::{
-    shared::popup_list::{enqueue_popup_notification, PopupKind}, sliding_sync::{submit_async_request, MatrixRequest}
+    shared::popup_list::{enqueue_popup_notification, PopupKind},
+    sliding_sync::{submit_async_request, MatrixRequest, TimelineKind},
 };
 
 live_design! {
@@ -150,7 +150,7 @@ pub enum EditingPaneAction {
 /// The information maintained by the EditingPane widget.
 struct EditingPaneInfo {
     event_tl_item: EventTimelineItem,
-    room_id: OwnedRoomId,
+    timeline_kind: TimelineKind,
 }
 
 /// A view that slides in from the bottom of the screen to allow editing a message.
@@ -369,7 +369,7 @@ impl Widget for EditingPane {
                 };
 
                 submit_async_request(MatrixRequest::EditMessage {
-                    room_id: info.room_id.clone(),
+                    timeline_kind: info.timeline_kind.clone(),
                     timeline_event_item_id: info.event_tl_item.identifier(),
                     edited_content,
                 });
@@ -426,7 +426,12 @@ impl EditingPane {
     }
 
     /// Shows the editing pane and sets it up to edit the given `event`'s content.
-    pub fn show(&mut self, cx: &mut Cx, event_tl_item: EventTimelineItem, room_id: OwnedRoomId) {
+    pub fn show(
+        &mut self,
+        cx: &mut Cx,
+        event_tl_item: EventTimelineItem,
+        timeline_kind: TimelineKind,
+    ) {
         if !event_tl_item.is_editable() {
             enqueue_popup_notification(
                 "That message cannot be edited.",
@@ -452,7 +457,10 @@ impl EditingPane {
         }
 
 
-        self.info = Some(EditingPaneInfo { event_tl_item, room_id: room_id.clone() });
+        self.info = Some(EditingPaneInfo {
+            event_tl_item,
+            timeline_kind,
+        });
 
         self.visible = true;
         self.button(ids!(accept_button)).reset_hover(cx);
@@ -487,13 +495,16 @@ impl EditingPane {
         &mut self,
         cx: &mut Cx,
         editing_pane_state: EditingPaneState,
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
     ) {
         let EditingPaneState { event_tl_item, text_input_state } = editing_pane_state;
         self.mentionable_text_input(ids!(editing_content.edit_text_input))
             .text_input_ref()
             .restore_state(cx, text_input_state);
-        self.info = Some(EditingPaneInfo { event_tl_item, room_id: room_id.clone() });
+        self.info = Some(EditingPaneInfo {
+            event_tl_item,
+            timeline_kind,
+        });
         self.visible = true;
         self.button(ids!(accept_button)).reset_hover(cx);
         self.button(ids!(cancel_button)).reset_hover(cx);
@@ -537,11 +548,16 @@ impl EditingPaneRef {
     }
 
     /// See [`EditingPane::show()`].
-    pub fn show(&self, cx: &mut Cx, event_tl_item: EventTimelineItem, room_id: OwnedRoomId) {
+    pub fn show(
+        &self,
+        cx: &mut Cx,
+        event_tl_item: EventTimelineItem,
+        timeline_kind: TimelineKind,
+    ) {
         let Some(mut inner) = self.borrow_mut() else {
             return;
         };
-        inner.show(cx, event_tl_item, room_id);
+        inner.show(cx, event_tl_item, timeline_kind);
     }
 
     /// See [`EditingPane::save_state()`].
@@ -556,10 +572,10 @@ impl EditingPaneRef {
         &self,
         cx: &mut Cx,
         editing_pane_state: EditingPaneState,
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
     ) {
         let Some(mut inner) = self.borrow_mut() else { return };
-        inner.restore_state(cx, editing_pane_state, room_id);
+        inner.restore_state(cx, editing_pane_state, timeline_kind);
     }
 
     /// Hides the editing pane immediately and clears its state without animating it out.
diff --git a/src/home/event_reaction_list.rs b/src/home/event_reaction_list.rs
index cf1656f4..94cd3741 100644
--- a/src/home/event_reaction_list.rs
+++ b/src/home/event_reaction_list.rs
@@ -1,6 +1,6 @@
 use crate::home::room_screen::RoomScreenTooltipActions;
 use crate::profile::user_profile_cache;
-use crate::sliding_sync::{current_user_id, submit_async_request, MatrixRequest};
+use crate::sliding_sync::{current_user_id, submit_async_request, MatrixRequest, TimelineKind};
 use indexmap::IndexMap;
 use makepad_widgets::*;
 use matrix_sdk::ruma::{OwnedRoomId, OwnedUserId};
@@ -114,21 +114,14 @@ pub struct ReactionData {
 
 #[derive(Live, LiveHook, Widget)]
 pub struct ReactionList {
-    #[redraw]
-    #[rust]
-    area: Area,
-    #[live]
-    item: Option<LivePtr>,
-    #[rust]
-    children: Vec<(ButtonRef, ReactionData)>,
-    #[layout]
-    layout: Layout,
-    #[walk]
-    walk: Walk,
-    #[rust]
-    room_id: Option<OwnedRoomId>,
-    #[rust]
-    timeline_event_id: Option<TimelineEventItemId>,
+    #[redraw] #[rust] area: Area,
+    #[live] item: Option<LivePtr>,
+    #[rust] children: Vec<(ButtonRef, ReactionData)>,
+    #[layout] layout: Layout,
+    #[walk] walk: Walk,
+
+    #[rust] timeline_kind: Option<TimelineKind>,
+    #[rust] timeline_event_id: Option<TimelineEventItemId>,
 }
 impl Widget for ReactionList {
     fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
@@ -170,12 +163,12 @@ impl Widget for ReactionList {
                     }
                     // Otherwise, a primary click/press over the button should toggle the reaction.
                     else if fue.is_primary_hit() && fue.was_tap() {
-                        let Some(room_id) = &self.room_id else { return };
+                        let Some(kind) = &self.timeline_kind else { return };
                         let Some(timeline_event_id) = &self.timeline_event_id else {
                             return;
                         };
                         submit_async_request(MatrixRequest::ToggleReaction {
-                            room_id: room_id.clone(),
+                            timeline_kind: kind.clone(),
                             timeline_event_id: timeline_event_id.clone(),
                             reaction: reaction_data.reaction.clone(),
                         });
@@ -254,7 +247,7 @@ impl ReactionListRef {
         &mut self,
         cx: &mut Cx,
         event_tl_item_reactions: Option<&ReactionsByKeyBySender>,
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
         timeline_event_item_id: TimelineEventItemId,
         _id: usize,
     ) {
@@ -279,24 +272,25 @@ impl ReactionListRef {
                     includes_user = true;
                 }
                 // Prefill each reactor's user profile into the cache so the tooltip will show their display name.
-                let _ = user_profile_cache::with_user_profile(cx, sender.clone(), Some(&room_id), true, |_, _| { });
+                let _ = user_profile_cache::with_user_profile(
+                    cx,
+                    sender.clone(),
+                    Some(timeline_kind.room_id()),
+                    true, |_, _| { },
+                );
             }
 
             let reaction_data = ReactionData {
                 reaction: reaction_text.to_string(),
                 includes_user,
                 reaction_senders: reaction_senders.clone(),
-                room_id: room_id.clone(),
+                room_id: timeline_kind.room_id().clone(),
             };
             let button = WidgetRef::new_from_ptr(cx, inner.item).as_button();
-            button.set_text(
-                cx,
-                &format!(
-                    "{}  {}",
-                    reaction_data.reaction,
-                    reaction_senders.len()
-                ),
-            );
+            button.set_text(cx, &format!("{}  {}",
+                reaction_data.reaction,
+                reaction_senders.len()
+            ));
             let (bg_color, border_color) = if reaction_data.includes_user {
                 (EMOJI_BG_COLOR_INCLUDE_SELF, EMOJI_BORDER_COLOR_INCLUDE_SELF)
             } else {
@@ -313,7 +307,7 @@ impl ReactionListRef {
             );
             inner.children.push((button, reaction_data));
         }
-        inner.room_id = Some(room_id);
+        inner.timeline_kind = Some(timeline_kind);
         inner.timeline_event_id = Some(timeline_event_item_id);
     }
 
diff --git a/src/home/main_desktop_ui.rs b/src/home/main_desktop_ui.rs
index 3b331da6..7a88771e 100644
--- a/src/home/main_desktop_ui.rs
+++ b/src/home/main_desktop_ui.rs
@@ -137,51 +137,40 @@ impl MainDesktopUI {
     /// Focuses on a room if it is already open, otherwise creates a new tab for the room.
     fn focus_or_create_tab(&mut self, cx: &mut Cx, room: SelectedRoom) {
         // Do nothing if the room to select is already created and focused.
-        if self.most_recently_selected_room.as_ref().is_some_and(|r| r == &room) {
+        if self.most_recently_selected_room.as_ref().is_some_and(|sr| sr == &room) {
             return;
         }
 
         let dock = self.view.dock(ids!(dock));
 
         // If the room is already open, select (jump to) its existing tab
-        let room_id_as_live_id = LiveId::from_str(room.room_id().as_str());
-        if self.open_rooms.contains_key(&room_id_as_live_id) {
-            dock.select_tab(cx, room_id_as_live_id);
+        let room_tab_id = room.tab_id();
+        if self.open_rooms.contains_key(&room_tab_id) {
+            dock.select_tab(cx, room_tab_id);
             self.most_recently_selected_room = Some(room);
             return;
         }
 
         // Create a new tab for the room
-        let (kind, name) = match &room {
-            SelectedRoom::JoinedRoom { room_name_id }  => (
-                id!(room_screen),
-                room_name_id.to_string(),
-            ),
-            SelectedRoom::InvitedRoom { room_name_id } => (
-                id!(invite_screen),
-                room_name_id.to_string(),
-            ),
-            SelectedRoom::Space { space_name_id } => (
-                id!(space_lobby_screen),
-                format!("[Space] {}", space_name_id),
-            ),
+        let kind = match &room {
+            SelectedRoom::JoinedRoom { .. }
+            | SelectedRoom::Thread { .. } => id!(room_screen),
+            SelectedRoom::InvitedRoom { .. } => id!(invite_screen),
+            SelectedRoom::Space { .. } => id!(space_lobby_screen),
         };
 
         // Insert the tab after the currently-selected room's tab, if possible.
         // Otherwise, insert it after the home tab, which should always exist.
         let (tab_bar, insert_after) = self.most_recently_selected_room.as_ref()
-            .and_then(|curr_room| {
-                let curr_room_id = LiveId::from_str(curr_room.room_id().as_str());
-                dock.find_tab_bar_of_tab(curr_room_id)
-            })
+            .and_then(|curr_room| dock.find_tab_bar_of_tab(curr_room.tab_id()))
             .unwrap_or_else(|| dock.find_tab_bar_of_tab(id!(home_tab)).unwrap());
 
         let new_tab_widget = dock.create_and_select_tab(
             cx,
             tab_bar,
-            room_id_as_live_id,
+            room_tab_id,
             kind,
-            name,
+            room.display_name(),
             id!(CloseableTab),
             Some(insert_after),
         );
@@ -194,6 +183,14 @@ impl MainDesktopUI {
                     new_widget.as_room_screen().set_displayed_room(
                         cx,
                         room_name_id,
+                        None,
+                    );
+                }
+                SelectedRoom::Thread { room_name_id, thread_root_event_id } => {
+                    new_widget.as_room_screen().set_displayed_room(
+                        cx,
+                        room_name_id,
+                        Some(thread_root_event_id.clone()),
                     );
                 }
                 SelectedRoom::InvitedRoom { room_name_id } => {
@@ -214,7 +211,7 @@ impl MainDesktopUI {
             error!("BUG: failed to create tab for {room:?}");
         }
 
-        self.open_rooms.insert(room_id_as_live_id, room.clone());
+        self.open_rooms.insert(room_tab_id, room.clone());
         self.most_recently_selected_room = Some(room);
     }
 
@@ -291,7 +288,7 @@ impl MainDesktopUI {
         // Set the info to be displayed in the newly-replaced RoomScreen..
         new_widget
             .as_room_screen()
-            .set_displayed_room(cx, room_name_id);
+            .set_displayed_room(cx, room_name_id, None);
 
         // Go through all existing `SelectedRoom` instances and replace the
         // `SelectedRoom::InvitedRoom`s with `SelectedRoom::JoinedRoom`s.
@@ -365,6 +362,7 @@ impl MainDesktopUI {
                             widget.as_room_screen().set_displayed_room(
                                 cx,
                                 room_name_id,
+                                None,
                             );
                         }
                         Some(SelectedRoom::InvitedRoom { room_name_id }) => {
@@ -379,6 +377,13 @@ impl MainDesktopUI {
                                 space_name_id,
                             );
                         }
+                        Some(SelectedRoom::Thread { room_name_id, thread_root_event_id }) => {
+                            widget.as_room_screen().set_displayed_room(
+                                cx,
+                                room_name_id,
+                                Some(thread_root_event_id.clone()),
+                            );
+                        }
                         None => { }
                     }
                 }
diff --git a/src/home/main_mobile_ui.rs b/src/home/main_mobile_ui.rs
index 3709f1ff..dec5b3d3 100644
--- a/src/home/main_mobile_ui.rs
+++ b/src/home/main_mobile_ui.rs
@@ -89,7 +89,7 @@ impl Widget for MainMobileUI {
                 // Get a reference to the `RoomScreen` widget and tell it which room's data to show.
                 self.view
                     .room_screen(ids!(room_screen))
-                    .set_displayed_room(cx, room_name_id);
+                    .set_displayed_room(cx, room_name_id, None);
             }
             Some(SelectedRoom::InvitedRoom { room_name_id }) => {
                 show_welcome = false;
@@ -109,6 +109,15 @@ impl Widget for MainMobileUI {
                     .space_lobby_screen(ids!(space_lobby_screen))
                     .set_displayed_space(cx, space_name_id);
             }
+            Some(SelectedRoom::Thread { room_name_id, thread_root_event_id }) => {
+                show_welcome = false;
+                show_room = true;
+                show_invite = false;
+                show_space_lobby = false;
+                self.view
+                    .room_screen(ids!(room_screen))
+                    .set_displayed_room(cx, room_name_id, Some(thread_root_event_id.clone()));
+            }
             None => {
                 show_welcome = true;
                 show_room = false;
diff --git a/src/home/new_message_context_menu.rs b/src/home/new_message_context_menu.rs
index 1efd2ddc..d78fbc26 100644
--- a/src/home/new_message_context_menu.rs
+++ b/src/home/new_message_context_menu.rs
@@ -283,6 +283,9 @@ pub struct MessageDetails {
     /// The event ID of the message that this message is related to, if any,
     /// such as the replied-to message.
     pub related_event_id: Option<OwnedEventId>,
+    /// The event ID of the thread root if this message is part of a thread
+    /// (or if this message is itself the thread root).
+    pub thread_root_event_id: Option<OwnedEventId>,
     /// The widget ID of the RoomScreen that contains this message.
     pub room_screen_widget_uid: WidgetUid,
     /// Whether this message should be highlighted, i.e.,
diff --git a/src/home/room_read_receipt.rs b/src/home/room_read_receipt.rs
index 3c7a2752..60fb7557 100644
--- a/src/home/room_read_receipt.rs
+++ b/src/home/room_read_receipt.rs
@@ -1,10 +1,11 @@
 use crate::home::room_screen::RoomScreenTooltipActions;
 use crate::profile::user_profile_cache::get_user_display_name_for_room;
 use crate::shared::avatar::{AvatarRef, AvatarWidgetRefExt};
+use crate::sliding_sync::TimelineKind;
 use crate::utils::human_readable_list;
 use indexmap::IndexMap;
 use makepad_widgets::*;
-use matrix_sdk::ruma::{events::receipt::Receipt, EventId, OwnedUserId, OwnedRoomId, RoomId};
+use matrix_sdk::ruma::{events::receipt::Receipt, EventId, OwnedUserId, OwnedRoomId};
 use matrix_sdk_ui::timeline::EventTimelineItem;
 
 use std::cmp;
@@ -159,7 +160,7 @@ impl AvatarRow {
     pub fn set_avatar_row(
         &mut self,
         cx: &mut Cx,
-        room_id: &RoomId,
+        timeline_kind: &TimelineKind,
         event_id: Option<&EventId>,
         receipts_map: &IndexMap<OwnedUserId, Receipt>,
     ) {
@@ -180,7 +181,7 @@ impl AvatarRow {
             if !*drawn {
                 let (_, drawn_status) = avatar_ref.set_avatar_and_get_username(
                     cx,
-                    room_id,
+                    timeline_kind,
                     user_id,
                     None,
                     event_id,
@@ -212,12 +213,12 @@ impl AvatarRowRef {
     pub fn set_avatar_row(
         &mut self,
         cx: &mut Cx,
-        room_id: &RoomId,
+        timeline_kind: &TimelineKind,
         event_id: Option<&EventId>,
         receipts_map: &IndexMap<OwnedUserId, Receipt>,
     ) {
         if let Some(ref mut inner) = self.borrow_mut() {
-            inner.set_avatar_row(cx, room_id, event_id, receipts_map);
+            inner.set_avatar_row(cx, timeline_kind, event_id, receipts_map);
         }
     }
 }
@@ -231,12 +232,12 @@ impl AvatarRowRef {
 pub fn populate_read_receipts(
     item: &WidgetRef,
     cx: &mut Cx,
-    room_id: &RoomId,
+    timeline_kind: &TimelineKind,
     event_tl_item: &EventTimelineItem,
 ) {
     item.avatar_row(ids!(avatar_row)).set_avatar_row(
         cx,
-        room_id,
+        timeline_kind,
         event_tl_item.event_id(),
         event_tl_item.read_receipts(),
     );
diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 75cb7a5a..08d88ab9 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -1,9 +1,10 @@
-//! A room screen is the UI view that displays a single Room's timeline of events/messages
-//! along with a message input bar at the bottom.
+//! The `RoomScreen` widget is the UI view that displays a single room or thread's timeline
+//! of events (messages，state changes, etc.), along with an input bar at the bottom.
 
-use std::{borrow::Cow, cell::RefCell, collections::BTreeMap, ops::{DerefMut, Range}, sync::Arc};
+use std::{borrow::Cow, cell::RefCell, ops::{DerefMut, Range}, sync::Arc};
 
 use bytesize::ByteSize;
+use hashbrown::{HashMap, HashSet};
 use imbl::Vector;
 use makepad_widgets::{image_cache::ImageBuffer, *};
 use matrix_sdk::{
@@ -22,10 +23,10 @@ use matrix_sdk::{
 use matrix_sdk_ui::timeline::{
     self, EmbeddedEvent, EncryptedMessage, EventTimelineItem, InReplyToDetails, MemberProfileChange, MembershipChange, MsgLikeContent, MsgLikeKind, OtherMessageLike, PollState, RoomMembershipChange, TimelineDetails, TimelineEventItemId, TimelineItem, TimelineItemContent, TimelineItemKind, VirtualTimelineItem
 };
-use ruma::{OwnedUserId, events::{AnySyncMessageLikeEvent, AnySyncTimelineEvent, SyncMessageLikeEvent}};
+use ruma::{OwnedUserId, api::client::receipt::create_receipt::v3::ReceiptType, events::{AnySyncMessageLikeEvent, AnySyncTimelineEvent, SyncMessageLikeEvent}, owned_room_id};
 
 use crate::{
-    app::{AppStateAction, ConfirmDeleteAction}, 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::{
+    app::{AppStateAction, ConfirmDeleteAction, SelectedRoom}, 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::{RoomsListAction, RoomsListRef}, tombstone_footer::SuccessorRoomDetails}, media_cache::{MediaCache, MediaCacheEntry}, profile::{
         user_profile::{ShowUserProfileAction, UserProfile, UserProfileAndRoomId, UserProfilePaneInfo, UserProfileSlidingPaneRef, UserProfileSlidingPaneWidgetExt},
         user_profile_cache,
     },
@@ -33,7 +34,7 @@ use crate::{
     shared::{
         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::{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}
+    sliding_sync::{BackwardsPaginateUntilEventRequest, MatrixRequest, PaginationDirection, TimelineEndpoints, TimelineKind, TimelineRequestSender, UserPowerLevels, get_client, submit_async_request, take_timeline_endpoints}, utils::{self, ImageFormat, MEDIA_THUMBNAIL_FORMAT, RoomNameId, unix_time_millis_to_datetime}
 };
 use crate::home::event_reaction_list::ReactionListWidgetRefExt;
 use crate::home::room_read_receipt::AvatarRowWidgetRefExt;
@@ -56,6 +57,12 @@ const BLURHASH_IMAGE_MAX_SIZE: u32 = 500;
 
 static UNNAMED_ROOM: &str = "Unnamed Room";
 
+/// #FFF4E5
+const COLOR_THREAD_SUMMARY_BG: Vec4 = vec4(1.0, 0.957, 0.898, 1.0);
+/// #FFEACC
+const COLOR_THREAD_SUMMARY_BG_HOVER: Vec4 = vec4(1.0, 0.918, 0.8, 1.0);
+
+
 live_design! {
     use link::theme::*;
     use link::shaders::*;
@@ -88,10 +95,58 @@ live_design! {
 
     REACTION_TEXT_COLOR = #4c00b0
 
+    COLOR_THREAD_SUMMARY_BG = #FFF4E5
+    COLOR_THREAD_SUMMARY_BG_HOVER = #FFEACC
+    COLOR_THREAD_SUMMARY_BORDER = #E8C99A
+    COLOR_THREAD_SUMMARY_REPLY_COUNT = #A35A00
 
     // An empty view that takes up no space in the portal list.
     Empty = <View> { }
 
+    // A summary at the bottom of a message that is the root of a thread.
+    ThreadRootSummary = <RoundedView> {
+        visible: false
+        width: Fill,
+        height: Fit
+        flow: Right,
+        align: {x: 0.0, y: 0.5}
+        spacing: 5.0
+        margin: { top: 5.0 }
+        padding: 12,
+        cursor: Hand
+
+        show_bg: true
+        draw_bg: {
+            color: (COLOR_THREAD_SUMMARY_BG)
+            border_radius: 4.0
+            border_size: 1.5
+            border_color: (COLOR_THREAD_SUMMARY_BORDER)
+        }
+
+        thread_summary_count = <Label> {
+            width: Fit,
+            draw_text: {
+                text_style: <USERNAME_TEXT_STYLE> { font_size: 11 }
+                color: (COLOR_THREAD_SUMMARY_REPLY_COUNT)
+            }
+            text: ""
+        }
+
+        <Icon> {
+            width: Fit, height: Fit,
+            align: {x: 0.5, y: 0.5}
+            draw_icon: {
+                svg_file: dep("crate://self/resources/icons/double_chat.svg")
+                color: (COLOR_THREAD_SUMMARY_REPLY_COUNT)
+            }
+            icon_walk: { width: 25, height: 25, margin: {top: 7, right: 7} }
+        }
+
+        thread_summary_latest = <MessageHtml> {
+            flow: Right,
+        }
+    }
+
     // The view used for each text-based message event in a room's timeline.
     Message = {{Message}} {
         width: Fill,
@@ -207,6 +262,7 @@ live_design! {
                 height: Fit
                 flow: Down,
                 padding: 0.0
+
                 username_view = <View> {
                     flow: Right,
                     width: Fill,
@@ -227,16 +283,14 @@ live_design! {
 
                 message = <HtmlOrPlaintext> { }
                 link_preview_view = <LinkPreview> {}
-
-                // <LineH> {
-                //     margin: {top: 13.0, bottom: 5.0}
-                // }
                 <View> {
                     width: Fill,
                     height: Fit
+                    flow: Right,
                     reaction_list = <ReactionList> { }
                     avatar_row = <AvatarRow> {}
                 }
+                thread_root_summary = <ThreadRootSummary> {}
             }
         }
     }
@@ -274,9 +328,11 @@ live_design! {
                 <View> {
                     width: Fill,
                     height: Fit
+                    flow: Right,
                     reaction_list = <ReactionList> { }
                     avatar_row = <AvatarRow> {}
                 }
+                thread_root_summary = <ThreadRootSummary> {}
             }
         }
     }
@@ -289,14 +345,16 @@ live_design! {
                 width: Fill,
                 height: Fit
                 padding: { left: 10.0 }
+
                 message = <TextOrImage> { }
-                v = <View> {
+                <View> {
                     width: Fill,
                     height: Fit,
                     flow: Right,
                     reaction_list = <ReactionList> { }
                     avatar_row = <AvatarRow> {}
                 }
+                thread_root_summary = <ThreadRootSummary> {}
             }
 
         }
@@ -311,12 +369,13 @@ live_design! {
                 message = <TextOrImage> { }
                 <View> {
                     width: Fill,
-                    height: Fit
+                    height: Fit,
+                    flow: Right,
                     reaction_list = <ReactionList> { }
                     avatar_row = <AvatarRow> {}
                 }
+                thread_root_summary = <ThreadRootSummary> {}
             }
-
         }
     }
 
@@ -580,6 +639,8 @@ pub struct RoomScreen {
 
     /// The name and ID of the currently-shown room, if any.
     #[rust] room_name_id: Option<RoomNameId>,
+    /// The timeline currently displayed by this RoomScreen, if any.
+    #[rust] timeline_kind: Option<TimelineKind>,
     /// The persistent UI-relevant states for the room that this widget is currently displaying.
     #[rust] tl_state: Option<TimelineUiState>,
     /// The set of pinned events in this room.
@@ -719,7 +780,7 @@ impl Widget for RoomScreen {
                         } else {
                             user_id.as_str()
                         };
-                        let room_id = tl.room_id.clone();
+                        let room_id = tl.kind.room_id().clone();
                         let content = ConfirmationModalContent {
                             title_text: "Send Invitation".into(),
                             body_text: format!("Are you sure you want to invite {username} to this room?").into(),
@@ -742,7 +803,9 @@ impl Widget for RoomScreen {
                     if self.room_name_id.as_ref().is_some_and(|rn| rn.room_id() == room_name_id.room_id()) {
                         // `set_displayed_room()` does nothing if the room_name_id is unchanged, so we clear it first.
                         self.room_name_id = None;
-                        self.set_displayed_room(cx, room_name_id);
+                        let thread_root_event_id = self.timeline_kind.as_ref()
+                            .and_then(|k| k.thread_root_event_id().cloned());
+                        self.set_displayed_room(cx, room_name_id, thread_root_event_id);
                         return;
                     }
                 }
@@ -836,16 +899,25 @@ impl Widget for RoomScreen {
                 let rooms_list_ref = cx.get_global::<RoomsListRef>();
                 if rooms_list_ref.is_room_loaded(room_name_id.room_id()) {
                     let room_name_clone = room_name_id.clone();
+                    let thread_root_event_id = self.timeline_kind.as_ref()
+                        .and_then(|k| k.thread_root_event_id().cloned());
                     // This room has been loaded now, so we call `set_displayed_room()`.
                     // We first clear the `room_name_id`, otherwise that function will do nothing.
                     self.room_name_id = None;
-                    self.set_displayed_room(cx, &room_name_clone);
+                    self.set_displayed_room(cx, &room_name_clone, thread_root_event_id);
                 } else {
                     self.all_rooms_loaded = rooms_list_ref.all_rooms_loaded();
                     return;
                 }
             }
 
+            // If this RoomScreen is waiting to show a thread timeline (not the main room timeline),
+            // then we need to retry showing the timeline now (upon a Signal),
+            // because the thread timeline may have been successfully created.
+            if self.tl_state.is_none() && self.timeline_kind.is_some() {
+                self.show_timeline(cx);
+            }
+
             self.process_timeline_updates(cx, &portal_list);
 
             // Ideally we would do this elsewhere on the main thread, because it's not room-specific,
@@ -889,7 +961,7 @@ impl Widget for RoomScreen {
             // Create a Scope with RoomScreenProps containing the room members.
             // This scope is needed by child widgets like MentionableTextInput during event handling.
             let room_props = if let Some(tl) = self.tl_state.as_ref() {
-                let room_id = tl.room_id.clone();
+                let room_id = tl.kind.room_id().clone();
                 let room_members = tl.room_members.clone();
 
                 // Fetch room data once to avoid duplicate expensive lookups
@@ -904,6 +976,7 @@ impl Widget for RoomScreen {
                 RoomScreenProps {
                     room_screen_widget_uid,
                     room_name_id: RoomNameId::new(room_display_name, room_id),
+                    timeline_kind: tl.kind.clone(),
                     room_members,
                     room_avatar_url,
                 }
@@ -912,22 +985,23 @@ impl Widget for RoomScreen {
                 RoomScreenProps {
                     room_screen_widget_uid,
                     room_name_id: room_name.clone(),
+                    timeline_kind: self.timeline_kind.clone()
+                        .expect("BUG: room_name_id was set but timeline_kind was missing"),
                     room_members: None,
                     room_avatar_url: None,
                 }
             } else {
                 // No room selected yet, skip event handling that requires room context
-                log!("RoomScreen handling event with no room_name_id and no tl_state, skipping room-dependent event handling");
                 if !is_pane_shown || !is_interactive_hit {
                     return;
                 }
+                log!("RoomScreen handling event with no room_name_id and no tl_state, skipping room-dependent event handling");
                 // Use a dummy room props for non-room-specific events
+                let room_id = owned_room_id!("!dummy:matrix.org");
                 RoomScreenProps {
                     room_screen_widget_uid,
-                    room_name_id: RoomNameId::new(
-                        RoomDisplayName::Empty,
-                        matrix_sdk::ruma::OwnedRoomId::try_from("!dummy:matrix.org").unwrap(),
-                    ),
+                    room_name_id: RoomNameId::empty(room_id.clone()),
+                    timeline_kind: TimelineKind::MainRoom { room_id },
                     room_members: None,
                     room_avatar_url: None,
                 }
@@ -1026,10 +1100,9 @@ impl Widget for RoomScreen {
             let Some(tl_state) = self.tl_state.as_mut() else {
                 return DrawStep::done();
             };
-            let room_id = &tl_state.room_id;
-            let tl_items = &tl_state.items;
 
             // Set the portal list's range based on the number of timeline items.
+            let tl_items = &tl_state.items;
             let last_item_id = tl_items.len();
 
             let list = list_ref.deref_mut();
@@ -1054,61 +1127,72 @@ impl Widget for RoomScreen {
                     };
                     let (item, item_new_draw_status) = match timeline_item.kind() {
                         TimelineItemKind::Event(event_tl_item) => match event_tl_item.content() {
-                            TimelineItemContent::MsgLike(msg_like_content) => match &msg_like_content.kind {
-                                MsgLikeKind::Message(_)
-                                | MsgLikeKind::Sticker(_)
-                                | MsgLikeKind::Redacted => {
-                                    let prev_event = tl_idx.checked_sub(1).and_then(|i| tl_items.get(i));
-                                    populate_message_view(
-                                        cx,
-                                        list,
-                                        item_id,
-                                        room_id,
-                                        event_tl_item,
-                                        msg_like_content,
-                                        prev_event,
-                                        &mut tl_state.media_cache,
-                                        &mut tl_state.link_preview_cache,
-                                        &tl_state.user_power,
-                                        &self.pinned_events,
-                                        item_drawn_status,
-                                        room_screen_widget_uid,
-                                    )
-                                },
-                                // TODO: properly implement `Poll` as a regular Message-like timeline item.
-                                MsgLikeKind::Poll(poll_state) => populate_small_state_event(
-                                    cx,
-                                    list,
-                                    item_id,
-                                    room_id,
-                                    event_tl_item,
-                                    poll_state,
-                                    item_drawn_status,
-                                ),
-                                MsgLikeKind::UnableToDecrypt(utd) => populate_small_state_event(
-                                    cx,
-                                    list,
-                                    item_id,
-                                    room_id,
-                                    event_tl_item,
-                                    utd,
-                                    item_drawn_status,
-                                ),
-                                MsgLikeKind::Other(other) => populate_small_state_event(
-                                    cx,
-                                    list,
-                                    item_id,
-                                    room_id,
-                                    event_tl_item,
-                                    other,
-                                    item_drawn_status,
-                                ),
+                            TimelineItemContent::MsgLike(msg_like_content) => {
+                                if tl_state.kind.thread_root_event_id().is_none()
+                                    && msg_like_content.thread_root.is_some()
+                                {
+                                    // Hide threaded replies from the main room timeline UI.
+                                    (list.item(cx, item_id, id!(Empty)), ItemDrawnStatus::both_drawn())
+                                } else {
+                                    match &msg_like_content.kind {
+                                        MsgLikeKind::Message(_)
+                                        | MsgLikeKind::Sticker(_)
+                                        | MsgLikeKind::Redacted => {
+                                            let prev_event = tl_idx.checked_sub(1).and_then(|i| tl_items.get(i));
+                                            populate_message_view(
+                                                cx,
+                                                list,
+                                                item_id,
+                                                &tl_state.kind,
+                                                event_tl_item,
+                                                msg_like_content,
+                                                prev_event,
+                                                &mut tl_state.media_cache,
+                                                &mut tl_state.link_preview_cache,
+                                                &tl_state.fetched_thread_summaries,
+                                                &mut tl_state.pending_thread_summary_fetches,
+                                                &tl_state.user_power,
+                                                &self.pinned_events,
+                                                item_drawn_status,
+                                                room_screen_widget_uid,
+                                            )
+                                        },
+                                        // TODO: properly implement `Poll` as a regular Message-like timeline item.
+                                        MsgLikeKind::Poll(poll_state) => populate_small_state_event(
+                                            cx,
+                                            list,
+                                            item_id,
+                                            &tl_state.kind,
+                                            event_tl_item,
+                                            poll_state,
+                                            item_drawn_status,
+                                        ),
+                                        MsgLikeKind::UnableToDecrypt(utd) => populate_small_state_event(
+                                            cx,
+                                            list,
+                                            item_id,
+                                            &tl_state.kind,
+                                            event_tl_item,
+                                            utd,
+                                            item_drawn_status,
+                                        ),
+                                        MsgLikeKind::Other(other) => populate_small_state_event(
+                                            cx,
+                                            list,
+                                            item_id,
+                                            &tl_state.kind,
+                                            event_tl_item,
+                                            other,
+                                            item_drawn_status,
+                                        ),
+                                    }
+                                }
                             },
                             TimelineItemContent::MembershipChange(membership_change) => populate_small_state_event(
                                 cx,
                                 list,
                                 item_id,
-                                room_id,
+                                &tl_state.kind,
                                 event_tl_item,
                                 membership_change,
                                 item_drawn_status,
@@ -1117,7 +1201,7 @@ impl Widget for RoomScreen {
                                 cx,
                                 list,
                                 item_id,
-                                room_id,
+                                &tl_state.kind,
                                 event_tl_item,
                                 profile_change,
                                 item_drawn_status,
@@ -1126,7 +1210,7 @@ impl Widget for RoomScreen {
                                 cx,
                                 list,
                                 item_id,
-                                room_id,
+                                &tl_state.kind,
                                 event_tl_item,
                                 other,
                                 item_drawn_status,
@@ -1172,8 +1256,8 @@ impl Widget for RoomScreen {
             // until we have enough events items to fill the viewport.
             if !tl_state.fully_paginated && !list.is_filling_viewport() {
                 log!("Automatically paginating timeline to fill viewport for room {:?}", self.room_name_id);
-                submit_async_request(MatrixRequest::PaginateRoomTimeline {
-                    room_id: room_id.clone(),
+                submit_async_request(MatrixRequest::PaginateTimeline {
+                    timeline_kind: tl_state.kind.clone(),
                     num_events: 50,
                     direction: PaginationDirection::Backwards,
                 });
@@ -1220,7 +1304,7 @@ impl RoomScreen {
                 TimelineUpdate::NewItems { new_items, changed_indices, is_append, clear_cache } => {
                     if new_items.is_empty() {
                         if !tl.items.is_empty() {
-                            log!("process_timeline_updates(): timeline (had {} items) was cleared for room {}", tl.items.len(), tl.room_id);
+                            log!("process_timeline_updates(): timeline (had {} items) was cleared for room {}", tl.items.len(), tl.kind.room_id());
                             // For now, we paginate a cleared timeline in order to be able to show something at least.
                             // A proper solution would be what's described below, which would be to save a few event IDs
                             // and then either focus on them (if we're not close to the end of the timeline)
@@ -1291,7 +1375,9 @@ impl RoomScreen {
                     if is_append && !portal_list.is_at_end() {
                         // Immediately show the unread badge with no count while we fetch the actual count in the background.
                         jump_to_bottom.show_unread_message_badge(cx, UnreadMessageCount::Unknown);
-                        submit_async_request(MatrixRequest::GetNumberUnreadMessages{ room_id: tl.room_id.clone() });
+                        submit_async_request(MatrixRequest::GetNumberUnreadMessages{
+                            timeline_kind: tl.kind.clone(),
+                        });
                     }
 
                     if prior_items_changed {
@@ -1333,9 +1419,9 @@ impl RoomScreen {
                     jump_to_bottom.show_unread_message_badge(cx, unread_messages_count);
                 }
                 TimelineUpdate::TargetEventFound { target_event_id, index } => {
-                    // log!("Target event found in room {}: {target_event_id}, index: {index}", tl.room_id);
+                    // log!("Target event found in room {}: {target_event_id}, index: {index}", tl.kind.room_id());
                     tl.request_sender.send_if_modified(|requests| {
-                        requests.retain(|r| r.room_id != tl.room_id);
+                        requests.retain(|r| &r.room_id != tl.kind.room_id());
                         // no need to notify/wake-up all receivers for a completed request
                         false
                     });
@@ -1348,7 +1434,7 @@ impl RoomScreen {
                     );
                     let loading_pane = self.view.loading_pane(ids!(loading_pane));
 
-                    // log!("TargetEventFound: is_valid? {is_valid}. room {}, event {target_event_id}, index {index} of {}\n  --> item: {item:?}", tl.room_id, tl.items.len());
+                    // log!("TargetEventFound: is_valid? {is_valid}. room {}, event {target_event_id}, index {index} of {}\n  --> item: {item:?}", tl.kind.room_id(), tl.items.len());
                     if is_valid {
                         // We successfully found the target event, so we can close the loading pane,
                         // reset the loading panestate to `None`, and stop issuing backwards pagination requests.
@@ -1372,7 +1458,7 @@ impl RoomScreen {
                         // Here, the target event was not found in the current timeline,
                         // or we found it previously but it is no longer in the timeline (or has moved),
                         // which means we encountered an error and are unable to jump to the target event.
-                        error!("Target event index {index} of {} is out of bounds for room {}", tl.items.len(), tl.room_id);
+                        error!("Target event index {index} of {} is out of bounds for room {}", tl.items.len(), tl.kind.room_id());
                         // Show this error in the loading pane, which should already be open.
                         loading_pane.set_state(cx, LoadingPaneState::Error(
                             String::from("Unable to find related message; it may have been deleted.")
@@ -1416,13 +1502,39 @@ impl RoomScreen {
                 }
                 TimelineUpdate::EventDetailsFetched {event_id, result } => {
                     if let Err(_e) = result {
-                        error!("Failed to fetch details fetched for event {event_id} in room {}. Error: {_e:?}", tl.room_id);
+                        error!("Failed to fetch details fetched for event {event_id} in room {}. Error: {_e:?}", tl.kind.room_id());
                     }
                     // Here, to be most efficient, we could redraw only the updated event,
                     // but for now we just fall through and let the final `redraw()` call re-draw the whole timeline view.
                 }
+                TimelineUpdate::ThreadSummaryDetailsFetched {
+                    thread_root_event_id,
+                    timeline_item_index,
+                    num_replies,
+                    latest_reply_preview_text,
+                } => {
+                    tl.pending_thread_summary_fetches.remove(&thread_root_event_id);
+                    tl.fetched_thread_summaries.insert(
+                        thread_root_event_id.clone(),
+                        FetchedThreadSummary {
+                            num_replies,
+                            latest_reply_preview_text,
+                        },
+                    );
+                    let event_id_matches_at_index = tl.items
+                        .get(timeline_item_index)
+                        .and_then(|item| item.as_event())
+                        .and_then(|ev| ev.event_id())
+                        .is_some_and(|id| id == thread_root_event_id);
+                    if event_id_matches_at_index {
+                        tl.content_drawn_since_last_update
+                            .remove(timeline_item_index .. timeline_item_index + 1);
+                    } else {
+                        tl.content_drawn_since_last_update.clear();
+                    }
+                }
                 TimelineUpdate::RoomMembersSynced => {
-                    // log!("process_timeline_updates(): room members fetched for room {}", tl.room_id);
+                    // log!("process_timeline_updates(): room members fetched for room {}", tl.kind.room_id());
                     // Here, to be most efficient, we could redraw only the user avatars and names in the timeline,
                     // but for now we just fall through and let the final `redraw()` call re-draw the whole timeline view.
                 }
@@ -1431,7 +1543,7 @@ impl RoomScreen {
                     tl.room_members = Some(Arc::new(members));
                 },
                 TimelineUpdate::MediaFetched(request) => {
-                    log!("process_timeline_updates(): media fetched for room {}", tl.room_id);
+                    log!("process_timeline_updates(): media fetched for room {}", tl.kind.room_id());
                     // Set Image to image viewer modal if the media is not a thumbnail.
                     if let (MediaFormat::File, media_source) = (request.format, request.source) {
                         populate_matrix_image_modal(cx, media_source, &mut tl.media_cache);
@@ -1439,7 +1551,7 @@ impl RoomScreen {
                     // Here, to be most efficient, we could redraw only the media items in the timeline,
                     // but for now we just fall through and let the final `redraw()` call re-draw the whole timeline view.
                 }
-                TimelineUpdate::MessageEdited { timeline_event_id, result } => {
+                TimelineUpdate::MessageEdited { timeline_event_item_id: timeline_event_id, result } => {
                     self.view.room_input_bar(ids!(room_input_bar))
                         .handle_edit_result(cx, timeline_event_id, result);
                 }
@@ -1486,7 +1598,7 @@ impl RoomScreen {
                         .update_user_power_levels(cx, user_power_levels);
                     // Update the @room mention capability based on the user's power level
                     cx.action(MentionableTextInputAction::PowerLevelsUpdated {
-                        room_id: tl.room_id.clone(),
+                        room_id: tl.kind.room_id().clone(),
                         can_notify_room: user_power_levels.can_notify_room(),
                     });
                     // We need to redraw all events in order to reflect the new power levels,
@@ -1499,7 +1611,7 @@ impl RoomScreen {
                 }
                 TimelineUpdate::Tombstoned(successor_room_details) => {
                     self.view.room_input_bar(ids!(room_input_bar))
-                        .update_tombstone_footer(cx, &tl.room_id, Some(&successor_room_details));
+                        .update_tombstone_footer(cx, tl.kind.room_id(), Some(&successor_room_details));
                     tl.tombstone_info = Some(successor_room_details);
                 }
                 TimelineUpdate::LinkPreviewFetched => {}
@@ -1507,8 +1619,8 @@ impl RoomScreen {
         }
 
         if should_continue_backwards_pagination {
-            submit_async_request(MatrixRequest::PaginateRoomTimeline {
-                room_id: tl.room_id.clone(),
+            submit_async_request(MatrixRequest::PaginateTimeline {
+                timeline_kind: tl.kind.clone(),
                 num_events: 50,
                 direction: PaginationDirection::Backwards,
             });
@@ -1525,7 +1637,7 @@ impl RoomScreen {
         }
 
         if num_updates > 0 {
-            // log!("Applied {} timeline updates for room {}, redrawing with {} items...", num_updates, tl.room_id, tl.items.len());
+            // log!("Applied {} timeline updates for room {}, redrawing with {} items...", num_updates, tl.kind.room_id(), tl.items.len());
             self.redraw(cx);
         }
     }
@@ -1677,7 +1789,7 @@ impl RoomScreen {
                 image_file_size,
                 timestamp: unix_time_millis_to_datetime(timestamp_millis),
                 avatar_parameter: Some((
-                    tl_state.room_id.clone(),
+                    tl_state.kind.clone(),
                     event_tl_item.clone(),
                 )),
             }),
@@ -1727,7 +1839,7 @@ impl RoomScreen {
                 MessageAction::React { details, reaction } => {
                     let Some(tl) = self.tl_state.as_ref() else { return };
                     submit_async_request(MatrixRequest::ToggleReaction {
-                        room_id: tl.room_id.clone(),
+                        timeline_kind: tl.kind.clone(),
                         timeline_event_id: details.timeline_event_id.clone(),
                         reaction: reaction.clone(),
                     });
@@ -1737,7 +1849,7 @@ impl RoomScreen {
                     if let Some(event_tl_item) = Self::find_event_in_timeline(&tl.items, details).cloned() {
                         let replied_to_info = EmbeddedEvent::from_timeline_item(&event_tl_item);
                         self.view.room_input_bar(ids!(room_input_bar))
-                            .show_replying_to(cx, (event_tl_item, replied_to_info), &tl.room_id);
+                            .show_replying_to(cx, (event_tl_item, replied_to_info), &tl.kind);
                     }
                     else {
                         enqueue_popup_notification(
@@ -1756,7 +1868,11 @@ impl RoomScreen {
                     let Some(tl) = self.tl_state.as_ref() else { return };
                     if let Some(event_tl_item) = Self::find_event_in_timeline(&tl.items, details) {
                         self.view.room_input_bar(ids!(room_input_bar))
-                            .show_editing_pane(cx, event_tl_item.clone(), tl.room_id.clone());
+                            .show_editing_pane(
+                                cx,
+                                event_tl_item.clone(),
+                                tl.kind.clone(),
+                            );
                     }
                     else {
                         enqueue_popup_notification(
@@ -1780,7 +1896,11 @@ impl RoomScreen {
                         .find_map(|item| item.as_event().filter(|ev| ev.is_editable()).cloned())
                     {
                         self.view.room_input_bar(ids!(room_input_bar))
-                            .show_editing_pane(cx, latest_sent_msg, tl.room_id.clone());
+                            .show_editing_pane(
+                                cx,
+                                latest_sent_msg,
+                                tl.kind.clone(),
+                            );
                     }
                     else {
                         enqueue_popup_notification(
@@ -1794,8 +1914,8 @@ impl RoomScreen {
                     let Some(tl) = self.tl_state.as_ref() else { return };
                     if let Some(event_id) = details.event_id() {
                         submit_async_request(MatrixRequest::PinEvent {
+                            timeline_kind: tl.kind.clone(),
                             event_id: event_id.clone(),
-                            room_id: tl.room_id.clone(),
                             pin: true,
                         });
                     } else {
@@ -1810,8 +1930,8 @@ impl RoomScreen {
                     let Some(tl) = self.tl_state.as_ref() else { return };
                     if let Some(event_id) = details.event_id() {
                         submit_async_request(MatrixRequest::PinEvent {
+                            timeline_kind: tl.kind.clone(),
                             event_id: event_id.clone(),
-                            room_id: tl.room_id.clone(),
                             pin: false,
                         });
                     } else {
@@ -1836,7 +1956,7 @@ impl RoomScreen {
                         error!("MessageAction::CopyText: couldn't find event [{}] {:?} to copy text from in room {}",
                             details.item_id,
                             details.timeline_event_id,
-                            tl.room_id,
+                            tl.kind.room_id(),
                         );
                     }
                 }
@@ -1873,14 +1993,14 @@ impl RoomScreen {
                         error!("MessageAction::CopyHtml: couldn't find event [{}] {:?} to copy HTML from in room {}",
                             details.item_id,
                             details.timeline_event_id,
-                            tl.room_id,
+                            tl.kind.room_id(),
                         );
                     }
                 }
                 MessageAction::CopyLink(details) => {
                     let Some(tl) = self.tl_state.as_ref() else { return };
                     if let Some(event_id) = details.event_id() {
-                        let matrix_to_uri = tl.room_id.matrix_to_event_uri(event_id.clone());
+                        let matrix_to_uri = tl.kind.room_id().matrix_to_event_uri(event_id.clone());
                         cx.copy_to_clipboard(&matrix_to_uri.to_string());
                     } else {
                         enqueue_popup_notification(
@@ -1891,7 +2011,7 @@ impl RoomScreen {
                         error!("MessageAction::CopyLink: no `event_id`: [{}] {:?} in room {}",
                             details.item_id,
                             details.timeline_event_id,
-                            tl.room_id,
+                            tl.kind.room_id(),
                         );
                     }
                 }
@@ -1914,7 +2034,7 @@ impl RoomScreen {
                     let event_id = event_tl_item.event_id().map(|e| e.to_owned());
 
                     cx.action(super::event_source_modal::EventSourceModalAction::Open {
-                        room_id: tl.room_id.clone(),
+                        room_id: tl.kind.room_id().clone(),
                         event_id,
                         original_json,
                     });
@@ -1946,10 +2066,24 @@ impl RoomScreen {
                         loading_pane
                     );
                 }
+                MessageAction::OpenThread(thread_root_event_id) => {
+                    let Some(room_name_id) = self.room_name_id.as_ref().cloned() else {
+                        error!("### ERROR: MessageAction::OpenThread: thread_root_event_id={thread_root_event_id}, but room_name_id was None!");
+                        continue
+                    };
+                    cx.widget_action(
+                        room_screen_widget_uid,
+                        &HeapLiveIdPath::default(),
+                        RoomsListAction::Selected(SelectedRoom::Thread {
+                            room_name_id,
+                            thread_root_event_id: thread_root_event_id.clone(),
+                        }),
+                    );
+                }
                 MessageAction::Redact { details, reason } => {
                     let Some(tl) = self.tl_state.as_ref() else { return };
                     let timeline_event_id = details.timeline_event_id.clone();
-                    let room_id = tl.room_id.clone();
+                    let timeline_kind = tl.kind.clone();
                     let reason = reason.clone();
                     let content = ConfirmationModalContent {
                         title_text: "Delete Message".into(),
@@ -1957,7 +2091,7 @@ impl RoomScreen {
                         accept_button_text: Some("Delete".into()),
                         on_accept_clicked: Some(Box::new(move |_cx| {
                             submit_async_request(MatrixRequest::RedactMessage {
-                                room_id,
+                                timeline_kind,
                                 timeline_event_id,
                                 reason,
                             });
@@ -2018,7 +2152,7 @@ impl RoomScreen {
             .map(|position| max_tl_idx.saturating_sub(position).saturating_sub(1));
 
         if let Some(index) = related_msg_tl_index {
-            // log!("The related message {replied_to_event} was immediately found in room {}, scrolling to from index {reply_message_item_id} --> {index} (first ID {}).", tl.room_id, portal_list.first_id());
+            // log!("The related message {replied_to_event} was immediately found in room {}, scrolling to from index {reply_message_item_id} --> {index} (first ID {}).", tl.kind.room_id(), portal_list.first_id());
             let speed = 50.0;
             // Scroll to the message right *before* the replied-to message.
             // FIXME: `smooth_scroll_to` should accept a "scroll offset" (first scroll) parameter too,
@@ -2030,7 +2164,7 @@ impl RoomScreen {
                 item_id: index
             };
         } else {
-            log!("The related event {target_event_id} wasn't immediately available in room {}, searching for it in the background...", tl.room_id);
+            log!("The related event {target_event_id} wasn't immediately available in room {}, searching for it in the background...", tl.kind.room_id());
             // Here, we set the state of the loading pane and display it to the user.
             // The main logic will be handled in `process_timeline_updates()`, which is the only
             // place where we can receive updates to the timeline from the background tasks.
@@ -2045,13 +2179,13 @@ impl RoomScreen {
             loading_pane.show(cx);
 
             tl.request_sender.send_if_modified(|requests| {
-                if let Some(existing) = requests.iter_mut().find(|r| r.room_id == tl.room_id) {
-                    warning!("Unexpected: room {} already had an existing timeline request in progress, event: {:?}", tl.room_id, existing.target_event_id);
+                if let Some(existing) = requests.iter_mut().find(|r| &r.room_id == tl.kind.room_id()) {
+                    warning!("Unexpected: room {} already had an existing timeline request in progress, event: {:?}", tl.kind.room_id(), existing.target_event_id);
                     // We might as well re-use this existing request...
                     existing.target_event_id = target_event_id.clone();
                 } else {
                     requests.push(BackwardsPaginateUntilEventRequest {
-                        room_id: tl.room_id.clone(),
+                        room_id: tl.kind.room_id().clone(),
                         target_event_id: target_event_id.clone(),
                         // avoid re-searching through items we already searched through.
                         starting_index: max_tl_idx.saturating_sub(num_items_searched),
@@ -2083,19 +2217,25 @@ impl RoomScreen {
     /// Invoke this when this timeline is being shown,
     /// e.g., when the user navigates to this timeline.
     fn show_timeline(&mut self, cx: &mut Cx) {
-        let room_id = self
-            .room_id()
-            .expect("BUG: Timeline::show_timeline(): no room_name was set.")
-            .clone();
+        let kind = self.timeline_kind.clone()
+            .expect("BUG: Timeline::show_timeline(): no timeline_kind was set.");
+        let room_id = kind.room_id().clone();
 
-        let state_opt = TIMELINE_STATES.with_borrow_mut(|ts| ts.remove(&room_id));
+        let state_opt = TIMELINE_STATES.with_borrow_mut(|ts| ts.remove(&kind));
         let (mut tl_state, mut is_first_time_being_loaded) = if let Some(existing) = state_opt {
             (existing, false)
         } else {
-            let Some(timeline_endpoints) = take_timeline_endpoints(&room_id) else {
+            let Some(timeline_endpoints) = take_timeline_endpoints(&kind) else {
+                if let Some(thread_root_event_id) = kind.thread_root_event_id() {
+                    submit_async_request(MatrixRequest::CreateThreadTimeline {
+                        room_id: room_id.clone(),
+                        thread_root_event_id: thread_root_event_id.clone(),
+                    });
+                    return;
+                }
                 if !self.is_loaded && self.all_rooms_loaded {
-                    panic!("BUG: timeline is not loaded, but room_id {:?} \
-                    was not waiting for its timeline to be loaded.", room_id);
+                    panic!("BUG: timeline {kind} is not loaded, but its RoomScreen \
+                    was not waiting for its timeline to be loaded either.");
                 }
                 return;
             };
@@ -2118,7 +2258,7 @@ impl RoomScreen {
             };
 
             let tl_state = TimelineUiState {
-                room_id: room_id.clone(),
+                kind,
                 // Initially, we assume the user has all power levels by default.
                 // This avoids unexpectedly hiding any UI elements that should be visible to the user.
                 // This doesn't mean that the user can actually perform all actions;
@@ -2135,6 +2275,8 @@ impl RoomScreen {
                 request_sender,
                 media_cache: MediaCache::new(Some(update_sender.clone())),
                 link_preview_cache: LinkPreviewCache::new(Some(update_sender)),
+                fetched_thread_summaries: HashMap::new(),
+                pending_thread_summary_fetches: HashSet::new(),
                 saved_state: SavedState::default(),
                 message_highlight_animation_state: MessageHighlightAnimationState::default(),
                 last_scrolled_index: usize::MAX,
@@ -2160,9 +2302,7 @@ impl RoomScreen {
             let rooms_list_ref = cx.get_global::<RoomsListRef>();
             let is_loaded_now = rooms_list_ref.is_room_loaded(&room_id);
             if is_loaded_now && !self.is_loaded {
-                // log!("Detected that room {:?} is now loaded for the first time",
-                //     self.room_name_id
-                // );
+                // log!("Detected that {}} is now loaded for the first time", tl_state.kind);
                 is_first_time_being_loaded = true;
             }
             self.is_loaded = is_loaded_now;
@@ -2175,9 +2315,9 @@ impl RoomScreen {
         // when they first open the room, and there might not be any messages yet.
         if is_first_time_being_loaded {
             if !tl_state.fully_paginated {
-                log!("Sending a first-time backwards pagination request for room {:?}", self.room_name_id);
-                submit_async_request(MatrixRequest::PaginateRoomTimeline {
-                    room_id: room_id.clone(),
+                log!("Sending a first-time backwards pagination request for {}", tl_state.kind);
+                submit_async_request(MatrixRequest::PaginateTimeline {
+                    timeline_kind: tl_state.kind.clone(),
                     num_events: 50,
                     direction: PaginationDirection::Backwards,
                 });
@@ -2186,7 +2326,9 @@ impl RoomScreen {
             // Even though we specify that room member profiles should be lazy-loaded,
             // the matrix server still doesn't consistently send them to our client properly.
             // So we kick off a request to fetch the room members here upon first viewing the room.
-            submit_async_request(MatrixRequest::SyncRoomMemberList { room_id: room_id.clone() });
+            submit_async_request(MatrixRequest::SyncRoomMemberList {
+                timeline_kind: tl_state.kind.clone(),
+            });
         }
 
         // Hide the typing notice view initially.
@@ -2200,27 +2342,30 @@ impl RoomScreen {
         // 4. Subscribe to typing notices again, now that the room is being shown.
         if self.is_loaded {
             submit_async_request(MatrixRequest::GetRoomPowerLevels {
-                room_id: room_id.clone(),
+                timeline_kind: tl_state.kind.clone(),
             });
             submit_async_request(MatrixRequest::GetRoomMembers {
-                room_id: room_id.clone(),
+                timeline_kind: tl_state.kind.clone(),
                 memberships: matrix_sdk::RoomMemberships::JOIN,
                 // Fetch from the local cache, as we already requested to sync
                 // the room members from the homeserver above.
                 local_only: true,
             });
-            submit_async_request(MatrixRequest::SubscribeToTypingNotices {
-                room_id: room_id.clone(),
-                subscribe: true,
-            });
             submit_async_request(MatrixRequest::SubscribeToOwnUserReadReceiptsChanged {
-                room_id: room_id.clone(),
-                subscribe: true,
-            });
-            submit_async_request(MatrixRequest::SubscribeToPinnedEvents {
-                room_id: room_id.clone(),
+                timeline_kind: tl_state.kind.clone(),
                 subscribe: true,
             });
+            // Only main room timelines can subscribe to typing notices and pinned events.
+            if matches!(tl_state.kind, TimelineKind::MainRoom { .. }) {
+                submit_async_request(MatrixRequest::SubscribeToTypingNotices {
+                    room_id: room_id.clone(),
+                    subscribe: true,
+                });
+                submit_async_request(MatrixRequest::SubscribeToPinnedEvents {
+                    room_id: room_id.clone(),
+                    subscribe: true,
+                });
+            }
         }
 
         // Now, restore the visual state of this timeline from its previously-saved state.
@@ -2239,25 +2384,28 @@ impl RoomScreen {
 
     /// Invoke this when this RoomScreen/timeline is being hidden or no longer being shown.
     fn hide_timeline(&mut self) {
-        let Some(room_id) = self.room_id().cloned() else { return };
+        let Some(timeline_kind) = self.timeline_kind.clone() else { return };
 
         self.save_state();
 
-        // When closing a room view, we do the following with non-persistent states:
+        // When closing a room view, we do the following with non-persistent states.
+        // (This should be the inverse of what's done in `show_timeline()`.)
         // * Unsubscribe from typing notices, since we don't care about them
         //   when a given room isn't visible.
-        // * Unsubscribe from updates to our own user's read receipts, for the same reason.
         // * Unsubscribe from updates to this room's pinned events, for the same reason.
-        submit_async_request(MatrixRequest::SubscribeToTypingNotices {
-            room_id: room_id.clone(),
-            subscribe: false,
-        });
+        // * Unsubscribe from updates to our own user's read receipts, for the same reason.
+        if matches!(timeline_kind, TimelineKind::MainRoom { .. }) {
+            submit_async_request(MatrixRequest::SubscribeToTypingNotices {
+                room_id: timeline_kind.room_id().clone(),
+                subscribe: false,
+            });
+            submit_async_request(MatrixRequest::SubscribeToPinnedEvents {
+                room_id: timeline_kind.room_id().clone(),
+                subscribe: false,
+            });
+        }
         submit_async_request(MatrixRequest::SubscribeToOwnUserReadReceiptsChanged {
-            room_id: room_id.clone(),
-            subscribe: false,
-        });
-        submit_async_request(MatrixRequest::SubscribeToPinnedEvents {
-            room_id,
+            timeline_kind,
             subscribe: false,
         });
     }
@@ -2281,7 +2429,7 @@ impl RoomScreen {
         // Clear room_members to avoid wasting memory (in case this room is never re-opened).
         tl.room_members = None;
         // Store this Timeline's `TimelineUiState` in the global map of states.
-        TIMELINE_STATES.with_borrow_mut(|ts| ts.insert(tl.room_id.clone(), tl));
+        TIMELINE_STATES.with_borrow_mut(|ts| ts.insert(tl.kind.clone(), tl));
     }
 
     /// Restores the previously-saved visual UI state of this room.
@@ -2308,7 +2456,7 @@ impl RoomScreen {
         let saved_room_input_bar_state = std::mem::take(room_input_bar_state);
         room_input_bar.restore_state(
             cx,
-            &tl_state.room_id,
+            tl_state.kind.clone(),
             saved_room_input_bar_state,
             tl_state.user_power,
             tl_state.tombstone_info.as_ref(),
@@ -2320,22 +2468,38 @@ impl RoomScreen {
         &mut self,
         cx: &mut Cx,
         room_name_id: &RoomNameId,
+        thread_root_event_id: Option<OwnedEventId>,
     ) {
-        // If the room is already being displayed, then do nothing.
-        if self.room_name_id.as_ref().is_some_and(|rn| rn.room_id() == room_name_id.room_id()) { return; }
+        let timeline_kind = if let Some(thread_root_event_id) = thread_root_event_id {
+            TimelineKind::Thread {
+                room_id: room_name_id.room_id().clone(),
+                thread_root_event_id,
+            }
+        } else {
+            TimelineKind::MainRoom {
+                room_id: room_name_id.room_id().clone(),
+            }
+        };
+
+        // If this timeline is already displayed, we don't need to do anything major,
+        // but we do need update the `room_name_id` in case it has changed, or it has been cleared.
+        if self.timeline_kind.as_ref().is_some_and(|kind| kind == &timeline_kind) {
+            self.room_name_id = Some(room_name_id.clone());
+            return;
+        }
 
         self.hide_timeline();
         // Reset the the state of the inner loading pane.
         self.loading_pane(ids!(loading_pane)).take_state();
 
-        let room_id = room_name_id.room_id().clone();
         self.room_name_id = Some(room_name_id.clone());
+        self.timeline_kind = Some(timeline_kind.clone());
 
         // We initially tell every MentionableTextInput widget that the current user
         // *does not* have privileges to notify the entire room;
         // this gets properly updated when room PowerLevels get fetched.
         cx.action(MentionableTextInputAction::PowerLevelsUpdated {
-            room_id: room_id.clone(),
+            room_id: timeline_kind.room_id().clone(),
             can_notify_room: false,
         });
 
@@ -2374,13 +2538,15 @@ impl RoomScreen {
                         return;
                     };
                     submit_async_request(MatrixRequest::ReadReceipt {
-                        room_id: tl_state.room_id.clone(),
+                        timeline_kind: tl_state.kind.clone(),
                         event_id: last_event_id.to_owned(),
+                        receipt_type: ReceiptType::Read,
                     });
                     if tl_state.scrolled_past_read_marker {
-                        submit_async_request(MatrixRequest::FullyReadReceipt {
-                            room_id: tl_state.room_id.clone(),
+                        submit_async_request(MatrixRequest::ReadReceipt {
+                            timeline_kind: tl_state.kind.clone(),
                             event_id: last_event_id.to_owned(),
+                            receipt_type: ReceiptType::FullyRead,
                         });
                     } else {
                         if let Some(own_user_receipt_timestamp) = &tl_state.latest_own_user_receipt.clone()
@@ -2398,9 +2564,10 @@ impl RoomScreen {
                                 && own_user_receipt_timestamp <= &last_timestamp
                             {
                                 tl_state.scrolled_past_read_marker = true;
-                                submit_async_request(MatrixRequest::FullyReadReceipt {
-                                    room_id: tl_state.room_id.clone(),
+                                submit_async_request(MatrixRequest::ReadReceipt {
+                                    timeline_kind: tl_state.kind.clone(),
                                     event_id: last_event_id.to_owned(),
+                                    receipt_type: ReceiptType::FullyRead,
                                 });
                             }
 
@@ -2429,10 +2596,10 @@ impl RoomScreen {
         let first_index = portal_list.first_id();
         if first_index == 0 && tl.last_scrolled_index > 0 {
             log!("Scrolled up from item {} --> 0, sending back pagination request for room {}",
-                tl.last_scrolled_index, tl.room_id,
+                tl.last_scrolled_index, tl.kind,
             );
-            submit_async_request(MatrixRequest::PaginateRoomTimeline {
-                room_id: tl.room_id.clone(),
+            submit_async_request(MatrixRequest::PaginateTimeline {
+                timeline_kind: tl.kind.clone(),
                 num_events: 50,
                 direction: PaginationDirection::Backwards,
             });
@@ -2447,9 +2614,10 @@ impl RoomScreenRef {
         &self,
         cx: &mut Cx,
         room_name_id: &RoomNameId,
+        thread_root_event_id: Option<OwnedEventId>,
     ) {
         let Some(mut inner) = self.borrow_mut() else { return };
-        inner.set_displayed_room(cx, room_name_id);
+        inner.set_displayed_room(cx, room_name_id, thread_root_event_id);
     }
 }
 
@@ -2458,6 +2626,7 @@ impl RoomScreenRef {
 pub struct RoomScreenProps {
     pub room_screen_widget_uid: WidgetUid,
     pub room_name_id: RoomNameId,
+    pub timeline_kind: TimelineKind,
     pub room_members: Option<Arc<Vec<RoomMember>>>,
     pub room_avatar_url: Option<OwnedMxcUri>,
 }
@@ -2540,9 +2709,16 @@ pub enum TimelineUpdate {
         event_id: OwnedEventId,
         result: Result<(), matrix_sdk_ui::timeline::Error>,
     },
+    /// A notice that fresh thread-summary details were fetched for a thread root.
+    ThreadSummaryDetailsFetched {
+        thread_root_event_id: OwnedEventId,
+        timeline_item_index: usize,
+        num_replies: u32,
+        latest_reply_preview_text: Option<String>,
+    },
     /// The result of a request to edit a message in this timeline.
     MessageEdited {
-        timeline_event_id: TimelineEventItemId,
+        timeline_event_item_id: TimelineEventItemId,
         result: Result<(), matrix_sdk_ui::timeline::Error>,
     },
     /// A notice that the room's members have been fetched from the server,
@@ -2587,9 +2763,8 @@ thread_local! {
     /// The global set of all timeline states, one entry per room.
     ///
     /// This is only useful when accessed from the main UI thread.
-    static TIMELINE_STATES: RefCell<BTreeMap<OwnedRoomId, TimelineUiState>> = const {
-        RefCell::new(BTreeMap::new())
-    };
+    static TIMELINE_STATES: RefCell<HashMap<TimelineKind, TimelineUiState>> = 
+        RefCell::new(HashMap::new());
 }
 
 /// The UI-side state of a single room's timeline, which is only accessed/updated by the UI thread.
@@ -2599,8 +2774,8 @@ thread_local! {
 /// If a state is more temporary and shouldn't be persisted when the timeline is hidden,
 /// then it should be stored in the RoomScreen widget itself, not in this struct.
 struct TimelineUiState {
-    /// The ID of the room that this timeline is for.
-    room_id: OwnedRoomId,
+    /// Info determining whether this is a main room timeline is a thread-focused timeline.
+    kind: TimelineKind,
 
     /// The power levels of the currently logged-in user in this room.
     user_power: UserPowerLevels,
@@ -2654,6 +2829,10 @@ struct TimelineUiState {
 
     /// Cache for link preview data indexed by URL to avoid redundant network requests.
     link_preview_cache: LinkPreviewCache,
+    /// Cached fetched thread-summary details, keyed by thread-root event ID.
+    fetched_thread_summaries: HashMap<OwnedEventId, FetchedThreadSummary>,
+    /// Set of thread roots currently being fetched to avoid duplicate in-flight requests.
+    pending_thread_summary_fetches: HashSet<OwnedEventId>,
 
     /// The states relevant to the UI display of this timeline that are saved upon
     /// a `Hide` action and restored upon a `Show` action.
@@ -2784,6 +2963,12 @@ struct ItemDrawnStatus {
     /// Whether the content of the item was drawn (e.g., the message text, image, video, sticker, etc).
     content_drawn: bool,
 }
+
+#[derive(Clone, Debug)]
+struct FetchedThreadSummary {
+    num_replies: u32,
+    latest_reply_preview_text: Option<String>,
+}
 impl ItemDrawnStatus {
     /// Returns a new `ItemDrawnStatus` with both `profile_drawn` and `content_drawn` set to `false`.
     const fn new() -> Self {
@@ -2810,12 +2995,14 @@ fn populate_message_view(
     cx: &mut Cx2d,
     list: &mut PortalList,
     item_id: usize,
-    room_id: &OwnedRoomId,
+    timeline_kind: &TimelineKind,
     event_tl_item: &EventTimelineItem,
     msg_like_content: &MsgLikeContent,
     prev_event: Option<&Arc<TimelineItem>>,
     media_cache: &mut MediaCache,
     link_preview_cache: &mut LinkPreviewCache,
+    fetched_thread_summaries: &HashMap<OwnedEventId, FetchedThreadSummary>,
+    pending_thread_summary_fetches: &mut HashSet<OwnedEventId>,
     user_power_levels: &UserPowerLevels,
     pinned_events: &[OwnedEventId],
     item_drawn_status: ItemDrawnStatus,
@@ -2973,7 +3160,7 @@ fn populate_message_view(
                         // Draw the profile up front here because we need the username for the emote body.
                         let (username, profile_drawn) = item.avatar(ids!(profile.avatar)).set_avatar_and_get_username(
                             cx,
-                            room_id,
+                            timeline_kind,
                             event_tl_item.sender(),
                             Some(event_tl_item.sender_profile()),
                             event_tl_item.event_id(),
@@ -3213,7 +3400,7 @@ fn populate_message_view(
                     cx,
                     &html_or_plaintext_ref,
                     event_tl_item,
-                    room_id,
+                    timeline_kind.room_id(),
                 );
                 (item, false)
             }
@@ -3234,49 +3421,68 @@ fn populate_message_view(
         }
     };
 
+    let timeline_event_id = event_tl_item.identifier();
+
     // If we didn't use a cached item, we need to draw all other message content:
-    // the reactions, the read receipts avatar row, and the reply preview.
-    // We also must set the message details/metadata for the `item` widget representing this message.
+    // the reactions, the read receipts avatar row, the reply preview.
     if !used_cached_item {
         item.reaction_list(ids!(content.reaction_list)).set_list(
             cx,
             event_tl_item.content().reactions(),
-            room_id.to_owned(),
-            event_tl_item.identifier(),
+            timeline_kind.clone(),
+            timeline_event_id.clone(),
             item_id,
         );
-        populate_read_receipts(&item, cx, room_id, event_tl_item);
-        let replied_to_message_view = item.view(ids!(replied_to_message));
-        let (is_reply_fully_drawn, replied_to_event_id) = draw_replied_to_message(
+        populate_read_receipts(&item, cx, timeline_kind, event_tl_item);
+        let is_reply_fully_drawn = draw_replied_to_message(
             cx,
-            &replied_to_message_view,
-            room_id,
+            &item.view(ids!(replied_to_message)),
+            timeline_kind,
             msg_like_content.in_reply_to.as_ref(),
             event_tl_item.event_id(),
         );
-
-        // Set the message details/metadata for the Message widget so that it can handle events.
-        let message_details = MessageDetails {
-            timeline_event_id: event_tl_item.identifier(),
+        let is_thread_summary_fully_drawn = populate_thread_root_summary(
+            cx,
+            &item,
             item_id,
-            related_event_id: replied_to_event_id,
-            room_screen_widget_uid,
-            abilities: MessageAbilities::from_user_power_and_event(
-                user_power_levels,
-                event_tl_item,
-                msg_like_content,
-                pinned_events,
-                has_html_body,
-            ),
-            should_be_highlighted: event_tl_item.is_highlighted(),
-        };
-        item.as_message().set_data(message_details);
+            timeline_kind,
+            msg_like_content,
+            event_tl_item,
+            fetched_thread_summaries,
+            pending_thread_summary_fetches,
+        );
 
         // The content is only considered to be fully drawn if the logic above marked it as such
-        // *and* if the reply preview was also fully drawn.
+        // *and* if the reply preview was also fully drawn
+        // *and* if the thread root summary (if applicable) was also fully drawn.
         new_drawn_status.content_drawn &= is_reply_fully_drawn;
+        new_drawn_status.content_drawn &= is_thread_summary_fully_drawn;
     }
 
+
+    // We must always re-set the message details, even when re-using a cached portallist item,
+    // because the item type might be the same but for a different message entirely.
+    let message_details = MessageDetails {
+        thread_root_event_id: msg_like_content.thread_root.clone().or_else(|| {
+            msg_like_content.thread_summary.as_ref()
+                .and_then(|_| event_tl_item.event_id().map(|id| id.to_owned()))
+        }),
+        timeline_event_id,
+        item_id,
+        related_event_id: msg_like_content.in_reply_to.as_ref().map(|r| r.event_id.clone()),
+        room_screen_widget_uid,
+        abilities: MessageAbilities::from_user_power_and_event(
+            user_power_levels,
+            event_tl_item,
+            msg_like_content,
+            pinned_events,
+            has_html_body,
+        ),
+        should_be_highlighted: event_tl_item.is_highlighted(),
+    };
+    item.as_message().set_data(message_details);
+
+
     // If `used_cached_item` is false, we should always redraw the profile, even if profile_drawn is true.
     let skip_draw_profile =
         use_compact_view || (used_cached_item && item_drawn_status.profile_drawn);
@@ -3291,7 +3497,7 @@ fn populate_message_view(
             let (username, profile_drawn) = set_username_and_get_avatar_retval.unwrap_or_else(||
                 item.avatar(ids!(profile.avatar)).set_avatar_and_get_username(
                     cx,
-                    room_id,
+                    timeline_kind,
                     event_tl_item.sender(),
                     Some(event_tl_item.sender_profile()),
                     event_tl_item.event_id(),
@@ -3792,6 +3998,7 @@ fn populate_redacted_message_content(
 ///
 /// ## Arguments
 /// * `replied_to_message_view`: the destination `RepliedToMessage` view that will be populated.
+/// * `timeline_kind`: the [`TimelineKind`] of the timeline that is being drawn.
 /// * `in_reply_to`: if `Some`, the details that will be used to populate the `replied_to_message_view`.
 ///   If `None`, this function will mark it as non-visible and consider it fully drawn.
 /// * `message_event_id`: the [`EventId`] of the message that is the reply itself (the response).
@@ -3802,18 +4009,15 @@ fn populate_redacted_message_content(
 fn draw_replied_to_message(
     cx: &mut Cx2d,
     replied_to_message_view: &ViewRef,
-    room_id: &OwnedRoomId,
+    timeline_kind: &TimelineKind,
     in_reply_to: Option<&InReplyToDetails>,
     message_event_id: Option<&EventId>,
-) -> (bool, Option<OwnedEventId>) {
+) -> bool {
     let fully_drawn: bool;
     let show_reply: bool;
-    let mut replied_to_event_id = None;
 
     if let Some(in_reply_to_details) = in_reply_to {
-        replied_to_event_id = Some(in_reply_to_details.event_id.to_owned());
         show_reply = true;
-
         match &in_reply_to_details.event {
             TimelineDetails::Ready(replied_to_event) => {
                 let (in_reply_to_username, is_avatar_fully_drawn) =
@@ -3821,7 +4025,7 @@ fn draw_replied_to_message(
                         .avatar(ids!(replied_to_message_content.reply_preview_avatar))
                         .set_avatar_and_get_username(
                             cx,
-                            room_id,
+                            timeline_kind,
                             &replied_to_event.sender,
                             Some(&replied_to_event.sender_profile),
                             Some(in_reply_to_details.event_id.as_ref()),
@@ -3854,7 +4058,7 @@ fn draw_replied_to_message(
                     .html_or_plaintext(ids!(replied_to_message_content.reply_preview_body))
                     .show_plaintext(cx, "[Error fetching replied-to event]");
             }
-            status @ TimelineDetails::Pending | status @ TimelineDetails::Unavailable => {
+            td @ TimelineDetails::Pending | td @ TimelineDetails::Unavailable => {
                 // We don't have the replied-to message yet, so we can't fully draw the preview.
                 fully_drawn = false;
                 replied_to_message_view
@@ -3869,10 +4073,10 @@ fn draw_replied_to_message(
 
                 // Confusingly, we need to fetch the details of the `message` (the event that is the reply),
                 // not the details of the original event that this `message` is replying to.
-                if matches!(status, TimelineDetails::Unavailable) {
+                if matches!(td, TimelineDetails::Unavailable) {
                     if let Some(event_id) = message_event_id {
                         submit_async_request(MatrixRequest::FetchDetailsForEvent {
-                            room_id: room_id.to_owned(),
+                            timeline_kind: timeline_kind.clone(),
                             event_id: event_id.to_owned(),
                         });
                     }
@@ -3886,7 +4090,102 @@ fn draw_replied_to_message(
     }
 
     replied_to_message_view.set_visible(cx, show_reply);
-    (fully_drawn, replied_to_event_id)
+    fully_drawn
+}
+
+/// Draws a one-line thread summary at the bottom of a message if it is the root of a thread.
+///
+/// Returns whether the thread summary information was available and fully drawn,
+/// i.e., whether it can be considered cached and not needing to be redrawn later.
+fn populate_thread_root_summary(
+    cx: &mut Cx2d,
+    item: &WidgetRef,
+    timeline_item_index: usize,
+    timeline_kind: &TimelineKind,
+    msg_like_content: &MsgLikeContent,
+    event_tl_item: &EventTimelineItem,
+    fetched_thread_summaries: &HashMap<OwnedEventId, FetchedThreadSummary>,
+    pending_thread_summary_fetches: &mut HashSet<OwnedEventId>,
+) -> bool {
+    let thread_summary_view = item.view(ids!(thread_root_summary));
+    thread_summary_view.set_visible(cx, false); // hide by default
+    let fully_drawn: bool;
+
+    if matches!(timeline_kind, TimelineKind::Thread { .. }) {
+        // If we're already drawing a message in a thread-focused timeline,
+        // it doesn't make sense to show a redundant thread summary.
+        fully_drawn = true;
+        return fully_drawn;
+    }
+
+    let Some(thread_summary) = msg_like_content.thread_summary.as_ref() else {
+        // consider this as fully drawn since there's no thread summary to show.
+        fully_drawn = true;
+        return fully_drawn;
+    };
+
+    // Here, we actually need to show the thread summary.
+    thread_summary_view.set_visible(cx, true);
+    let local_num_replies = thread_summary.num_replies;
+    let thread_root_event_id = event_tl_item.event_id().map(|id| id.to_owned());
+    let fetched_summary = thread_root_event_id
+        .as_ref()
+        .and_then(|root_id| fetched_thread_summaries.get(root_id));
+    let replies_count = fetched_summary
+        .map(|f| f.num_replies)
+        .unwrap_or(local_num_replies);
+
+    let latest_preview: Cow<str> = match &thread_summary.latest_event {
+        TimelineDetails::Ready(embedded_event) => {
+            fully_drawn = true;
+            let sender_username = match &embedded_event.sender_profile {
+                TimelineDetails::Ready(profile) => profile
+                    .display_name
+                    .as_deref()
+                    .unwrap_or(embedded_event.sender.as_str()),
+                _ => embedded_event.sender.as_str(),
+            };
+            let preview = text_preview_of_timeline_item(
+                &embedded_event.content,
+                &embedded_event.sender,
+                sender_username,
+            ).format_with(sender_username, true);
+            utils::replace_linebreaks_separators(&preview).into()
+        }
+        td @ TimelineDetails::Pending | td @ TimelineDetails::Unavailable => {
+            fully_drawn = true;
+            if td.is_unavailable()
+                && let Some(thread_root_event_id) = thread_root_event_id.clone()
+            {
+                let needs_refresh = fetched_summary
+                    .is_none_or(|fs| fs.latest_reply_preview_text.is_none());
+                if needs_refresh && pending_thread_summary_fetches.insert(thread_root_event_id.clone()) {
+                    submit_async_request(MatrixRequest::FetchThreadSummaryDetails {
+                        timeline_kind: timeline_kind.clone(),
+                        thread_root_event_id,
+                        timeline_item_index,
+                    });
+                }
+            }
+            fetched_summary.and_then(|fs| fs.latest_reply_preview_text.as_deref())
+                .unwrap_or("<i>Loading latest reply...</i>")
+                .into()
+        }
+        TimelineDetails::Error(_) => {
+            fully_drawn = true; // consider this fully drawn since there's no point retrying.
+            "<i>Unable to load latest reply</i>".into()
+        }
+    };
+
+    let replies_count_text = match replies_count {
+        1 => Cow::Borrowed("1 reply"),
+        n => Cow::Owned(format!("{n} replies"))
+    };
+    item.label(ids!(thread_summary_count))
+        .set_text(cx, &replies_count_text);
+    item.html(ids!(thread_summary_latest))
+        .set_text(cx, &latest_preview);
+    fully_drawn
 }
 
 /// Generates a rich HTML text preview of the given `timeline_item_content`
@@ -4105,7 +4404,7 @@ fn populate_small_state_event(
     cx: &mut Cx,
     list: &mut PortalList,
     item_id: usize,
-    room_id: &OwnedRoomId,
+    timeline_kind: &TimelineKind,
     event_tl_item: &EventTimelineItem,
     event_content: &impl SmallStateEventContent,
     item_drawn_status: ItemDrawnStatus,
@@ -4116,7 +4415,7 @@ fn populate_small_state_event(
     // so we can only mark the content as drawn after the profile has been fully drawn and cached.
     let skip_redrawing_profile = existed && item_drawn_status.profile_drawn;
     let skip_redrawing_content = skip_redrawing_profile && item_drawn_status.content_drawn;
-    populate_read_receipts(&item, cx, room_id, event_tl_item);
+    populate_read_receipts(&item, cx, timeline_kind, event_tl_item);
     if skip_redrawing_content {
         return (item, new_drawn_status);
     }
@@ -4133,7 +4432,7 @@ fn populate_small_state_event(
 
         let (username, profile_drawn) = avatar_ref.set_avatar_and_get_username(
             cx,
-            room_id,
+            timeline_kind,
             event_tl_item.sender(),
             Some(event_tl_item.sender_profile()),
             event_tl_item.event_id(),
@@ -4237,6 +4536,8 @@ pub enum MessageAction {
     /// indicating that they want to auto-scroll back to the related message,
     /// e.g., a replied-to message.
     JumpToRelated(MessageDetails),
+    /// The user clicked the thread summary on a thread-root message.
+    OpenThread(OwnedEventId),
     /// The user requested to jump to a specific event in this room.
     JumpToEvent(OwnedEventId),
     /// The user clicked the "delete" button on a message.
@@ -4331,6 +4632,60 @@ impl Widget for Message {
             _ => { }
         }
 
+        // Handle clicks on the thread summary shown beneath a thread-root message.
+        if let Some(thread_root_event_id) = details.thread_root_event_id.as_ref() {
+            let thread_root_summary = self.view(ids!(thread_root_summary));
+            let apply_hover = |cx: &mut Cx, bg_color: Vec4| {
+                thread_root_summary.apply_over(cx, live! {
+                    draw_bg: {
+                        color: (bg_color)
+                    }
+                });
+            };
+            match event.hits(cx, thread_root_summary.area()) {
+                Hit::FingerDown(fe) => {
+                    apply_hover(cx, COLOR_THREAD_SUMMARY_BG_HOVER);
+                    if fe.device.mouse_button().is_some_and(|b| b.is_secondary()) {
+                        cx.widget_action(
+                            details.room_screen_widget_uid,
+                            &scope.path,
+                            MessageAction::OpenMessageContextMenu {
+                                details: details.clone(),
+                                abs_pos: fe.abs,
+                            }
+                        );
+                    }
+                }
+                Hit::FingerHoverIn(_) => {
+                    apply_hover(cx, COLOR_THREAD_SUMMARY_BG_HOVER);
+                }
+                Hit::FingerHoverOut(_) => {
+                    apply_hover(cx, COLOR_THREAD_SUMMARY_BG);
+                }
+                Hit::FingerLongPress(lp) => {
+                    cx.widget_action(
+                        details.room_screen_widget_uid,
+                        &scope.path,
+                        MessageAction::OpenMessageContextMenu {
+                            details: details.clone(),
+                            abs_pos: lp.abs,
+                        }
+                    );
+                }
+                Hit::FingerUp(fe) => {
+                    apply_hover(cx, COLOR_THREAD_SUMMARY_BG);
+                    if fe.is_over && fe.is_primary_hit() && fe.was_tap() {
+                        cx.widget_action(
+                            details.room_screen_widget_uid,
+                            &scope.path,
+                            MessageAction::OpenThread(thread_root_event_id.clone()),
+                        );
+                    }
+                }
+                _ => { }
+            }
+        }
+
         // Next, we forward the event to the child view such that it has the chance
         // to handle it before the Message widget handles it.
         // This ensures that events like right-clicking/long-pressing a reaction button
diff --git a/src/home/rooms_list.rs b/src/home/rooms_list.rs
index a0f2f37d..f097acbd 100644
--- a/src/home/rooms_list.rs
+++ b/src/home/rooms_list.rs
@@ -38,7 +38,7 @@ use crate::{
         popup_list::{PopupKind, enqueue_popup_notification},
         room_filter_input_bar::RoomFilterAction,
     },
-    sliding_sync::{MatrixLinkAction, MatrixRequest, PaginationDirection, submit_async_request},
+    sliding_sync::{MatrixLinkAction, MatrixRequest, PaginationDirection, TimelineKind, submit_async_request},
     space_service_sync::{ParentChain, SpaceRequest, SpaceRoomListAction}, utils::{RoomNameId, VecDiff},
 };
 
@@ -238,18 +238,21 @@ pub fn enqueue_rooms_list_update(update: RoomsListUpdate) {
     SignalToUI::set_ui_signal();
 }
 
-/// Actions emitted by the RoomsList widget.
+/// Actions related to a single room in the RoomsList widget.
 #[derive(Debug, Clone, DefaultNone)]
 pub enum RoomsListAction {
     /// A new room or space was selected.
     Selected(SelectedRoom),
     /// A new room was joined from an accepted invite,
     /// meaning that the existing `InviteScreen` should be converted
-    /// to a `RoomScreen` to display now-joined room.
+    /// to a `RoomScreen` to display the now-joined room.
     InviteAccepted {
         room_name_id: RoomNameId,
     },
-    /// Open the room context menu for the given room.
+    /// Instructs the top-level app to show the context menu for the given room.
+    ///
+    /// Emitted by the RoomsList when the user right-clicks or long-presses
+    /// on a room in the rooms list.
     OpenRoomContextMenu {
         details: RoomContextMenuDetails,
         pos: DVec2,
@@ -452,8 +455,8 @@ pub struct RoomsList {
     /// The latest status message that should be displayed in the bottom status label.
     #[rust] status: String,
 
-    /// The ID of the currently-selected room.
-    #[rust] current_active_room: Option<OwnedRoomId>,
+    /// The currently-selected room.
+    #[rust] current_active_room: Option<SelectedRoom>,
 
     /// The maximum number of rooms that will ever be loaded.
     ///
@@ -1202,7 +1205,7 @@ impl Widget for RoomsList {
                     continue;
                 };
 
-                self.current_active_room = Some(room_id.clone());
+                self.current_active_room = Some(new_selected_room.clone());
                 cx.widget_action(
                     self.widget_uid(),
                     &scope.path,
@@ -1232,8 +1235,8 @@ impl Widget for RoomsList {
             // Handle the space lobby being clicked.
             else if let Some(SpaceLobbyAction::SpaceLobbyEntryClicked) = action.downcast_ref() {
                 let Some(space_name_id) = self.selected_space.clone() else { continue };
-                self.current_active_room = Some(space_name_id.room_id().clone());
                 let new_selected_space = SelectedRoom::Space { space_name_id };
+                self.current_active_room = Some(new_selected_space.clone());
                 cx.widget_action(
                     self.widget_uid(),
                     &scope.path,
@@ -1361,8 +1364,7 @@ impl Widget for RoomsList {
     fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
         let app_state = scope.data.get_mut::<AppState>().unwrap();
         // Update the currently-selected room from the AppState data.
-        self.current_active_room = app_state.selected_room.as_ref()
-            .map(|sel_room| sel_room.room_id().clone());
+        self.current_active_room = app_state.selected_room.clone();
 
         // Based on the various displayed room lists and is_expanded state of each room header,
         // calculate the indexes in the PortalList where the headers and rooms should be drawn.
@@ -1424,8 +1426,8 @@ impl Widget for RoomsList {
                     let mut invited_rooms_mut = self.invited_rooms.borrow_mut();
                     if let Some(invited_room) = invited_rooms_mut.get_mut(invited_room_id) {
                         let item = list.item(cx, portal_list_index, id!(rooms_list_entry));
-                        invited_room.is_selected =
-                            self.current_active_room.as_deref() == Some(invited_room_id);
+                        invited_room.is_selected = self.current_active_room.as_ref()
+                            .is_some_and(|sel_room| sel_room.room_id() == invited_room_id);
                         // Pass the room info down to the RoomsListEntry widget via Scope.
                         scope = Scope::with_props(&*invited_room);
                         item.draw_all(cx, &mut scope);
@@ -1449,14 +1451,16 @@ impl Widget for RoomsList {
                 else if let Some(direct_room_id) = get_direct_room_id(portal_list_index) {
                     if let Some(direct_room) = self.all_joined_rooms.get_mut(direct_room_id) {
                         let item = list.item(cx, portal_list_index, id!(rooms_list_entry));
-                        direct_room.is_selected =
-                            self.current_active_room.as_ref() == Some(direct_room_id);
+                        direct_room.is_selected = self.current_active_room.as_ref()
+                            .is_some_and(|sel_room| sel_room.room_id() == direct_room_id);
 
                         // Paginate the room if it hasn't been paginated yet.
                         if PREPAGINATE_VISIBLE_ROOMS && !direct_room.has_been_paginated {
                             direct_room.has_been_paginated = true;
-                            submit_async_request(MatrixRequest::PaginateRoomTimeline {
-                                room_id: direct_room.room_name_id.room_id().clone(),
+                            submit_async_request(MatrixRequest::PaginateTimeline {
+                                timeline_kind: TimelineKind::MainRoom {
+                                    room_id: direct_room.room_name_id.room_id().clone(),
+                                },
                                 num_events: 50,
                                 direction: PaginationDirection::Backwards,
                             });
@@ -1484,14 +1488,16 @@ impl Widget for RoomsList {
                 else if let Some(regular_room_id) = get_regular_room_id(portal_list_index) {
                     if let Some(regular_room) = self.all_joined_rooms.get_mut(regular_room_id) {
                         let item = list.item(cx, portal_list_index, id!(rooms_list_entry));
-                        regular_room.is_selected =
-                            self.current_active_room.as_ref() == Some(regular_room_id);
+                        regular_room.is_selected = self.current_active_room.as_ref()
+                            .is_some_and(|sel_room| sel_room.room_id() == regular_room_id);
 
                         // Paginate the room if it hasn't been paginated yet.
                         if PREPAGINATE_VISIBLE_ROOMS && !regular_room.has_been_paginated {
                             regular_room.has_been_paginated = true;
-                            submit_async_request(MatrixRequest::PaginateRoomTimeline {
-                                room_id: regular_room.room_name_id.room_id().clone(),
+                            submit_async_request(MatrixRequest::PaginateTimeline {
+                                timeline_kind: TimelineKind::MainRoom {
+                                    room_id: regular_room.room_name_id.room_id().clone(),
+                                },
                                 num_events: 50,
                                 direction: PaginationDirection::Backwards,
                             });
diff --git a/src/persistence/matrix_state.rs b/src/persistence/matrix_state.rs
index e08d9813..43ad081c 100644
--- a/src/persistence/matrix_state.rs
+++ b/src/persistence/matrix_state.rs
@@ -171,6 +171,9 @@ pub async fn restore_session(
     let client = Client::builder()
         .homeserver_url(client_session.homeserver)
         .sqlite_store(client_session.db_path, Some(&client_session.passphrase))
+        .with_threading_support(matrix_sdk::ThreadingSupport::Enabled {
+            with_subscriptions: true,
+        })
         .handle_refresh_tokens()
         .build()
         .await?;
diff --git a/src/profile/user_profile.rs b/src/profile/user_profile.rs
index 91becdc8..1cdb78b0 100644
--- a/src/profile/user_profile.rs
+++ b/src/profile/user_profile.rs
@@ -105,7 +105,8 @@ live_design! {
             }
 
             user_name = <Label> {
-                width: Fit, height: Fit
+                width: Fill, height: Fit
+                align: {x: 0.5}
                 draw_text: {
                     wrap: Word,
                     color: #000,
@@ -115,7 +116,8 @@ live_design! {
             }
 
             user_id = <Label> {
-                width: Fit, height: Fit
+                width: Fill, height: Fit
+                align: {x: 0.5}
                 draw_text: {
                     wrap: Line,
                     color: (MESSAGE_TEXT_COLOR),
diff --git a/src/room/room_input_bar.rs b/src/room/room_input_bar.rs
index ab42c8aa..5260f71b 100644
--- a/src/room/room_input_bar.rs
+++ b/src/room/room_input_bar.rs
@@ -19,8 +19,8 @@
 use makepad_widgets::*;
 use matrix_sdk::room::reply::{EnforceThread, Reply};
 use matrix_sdk_ui::timeline::{EmbeddedEvent, EventTimelineItem, TimelineEventItemId};
-use ruma::{events::room::message::{LocationMessageEventContent, MessageType, RoomMessageEventContent}, OwnedRoomId};
-use crate::{home::{editing_pane::{EditingPaneState, EditingPaneWidgetExt}, location_preview::LocationPreviewWidgetExt, room_screen::{populate_preview_of_timeline_item, MessageAction, RoomScreenProps}, tombstone_footer::{SuccessorRoomDetails, TombstoneFooterWidgetExt}}, location::init_location_subscriber, shared::{avatar::AvatarWidgetRefExt, html_or_plaintext::HtmlOrPlaintextWidgetRefExt, mentionable_text_input::MentionableTextInputWidgetExt, popup_list::{enqueue_popup_notification, PopupKind}, styles::*}, sliding_sync::{submit_async_request, MatrixRequest, UserPowerLevels}, utils};
+use ruma::{events::room::message::{LocationMessageEventContent, MessageType, ReplyWithinThread, RoomMessageEventContent}, OwnedRoomId};
+use crate::{home::{editing_pane::{EditingPaneState, EditingPaneWidgetExt}, location_preview::LocationPreviewWidgetExt, room_screen::{populate_preview_of_timeline_item, MessageAction, RoomScreenProps}, tombstone_footer::{SuccessorRoomDetails, TombstoneFooterWidgetExt}}, location::init_location_subscriber, shared::{avatar::AvatarWidgetRefExt, html_or_plaintext::HtmlOrPlaintextWidgetRefExt, mentionable_text_input::MentionableTextInputWidgetExt, popup_list::{enqueue_popup_notification, PopupKind}, styles::*}, sliding_sync::{submit_async_request, MatrixRequest, TimelineKind, UserPowerLevels}, utils};
 
 live_design! {
     use link::theme::*;
@@ -264,17 +264,30 @@ impl RoomInputBar {
                         LocationMessageEventContent::new(geo_uri.clone(), geo_uri)
                     )
                 );
+                let replied_to = self.replying_to.take().and_then(|(event_tl_item, _emb)|
+                    event_tl_item.event_id().map(|event_id| {
+                        let enforce_thread = if room_screen_props.timeline_kind.thread_root_event_id().is_some() {
+                            EnforceThread::Threaded(ReplyWithinThread::Yes)
+                        } else {
+                            EnforceThread::MaybeThreaded
+                        };
+                        Reply {
+                            event_id: event_id.to_owned(),
+                            enforce_thread,
+                        }
+                    })
+                ).or_else(||
+                    room_screen_props.timeline_kind.thread_root_event_id().map(|thread_root_event_id|
+                        Reply {
+                            event_id: thread_root_event_id.clone(),
+                            enforce_thread: EnforceThread::Threaded(ReplyWithinThread::No),
+                        }
+                    )
+                );
                 submit_async_request(MatrixRequest::SendMessage {
-                    room_id: room_screen_props.room_name_id.room_id().clone(),
+                    timeline_kind: room_screen_props.timeline_kind.clone(),
                     message,
-                    replied_to: self.replying_to.take().and_then(|(event_tl_item, _emb)|
-                        event_tl_item.event_id().map(|event_id|
-                            Reply {
-                                event_id: event_id.to_owned(),
-                                enforce_thread: EnforceThread::MaybeThreaded,
-                            }
-                        )
-                    ),
+                    replied_to,
                     #[cfg(feature = "tsp")]
                     sign_with_tsp: self.is_tsp_signing_enabled(cx),
                 });
@@ -292,17 +305,30 @@ impl RoomInputBar {
             let entered_text = mentionable_text_input.text().trim().to_string();
             if !entered_text.is_empty() {
                 let message = mentionable_text_input.create_message_with_mentions(&entered_text);
+                let replied_to = self.replying_to.take().and_then(|(event_tl_item, _emb)|
+                    event_tl_item.event_id().map(|event_id| {
+                        let enforce_thread = if room_screen_props.timeline_kind.thread_root_event_id().is_some() {
+                            EnforceThread::Threaded(ReplyWithinThread::Yes)
+                        } else {
+                            EnforceThread::MaybeThreaded
+                        };
+                        Reply {
+                            event_id: event_id.to_owned(),
+                            enforce_thread,
+                        }
+                    })
+                ).or_else(||
+                    room_screen_props.timeline_kind.thread_root_event_id().map(|thread_root_event_id|
+                        Reply {
+                            event_id: thread_root_event_id.clone(),
+                            enforce_thread: EnforceThread::Threaded(ReplyWithinThread::No),
+                        }
+                    )
+                );
                 submit_async_request(MatrixRequest::SendMessage {
-                    room_id: room_screen_props.room_name_id.room_id().clone(),
+                    timeline_kind: room_screen_props.timeline_kind.clone(),
                     message,
-                    replied_to: self.replying_to.take().and_then(|(event_tl_item, _emb)|
-                        event_tl_item.event_id().map(|event_id|
-                            Reply {
-                                event_id: event_id.to_owned(),
-                                enforce_thread: EnforceThread::MaybeThreaded,
-                            }
-                        )
-                    ),
+                    replied_to,
                     #[cfg(feature = "tsp")]
                     sign_with_tsp: self.is_tsp_signing_enabled(cx),
                 });
@@ -318,7 +344,7 @@ impl RoomInputBar {
         let is_text_input_empty = if let Some(new_text) = text_input.changed(actions) {
             let is_empty = new_text.is_empty();
             submit_async_request(MatrixRequest::SendTypingNotice {
-                room_id: room_screen_props.room_name_id.room_id().clone(),
+                room_id: room_screen_props.timeline_kind.room_id().clone(),
                 typing: !is_empty,
             });
             is_empty
@@ -358,7 +384,7 @@ impl RoomInputBar {
         &mut self,
         cx: &mut Cx,
         replying_to: (EventTimelineItem, EmbeddedEvent),
-        room_id: &OwnedRoomId,
+        timeline_kind: &TimelineKind,
         grab_key_focus: bool,
     ) {
         // When the user clicks the reply button next to a message, we need to:
@@ -368,7 +394,7 @@ impl RoomInputBar {
             .avatar(ids!(reply_preview_content.reply_preview_avatar))
             .set_avatar_and_get_username(
                 cx,
-                room_id,
+                timeline_kind,
                 replying_to.0.sender(),
                 Some(replying_to.0.sender_profile()),
                 replying_to.0.event_id(),
@@ -415,7 +441,7 @@ impl RoomInputBar {
         &mut self,
         cx: &mut Cx,
         behavior: ShowEditingPaneBehavior,
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
     ) {
         // We must hide the input_bar while the editing pane is shown,
         // otherwise a very-tall inputted message might show up underneath a shorter editing pane.
@@ -432,10 +458,10 @@ impl RoomInputBar {
         let editing_pane = self.view.editing_pane(ids!(editing_pane));
         match behavior {
             ShowEditingPaneBehavior::ShowNew { event_tl_item } => {
-                editing_pane.show(cx, event_tl_item, room_id);
+                editing_pane.show(cx, event_tl_item, timeline_kind);
             }
             ShowEditingPaneBehavior::RestoreExisting { editing_pane_state } => {
-                editing_pane.restore_state(cx, editing_pane_state, room_id);
+                editing_pane.restore_state(cx, editing_pane_state, timeline_kind);
             }
         };
 
@@ -529,10 +555,10 @@ impl RoomInputBarRef {
         &self,
         cx: &mut Cx,
         replying_to: (EventTimelineItem, EmbeddedEvent),
-        room_id: &OwnedRoomId,
+        timeline_kind: &TimelineKind,
     ) {
         let Some(mut inner) = self.borrow_mut() else { return };
-        inner.show_replying_to(cx, replying_to, room_id, true);
+        inner.show_replying_to(cx, replying_to, timeline_kind, true);
     }
 
     /// Shows the editing pane to allow the user to edit the given event.
@@ -540,13 +566,13 @@ impl RoomInputBarRef {
         &self,
         cx: &mut Cx,
         event_tl_item: EventTimelineItem,
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
     ) {
         let Some(mut inner) = self.borrow_mut() else { return };
         inner.show_editing_pane(
             cx,
             ShowEditingPaneBehavior::ShowNew { event_tl_item },
-            room_id,
+            timeline_kind,
         );
     }
 
@@ -604,7 +630,7 @@ impl RoomInputBarRef {
     pub fn restore_state(
         &self,
         cx: &mut Cx,
-        room_id: &OwnedRoomId,
+        timeline_kind: TimelineKind,
         saved_state: RoomInputBarState,
         user_power_levels: UserPowerLevels,
         tombstone_info: Option<&SuccessorRoomDetails>,
@@ -630,7 +656,7 @@ impl RoomInputBarRef {
 
         // 2. Restore the state of the replying-to preview.
         if let Some(replying_to) = replying_to {
-            inner.show_replying_to(cx, replying_to, room_id, false);
+            inner.show_replying_to(cx, replying_to, &timeline_kind, false);
         } else {
             inner.clear_replying_to(cx);
         }
@@ -641,7 +667,7 @@ impl RoomInputBarRef {
             inner.show_editing_pane(
                 cx,
                 ShowEditingPaneBehavior::RestoreExisting { editing_pane_state },
-                room_id.clone(),
+                timeline_kind.clone(),
             );
         } else {
             inner.editing_pane(ids!(editing_pane)).force_reset_hide(cx);
@@ -650,7 +676,7 @@ impl RoomInputBarRef {
 
         // 4. Restore the state of the tombstone footer.
         //    This depends on the `EditingPane` state, so it must be done after Step 3.
-        inner.update_tombstone_footer(cx, room_id, tombstone_info);
+        inner.update_tombstone_footer(cx, timeline_kind.room_id(), tombstone_info);
     }
 }
 
diff --git a/src/shared/avatar.rs b/src/shared/avatar.rs
index b08985db..6d7e5778 100644
--- a/src/shared/avatar.rs
+++ b/src/shared/avatar.rs
@@ -9,12 +9,15 @@
 use std::sync::Arc;
 
 use makepad_widgets::*;
-use matrix_sdk::{ruma::{EventId, OwnedRoomId, OwnedUserId, RoomId, UserId}};
+use matrix_sdk::{ruma::{EventId, OwnedRoomId, OwnedUserId, UserId}};
 use matrix_sdk_ui::timeline::{Profile, TimelineDetails};
 use ruma::OwnedMxcUri;
 
 use crate::{
-    avatar_cache::{self, AvatarCacheEntry}, profile::{user_profile::{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, TimelineKind},
+    utils,
 };
 
 live_design! {
@@ -234,7 +237,7 @@ impl Avatar {
     ///
     /// If the user profile is not ready, this function will submit an async request
     /// to fetch the user profile from the server, but only if the event ID is `Some`.
-    /// For Read Receipt cases, there is no user's profile. The Avatar cache is taken from the sender's profile
+    /// For Read Receipt cases, there is no user profile. The Avatar cache is taken from the sender's profile
     ///
     /// This function will always choose a nice, displayable username and avatar.
     ///
@@ -260,7 +263,7 @@ impl Avatar {
     pub fn set_avatar_and_get_username(
         &mut self,
         cx: &mut Cx,
-        room_id: &RoomId,
+        timeline_kind: &TimelineKind,
         avatar_user_id: &UserId,
         avatar_profile_opt: Option<&TimelineDetails<Profile>>,
         event_id: Option<&EventId>,
@@ -272,10 +275,10 @@ impl Avatar {
             user_profile_cache::with_user_profile(
                 cx,
                 avatar_user_id.to_owned(),
-                Some(&room_id.to_owned()),
+                Some(timeline_kind.room_id()),
                 true,
                 |profile, rooms| {
-                    rooms.get(room_id).map(|rm| {
+                    rooms.get(timeline_kind.room_id()).map(|rm| {
                         (
                             rm.display_name().map(|n| n.to_owned()),
                             AvatarState::Known(rm.avatar_url().map(|u| u.to_owned())),
@@ -296,7 +299,7 @@ impl Avatar {
             Some(TimelineDetails::Unavailable) => {
                 if let Some(event_id) = event_id {
                     submit_async_request(MatrixRequest::FetchDetailsForEvent {
-                        room_id: room_id.to_owned(),
+                        timeline_kind: timeline_kind.clone(),
                         event_id: event_id.to_owned(),
                     });
                 }
@@ -332,7 +335,7 @@ impl Avatar {
                     is_clickable.then(|| AvatarImageInfo::from((
                         avatar_user_id.to_owned(),
                         username_opt.clone(),
-                        room_id.to_owned(),
+                        timeline_kind.room_id().to_owned(),
                         data.clone()
                     ))),
                     |cx, img| utils::load_png_or_jpg(&img, cx, &data),
@@ -346,7 +349,7 @@ impl Avatar {
                     is_clickable.then(|| AvatarTextInfo::from((
                         avatar_user_id.to_owned(),
                         username_opt,
-                        room_id.to_owned(),
+                        timeline_kind.room_id().to_owned(),
                     ))),
                     &username,
                 )
@@ -398,7 +401,7 @@ impl AvatarRef {
     pub fn set_avatar_and_get_username(
         &self,
         cx: &mut Cx,
-        room_id: &RoomId,
+        timeline_kind: &TimelineKind,
         avatar_user_id: &UserId,
         avatar_profile_opt: Option<&TimelineDetails<Profile>>,
         event_id: Option<&EventId>,
@@ -407,7 +410,7 @@ impl AvatarRef {
         if let Some(mut inner) = self.borrow_mut() {
             inner.set_avatar_and_get_username(
                 cx,
-                room_id,
+                timeline_kind,
                 avatar_user_id,
                 avatar_profile_opt,
                 event_id,
diff --git a/src/shared/image_viewer.rs b/src/shared/image_viewer.rs
index ade4b52e..caf9fc0a 100644
--- a/src/shared/image_viewer.rs
+++ b/src/shared/image_viewer.rs
@@ -11,10 +11,9 @@ use makepad_widgets::{
     rotated_image::RotatedImageWidgetExt,
     *,
 };
-use matrix_sdk::ruma::OwnedRoomId;
 use matrix_sdk_ui::timeline::EventTimelineItem;
 use thiserror::Error;
-use crate::shared::{avatar::AvatarWidgetExt, timestamp::TimestampWidgetRefExt};
+use crate::{shared::{avatar::AvatarWidgetExt, timestamp::TimestampWidgetRefExt}, sliding_sync::TimelineKind};
 
 /// The timeout for hiding the UI overlays after no user mouse/tap activity.
 const SHOW_UI_DURATION: f64 = 3.0;
@@ -1084,10 +1083,10 @@ impl ImageViewer {
                 .set_date_time(cx, timestamp);
         }
 
-        if let Some((room_id, event_timeline_item)) = &metadata.avatar_parameter {            
+        if let Some((timeline_kind, event_timeline_item)) = &metadata.avatar_parameter {
             let (sender, _) = self.view.avatar(ids!(user_profile_view.avatar)).set_avatar_and_get_username(
                 cx,
-                room_id,
+                timeline_kind,
                 event_timeline_item.sender(),
                 Some(event_timeline_item.sender_profile()),
                 event_timeline_item.event_id(),
@@ -1172,9 +1171,9 @@ pub enum LoadState {
 #[derive(Debug, Clone)]
 /// Metadata for an image.
 pub struct ImageViewerMetaData {
-    // Optional avatar parameter containing room ID and event timeline item
-    // to be used for the avatar.
-    pub avatar_parameter: Option<(OwnedRoomId, EventTimelineItem)>,
+    // Optional avatar parameter containing info about the timeline
+    // and the event to be used for the avatar.
+    pub avatar_parameter: Option<(TimelineKind, EventTimelineItem)>,
     pub timestamp: Option<DateTime<Local>>,
     pub image_name: String,
     // Image size in bytes
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 3932fad0..2db3d2cb 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -8,36 +8,37 @@ use imbl::Vector;
 use makepad_widgets::{error, log, warning, Cx, SignalToUI};
 use matrix_sdk_base::crypto::{DecryptionSettings, TrustRequirement};
 use matrix_sdk::{
-    config::RequestConfig, encryption::EncryptionSettings, event_handler::EventHandlerDropGuard, media::MediaRequestParameters, room::{edit::EditedContent, reply::Reply, RoomMember}, ruma::{
-        api::client::{profile::{AvatarUrl, DisplayName}, receipt::create_receipt::v3::ReceiptType}, events::{
+    config::RequestConfig, encryption::EncryptionSettings, event_handler::EventHandlerDropGuard, media::MediaRequestParameters, room::{edit::EditedContent, reply::Reply, IncludeRelations, RelationsOptions, RoomMember}, ruma::{
+        api::{Direction, client::{profile::{AvatarUrl, DisplayName}, receipt::create_receipt::v3::ReceiptType}}, events::{
+            relation::RelationType,
             room::{
                 message::RoomMessageEventContent, power_levels::RoomPowerLevels, MediaSource
             }, MessageLikeEventType, StateEventType
-        }, matrix_uri::MatrixId, MatrixToUri, MatrixUri, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId, OwnedUserId, RoomOrAliasId, UserId
+        }, matrix_uri::MatrixId, EventId, MatrixToUri, MatrixUri, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId, OwnedUserId, RoomOrAliasId, UserId, uint
     }, sliding_sync::VersionBuilder, Client, ClientBuildError, Error, OwnedServerName, Room, RoomDisplayName, RoomMemberships, RoomState, SuccessorRoom
 };
 use matrix_sdk_ui::{
-    RoomListService, Timeline, room_list_service::{RoomListItem, RoomListLoadingState, SyncIndicator, filters}, sync_service::{self, SyncService}, timeline::{LatestEventValue, RoomExt, TimelineEventItemId, TimelineItem, TimelineReadReceiptTracking, TimelineDetails}
+    RoomListService, Timeline, room_list_service::{RoomListItem, RoomListLoadingState, SyncIndicator, filters}, sync_service::{self, SyncService}, timeline::{LatestEventValue, RoomExt, TimelineEventItemId, TimelineFocus, TimelineItem, TimelineReadReceiptTracking, TimelineDetails}
 };
 use robius_open::Uri;
-use ruma::{OwnedRoomOrAliasId, events::tag::Tags};
+use ruma::{OwnedRoomOrAliasId, RoomId, events::tag::Tags};
 use tokio::{
     runtime::Handle,
     sync::{mpsc::{Sender, UnboundedReceiver, UnboundedSender}, watch, Notify}, task::JoinHandle, time::error::Elapsed,
 };
 use url::Url;
-use std::{cmp::{max, min}, future::Future, hash::{BuildHasherDefault, DefaultHasher}, iter::Peekable, ops::{Deref, Not}, path:: Path, sync::{Arc, LazyLock, Mutex}, time::Duration};
+use std::{cmp::{max, min}, future::Future, hash::{BuildHasherDefault, DefaultHasher}, iter::Peekable, ops::{Deref, DerefMut, Not}, path:: Path, sync::{Arc, LazyLock, Mutex}, time::Duration};
 use std::io;
 use hashbrown::{HashMap, HashSet};
 use crate::{
-    app::AppStateAction, app_data_dir, avatar_cache::AvatarUpdate, event_preview::text_preview_of_timeline_item, home::{
+    app::AppStateAction, app_data_dir, avatar_cache::AvatarUpdate, event_preview::{BeforeText, TextPreview, text_preview_of_raw_timeline_event, text_preview_of_timeline_item}, home::{
         add_room::KnockResultAction, invite_screen::{JoinRoomResultAction, LeaveRoomResultAction}, link_preview::{LinkPreviewData, LinkPreviewDataNonNumeric, LinkPreviewRateLimitResponse}, room_screen::{InviteResultAction, 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::UserProfile,
         user_profile_cache::{UserProfileUpdate, enqueue_user_profile_update},
     }, room::{FetchedRoomAvatar, FetchedRoomPreview, RoomPreviewAction}, shared::{
         avatar::AvatarState, html_or_plaintext::MatrixLinkPillState, jump_to_bottom_button::UnreadMessageCount, popup_list::{PopupKind, enqueue_popup_notification}
-    }, space_service_sync::space_service_loop, utils::{self, AVATAR_THUMBNAIL_FORMAT, RoomNameId, avatar_from_room_name, VecDiff}, verification::add_verification_event_handlers_and_sync_client
+    }, space_service_sync::space_service_loop, utils::{self, AVATAR_THUMBNAIL_FORMAT, RoomNameId, VecDiff, avatar_from_room_name}, verification::add_verification_event_handlers_and_sync_client
 };
 
 #[derive(Parser, Debug, Default)]
@@ -109,6 +110,9 @@ async fn build_client(
         .server_name_or_homeserver_url(homeserver_url)
         // Use a sqlite database to persist the client's encryption setup.
         .sqlite_store(&db_path, Some(&passphrase))
+        .with_threading_support(matrix_sdk::ThreadingSupport::Enabled {
+            with_subscriptions: true,
+        })
         // The sliding sync proxy has now been deprecated in favor of native sliding sync.
         .sliding_sync_version_builder(VersionBuilder::DiscoverNative)
         .with_decryption_settings(DecryptionSettings {
@@ -315,37 +319,90 @@ pub enum DirectMessageRoomAction {
     },
 }
 
+/// Either a main room timeline or a thread-focused timeline.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum TimelineKind {
+    MainRoom {
+        room_id: OwnedRoomId,
+    },
+    Thread {
+        room_id: OwnedRoomId,
+        thread_root_event_id: OwnedEventId,
+    },
+}
+impl TimelineKind {
+    pub fn room_id(&self) -> &OwnedRoomId {
+        match self {
+            TimelineKind::MainRoom { room_id } => room_id,
+            TimelineKind::Thread { room_id, .. } => room_id,
+        }
+    }
+
+    pub fn thread_root_event_id(&self) -> Option<&OwnedEventId> {
+        match self {
+            TimelineKind::MainRoom { .. } => None,
+            TimelineKind::Thread { thread_root_event_id, .. } => Some(thread_root_event_id),
+        }
+    }
+}
+impl std::fmt::Display for TimelineKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TimelineKind::MainRoom { room_id } => write!(f, "MainRoom({})", room_id),
+            TimelineKind::Thread { room_id, thread_root_event_id } => {
+                write!(f, "Thread({}, {})", room_id, thread_root_event_id)
+            }
+        }
+    }
+}
+
 /// The set of requests for async work that can be made to the worker thread.
 #[allow(clippy::large_enum_variant)]
 pub enum MatrixRequest {
     /// Request from the login screen to log in with the given credentials.
     Login(LoginRequest),
     /// Request to logout.
-    Logout{
+    Logout {
         is_desktop: bool,
     },
-    /// Request to paginate the older (or newer) events of a room's timeline.
-    PaginateRoomTimeline {
-        room_id: OwnedRoomId,
+    /// Request to paginate the older (or newer) events of a room or thread timeline.
+    PaginateTimeline {
+        timeline_kind: TimelineKind,
         /// The maximum number of timeline events to fetch in each pagination batch.
         num_events: u16,
         direction: PaginationDirection,
     },
     /// Request to edit the content of an event in the given room's timeline.
     EditMessage {
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
         timeline_event_item_id: TimelineEventItemId,
         edited_content: EditedContent,
     },
     /// Request to fetch the full details of the given event in the given room's timeline.
     FetchDetailsForEvent {
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
         event_id: OwnedEventId,
     },
+    /// Request to fetch the latest thread-reply preview and latest reply count
+    /// for the given thread root.
+    FetchThreadSummaryDetails {
+        timeline_kind: TimelineKind,
+        thread_root_event_id: OwnedEventId,
+        timeline_item_index: usize,
+    },
     /// Request to fetch profile information for all members of a room.
+    ///
     /// This can be *very* slow depending on the number of members in the room.
+    ///
+    /// Even though it operates on a room itself, this accepts a `TimelineKind`
+    /// in order to be able to send the fetched room member list to a specific timeline UI.
     SyncRoomMemberList {
+        timeline_kind: TimelineKind,
+    },
+    /// Request to create a thread timeline focused on the given thread root event in the given room.
+    CreateThreadTimeline {
         room_id: OwnedRoomId,
+        thread_root_event_id: OwnedEventId,
     },
     /// Request to knock on (request an invite to) the given room.
     Knock {
@@ -368,9 +425,13 @@ pub enum MatrixRequest {
         room_id: OwnedRoomId,
     },
     /// Request to get the actual list of members in a room.
+    ///
     /// This returns the list of members that can be displayed in the UI.
+    ///
+    /// Even though it operates on a room itself, this accepts a `TimelineKind`
+    /// in order to be able to send the fetched room member list to a specific timeline UI.
     GetRoomMembers {
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
         memberships: RoomMemberships,
         /// * If `true` (not recommended), only the local cache will be accessed.
         /// * If `false` (recommended), details will be fetched from the server.
@@ -413,7 +474,7 @@ pub enum MatrixRequest {
     },
     /// Request to fetch the number of unread messages in the given room.
     GetNumberUnreadMessages {
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
     },
     /// Request to set the unread flag for the given room.
     SetUnreadFlag {
@@ -488,7 +549,7 @@ pub enum MatrixRequest {
     },
     /// Request to send a message to the given room.
     SendMessage {
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
         message: RoomMessageEventContent,
         replied_to: Option<Reply>,
         #[cfg(feature = "tsp")]
@@ -514,7 +575,10 @@ pub enum MatrixRequest {
     },
     /// Subscribe to typing notices for the given room.
     ///
-    /// This request does not return a response or notify the UI thread.
+    /// This is only valid for the main room timeline, not for thread-focused timelines.
+    ///
+    /// This request does not immediately return a response or notify the UI thread,
+    /// but it will send updates to the UI via the timeline's update sender.
     SubscribeToTypingNotices {
         room_id: OwnedRoomId,
         /// Whether to subscribe or unsubscribe.
@@ -522,51 +586,53 @@ pub enum MatrixRequest {
     },
     /// Subscribe to changes in the read receipts of our own user.
     ///
-    /// This request does not return a response or notify the UI thread.
+    /// This request does not immediately return a response or notify the UI thread,
+    /// but it will send updates to the UI via the timeline's update sender.
     SubscribeToOwnUserReadReceiptsChanged {
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
         /// Whether to subscribe or unsubscribe.
         subscribe: bool,
     },
     /// Subscribe to changes in the set of pinned events for the given room.
+    ///
+    /// This is only valid for the main room timeline, not for thread-focused timelines.
     SubscribeToPinnedEvents {
         room_id: OwnedRoomId,
         /// Whether to subscribe or unsubscribe.
         subscribe: bool,
     },
-    /// Sends a read receipt for the given event in the given room.
+    /// Sends a read receipt for the given event to the given room or thread timeline.
     ReadReceipt {
-        room_id: OwnedRoomId,
-        event_id: OwnedEventId,
-    },
-    /// Sends a fully-read receipt for the given event in the given room.
-    FullyReadReceipt {
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
         event_id: OwnedEventId,
+        receipt_type: ReceiptType,
     },
     /// Sends a request to obtain the power levels for this room.
     ///
     /// The response is delivered back to the main UI thread via [`TimelineUpdate::UserPowerLevels`].
+    ///
+    /// Even though it operates on a room itself, this accepts a `TimelineKind`
+    /// in order to be able to send the fetched room member list to a specific timeline UI.
     GetRoomPowerLevels {
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
     },
     /// Toggles the given reaction to the given event in the given room.
     ToggleReaction {
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
         timeline_event_id: TimelineEventItemId,
         reaction: String,
     },
     /// Redacts (deletes) the given event in the given room.
     #[doc(alias("delete"))]
     RedactMessage {
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
         timeline_event_id: TimelineEventItemId,
         reason: Option<String>,
     },
     /// Pin or unpin the given event in the given room.
     #[doc(alias("unpin"))]
     PinEvent {
-        room_id: OwnedRoomId,
+        timeline_kind: TimelineKind,
         event_id: OwnedEventId,
         pin: bool,
     },
@@ -619,7 +685,9 @@ async fn matrix_worker_task(
     login_sender: Sender<LoginRequest>,
 ) -> Result<()> {
     log!("Started matrix_worker_task.");
-    let mut subscribers_own_user_read_receipts: HashMap<OwnedRoomId, JoinHandle<()>> = HashMap::new();
+    // The async tasks that are spawned to subscribe to changes in our own user's read receipts for each timeline.
+    let mut subscribers_own_user_read_receipts: HashMap<TimelineKind, JoinHandle<()>> = HashMap::new();
+    // The async tasks that are spawned to subscribe to changes in the pinned events for each room.
     let mut subscribers_pinned_events: HashMap<OwnedRoomId, JoinHandle<()>> = HashMap::new();
 
     while let Some(request) = request_receiver.recv().await {
@@ -649,22 +717,15 @@ async fn matrix_worker_task(
                 });
             }
 
-            MatrixRequest::PaginateRoomTimeline { room_id, num_events, direction } => {
-                let (timeline, sender) = {
-                    let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
-                        log!("Skipping pagination request for not-yet-known room {room_id}");
-                        continue;
-                    };
-
-                    let timeline_ref = room_info.timeline.clone();
-                    let sender = room_info.timeline_update_sender.clone();
-                    (timeline_ref, sender)
+            MatrixRequest::PaginateTimeline {timeline_kind, num_events, direction} => {
+                let Some((timeline, sender)) = get_timeline_and_sender(&timeline_kind) else {
+                    log!("Skipping pagination request for unknown {timeline_kind}");
+                    continue;
                 };
 
                 // Spawn a new async task that will make the actual pagination request.
                 let _paginate_task = Handle::current().spawn(async move {
-                    log!("Starting {direction} pagination request for room {room_id}...");
+                    log!("Starting {direction} pagination request for {timeline_kind}...");
                     sender.send(TimelineUpdate::PaginationRunning(direction)).unwrap();
                     SignalToUI::set_ui_signal();
 
@@ -676,7 +737,7 @@ async fn matrix_worker_task(
 
                     match res {
                         Ok(fully_paginated) => {
-                            log!("Completed {direction} pagination request for room {room_id}, hit {} of timeline? {}",
+                            log!("Completed {direction} pagination request for {timeline_kind}, hit {} of timeline? {}",
                                 if direction == PaginationDirection::Forwards { "end" } else { "start" },
                                 if fully_paginated { "yes" } else { "no" },
                             );
@@ -687,7 +748,7 @@ async fn matrix_worker_task(
                             SignalToUI::set_ui_signal();
                         }
                         Err(error) => {
-                            error!("Error sending {direction} pagination request for room {room_id}: {error:?}");
+                            error!("Error sending {direction} pagination request for {timeline_kind}: {error:?}");
                             sender.send(TimelineUpdate::PaginationError {
                                 error,
                                 direction,
@@ -698,84 +759,181 @@ async fn matrix_worker_task(
                 });
             }
 
-            MatrixRequest::EditMessage { room_id, timeline_event_item_id: timeline_event_id, edited_content } => {
-                let (timeline, sender) = {
-                    let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
-                        error!("BUG: room info not found for edit request, room {room_id}");
-                        continue;
-                    };
-                    (room_info.timeline.clone(), room_info.timeline_update_sender.clone())
+            MatrixRequest::EditMessage { timeline_kind, timeline_event_item_id, edited_content } => {
+                let Some((timeline, sender)) = get_timeline_and_sender(&timeline_kind) else {
+                    log!("BUG: {timeline_kind} not found for edit request");
+                    continue;
                 };
 
                 // Spawn a new async task that will make the actual edit request.
                 let _edit_task = Handle::current().spawn(async move {
-                    log!("Sending request to edit message {timeline_event_id:?} in room {room_id}...");
-                    let result = timeline.edit(&timeline_event_id, edited_content).await;
+                    log!("Sending request to edit message {timeline_event_item_id:?} in {timeline_kind}...");
+                    let result = timeline.edit(&timeline_event_item_id, edited_content).await;
                     match result {
-                        Ok(_) => log!("Successfully edited message {timeline_event_id:?} in room {room_id}."),
-                        Err(ref e) => error!("Error editing message {timeline_event_id:?} in room {room_id}: {e:?}"),
+                        Ok(_) => log!("Successfully edited message {timeline_event_item_id:?} in {timeline_kind}."),
+                        Err(ref e) => error!("Error editing message {timeline_event_item_id:?} in {timeline_kind}: {e:?}"),
                     }
                     sender.send(TimelineUpdate::MessageEdited {
-                        timeline_event_id,
+                        timeline_event_item_id,
                         result,
                     }).unwrap();
                     SignalToUI::set_ui_signal();
                 });
             }
 
-            MatrixRequest::FetchDetailsForEvent { room_id, event_id } => {
-                let (timeline, sender) = {
-                    let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
-                        error!("BUG: room info not found for fetch details for event request {room_id}");
-                        continue;
-                    };
-
-                    (room_info.timeline.clone(), room_info.timeline_update_sender.clone())
+            MatrixRequest::FetchDetailsForEvent { timeline_kind, event_id } => {
+                let Some((timeline, sender)) = get_timeline_and_sender(&timeline_kind) else {
+                    log!("BUG: {timeline_kind} not found for fetch details for event request");
+                    continue;
                 };
 
-                // Spawn a new async task that will make the actual fetch request.
                 let _fetch_task = Handle::current().spawn(async move {
-                    // log!("Sending request to fetch details for event {event_id} in room {room_id}...");
+                    // log!("Sending request to fetch details for event {event_id} in {timeline_kind}...");
                     let result = timeline.fetch_details_for_event(&event_id).await;
                     match &result {
                         Ok(_) => {
-                            // log!("Successfully fetched details for event {event_id} in room {room_id}.");
+                            // log!("Successfully fetched details for event {event_id} in {timeline_kind}.");
                         }
                         Err(_e) => {
-                            // error!("Error fetching details for event {event_id} in room {room_id}: {_e:?}");
+                            // error!("Error fetching details for event {event_id} in {timeline_kind}: {_e:?}");
                         }
                     }
-                    sender.send(TimelineUpdate::EventDetailsFetched {
-                        event_id,
-                        result,
-                    }).unwrap();
+                    if sender.send(TimelineUpdate::EventDetailsFetched { event_id, result }).is_err() {
+                        error!("Failed to send fetched event details to UI for {timeline_kind}");
+                    }
                     SignalToUI::set_ui_signal();
                 });
             }
 
-            MatrixRequest::SyncRoomMemberList { room_id } => {
-                let (timeline, sender) = {
-                    let all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get(&room_id) else {
-                        error!("BUG: room info not found for fetch members request {room_id}");
-                        continue;
+            MatrixRequest::FetchThreadSummaryDetails {
+                timeline_kind,
+                thread_root_event_id,
+                timeline_item_index,
+            } => {
+                let Some((timeline, sender)) = get_timeline_and_sender(&timeline_kind) else {
+                    log!("BUG: {timeline_kind} not found for fetch thread summary details request");
+                    continue;
+                };
+
+                let _fetch_task = Handle::current().spawn(async move {
+                    let (num_replies, latest_reply_event) = fetch_thread_summary_details(
+                        timeline.room(),
+                        &thread_root_event_id,
+                    ).await;
+                    let latest_reply_preview_text = match latest_reply_event.as_ref() {
+                        Some(event) => text_preview_of_latest_thread_reply(timeline.room(), event).await,
+                        None => None,
                     };
 
-                    (room_info.timeline.clone(), room_info.timeline_update_sender.clone())
+                    if sender.send(TimelineUpdate::ThreadSummaryDetailsFetched {
+                        thread_root_event_id,
+                        timeline_item_index,
+                        num_replies,
+                        latest_reply_preview_text,
+                    }).is_err() {
+                        error!("Failed to send fetched thread summary details to UI for {timeline_kind}");
+                    }
+                    SignalToUI::set_ui_signal();
+                });
+            }
+
+            MatrixRequest::SyncRoomMemberList { timeline_kind } => {
+                let Some((timeline, sender)) = get_timeline_and_sender(&timeline_kind) else {
+                    log!("BUG: {timeline_kind} not found for sync members list request");
+                    continue;
                 };
 
-                // Spawn a new async task that will make the actual fetch request.
                 let _fetch_task = Handle::current().spawn(async move {
-                    log!("Sending sync room members request for room {room_id}...");
+                    log!("Sending sync room members request for {timeline_kind}...");
                     timeline.fetch_members().await;
-                    log!("Completed sync room members request for room {room_id}.");
+                    log!("Completed sync room members request for {timeline_kind}.");
                     sender.send(TimelineUpdate::RoomMembersSynced).unwrap();
                     SignalToUI::set_ui_signal();
                 });
             }
 
+            MatrixRequest::CreateThreadTimeline { room_id, thread_root_event_id } => {
+                let main_room_timeline = {
+                    let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
+                    let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
+                        error!("BUG: room info not found for create thread timeline request, room {room_id}");
+                        continue;
+                    };
+                    if room_info.thread_timelines.contains_key(&thread_root_event_id) {
+                        continue;
+                    }
+                    let newly_pending = room_info.pending_thread_timelines.insert(thread_root_event_id.clone());
+                    if !newly_pending {
+                        continue;
+                    }
+                    room_info.main_timeline.timeline.clone()
+                };
+
+                let _create_thread_timeline_task = Handle::current().spawn(async move {
+                    log!("Creating thread-focused timeline for room {room_id}, thread {thread_root_event_id}...");
+                    let build_result = main_room_timeline.room()
+                        .timeline_builder()
+                        .with_focus(TimelineFocus::Thread {
+                            root_event_id: thread_root_event_id.clone(),
+                        })
+                        .track_read_marker_and_receipts(TimelineReadReceiptTracking::AllEvents)
+                        .build()
+                        .await;
+
+                    match build_result {
+                        Ok(thread_timeline) => {
+                            let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
+                            let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
+                                return;
+                            };
+                            log!("Successfully created thread-focused timeline for room {room_id}, thread {thread_root_event_id}.");
+                            let thread_timeline = Arc::new(thread_timeline);
+                            let (timeline_update_sender, timeline_update_receiver) = crossbeam_channel::unbounded();
+                            let (request_sender, request_receiver) = watch::channel(Vec::new());
+                            let timeline_subscriber_handler_task = Handle::current().spawn(
+                                timeline_subscriber_handler(
+                                    main_room_timeline.room().clone(),
+                                    thread_timeline.clone(),
+                                    timeline_update_sender.clone(),
+                                    request_receiver,
+                                    Some(thread_root_event_id.clone()),
+                                )
+                            );
+                            room_info
+                                .pending_thread_timelines
+                                .remove(&thread_root_event_id);
+                            room_info.thread_timelines.insert(
+                                thread_root_event_id.clone(),
+                                PerTimelineDetails {
+                                    timeline: thread_timeline,
+                                    timeline_update_sender,
+                                    timeline_singleton_endpoints: Some((
+                                        timeline_update_receiver,
+                                        request_sender,
+                                    )),
+                                    timeline_subscriber_handler_task,
+                                },
+                            );
+                            SignalToUI::set_ui_signal();
+                        }
+                        Err(error) => {
+                            error!("Failed to create thread-focused timeline for room {room_id}, thread {thread_root_event_id}: {error}");
+                            let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
+                            if let Some(room_info) = all_joined_rooms.get_mut(&room_id) {
+                                room_info
+                                    .pending_thread_timelines
+                                    .remove(&thread_root_event_id);
+                            }
+                            enqueue_popup_notification(
+                                format!("Failed to create thread-focused timeline. Please retry opening the thread again later.\n\nError: {error}"),
+                                PopupKind::Error,
+                                None,
+                            );
+                        }
+                    }
+                });
+            }
+
             MatrixRequest::Knock { room_or_alias_id, reason, server_names } => {
                 let Some(client) = get_client() else { continue };
                 let _knock_room_task = Handle::current().spawn(async move {
@@ -884,27 +1042,20 @@ async fn matrix_worker_task(
                 });
             }
 
-            MatrixRequest::GetRoomMembers { room_id, memberships, local_only } => {
-                let (timeline, sender) = {
-                    let all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get(&room_id) else {
-                        log!("BUG: room info not found for get room members request {room_id}");
-                        continue;
-                    };
-                    (room_info.timeline.clone(), room_info.timeline_update_sender.clone())
+            MatrixRequest::GetRoomMembers { timeline_kind, memberships, local_only } => {
+                let Some((timeline, sender)) = get_timeline_and_sender(&timeline_kind) else {
+                    log!("BUG: {timeline_kind} not found for get room members request");
+                    continue;
                 };
 
                 let _get_members_task = Handle::current().spawn(async move {
-                    let room = timeline.room();
-
                     let send_update = |members: Vec<matrix_sdk::room::RoomMember>, source: &str| {
-                        log!("{} {} members for room {}", source, members.len(), room_id);
-                        sender.send(TimelineUpdate::RoomMembersListFetched {
-                            members
-                        }).unwrap();
+                        log!("{} {} members for {timeline_kind}", source, members.len());
+                        sender.send(TimelineUpdate::RoomMembersListFetched { members }).unwrap();
                         SignalToUI::set_ui_signal();
                     };
 
+                    let room = timeline.room();
                     if local_only {
                         if let Ok(members) = room.members_no_sync(memberships).await {
                             send_update(members, "Got");
@@ -933,7 +1084,10 @@ async fn matrix_worker_task(
                         error!("BUG: tombstoned room {tombstoned_room_id} info not found for get successor room details request");
                         continue;
                     };
-                    (room_info.timeline_update_sender.clone(), room_info.timeline.room().successor_room())
+                    (
+                        room_info.main_timeline.timeline_update_sender.clone(),
+                        room_info.main_timeline.timeline.room().successor_room(),
+                    )
                 };
                 spawn_fetch_successor_room_preview(
                     client,
@@ -1047,82 +1201,73 @@ async fn matrix_worker_task(
                     }
                 });
             }
-            MatrixRequest::GetNumberUnreadMessages { room_id } => {
-                let (timeline, sender) = {
-                    let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
-                        log!("Skipping get number of unread messages request for not-yet-known room {room_id}");
-                        continue;
-                    };
 
-                    (room_info.timeline.clone(), room_info.timeline_update_sender.clone())
+            MatrixRequest::GetNumberUnreadMessages { timeline_kind } => {
+                let Some((timeline, sender)) = get_timeline_and_sender(&timeline_kind) else {
+                    log!("Skipping get number of unread messages request for {timeline_kind}");
+                    continue;
                 };
+
                 let _get_unreads_task = Handle::current().spawn(async move {
                     match sender.send(TimelineUpdate::NewUnreadMessagesCount(
                         UnreadMessageCount::Known(timeline.room().num_unread_messages())
                     )) {
                         Ok(_) => SignalToUI::set_ui_signal(),
-                        Err(e) => log!("Failed to send timeline update: {e:?} for GetNumberUnreadMessages request for room {room_id}"),
+                        Err(e) => log!("Failed to send timeline update: {e:?} for GetNumberUnreadMessages request for {timeline_kind}"),
+                    }
+                    if let TimelineKind::MainRoom { room_id } = timeline_kind {
+                        enqueue_rooms_list_update(RoomsListUpdate::UpdateNumUnreadMessages {
+                            room_id,
+                            is_marked_unread: timeline.room().is_marked_unread(),
+                            unread_messages: UnreadMessageCount::Known(timeline.room().num_unread_messages()),
+                            unread_mentions: timeline.room().num_unread_mentions(),
+                        });
                     }
-                    enqueue_rooms_list_update(RoomsListUpdate::UpdateNumUnreadMessages {
-                        room_id: room_id.clone(),
-                        is_marked_unread: timeline.room().is_marked_unread(),
-                        unread_messages: UnreadMessageCount::Known(timeline.room().num_unread_messages()),
-                        unread_mentions: timeline.room().num_unread_mentions(),
-                    });
                 });
             }
+
             MatrixRequest::SetUnreadFlag { room_id, mark_as_unread } => {
-                let timeline = {
-                    let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
-                        log!("Skipping set unread flag request for not-yet-known room {room_id}");
-                        continue;
-                    };
-                    room_info.timeline.clone()
+                let Some(main_timeline) = get_room_timeline(&room_id) else {
+                    log!("BUG: skipping set unread flag request for not-yet-known room {room_id}");
+                    continue;
                 };
                 let _set_unread_task = Handle::current().spawn(async move {
-                    let result = timeline.room().set_unread_flag(mark_as_unread).await;
+                    let result = main_timeline.room().set_unread_flag(mark_as_unread).await;
                     match result {
                         Ok(_) => log!("Set unread flag to {} for room {}", mark_as_unread, room_id),
                         Err(e) => error!("Failed to set unread flag to {} for room {}: {:?}", mark_as_unread, room_id, e),
                     }
                 });
             }
+
             MatrixRequest::SetIsFavorite { room_id, is_favorite } => {
-                let timeline = {
-                    let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
-                        log!("Skipping set favorite request for not-yet-known room {room_id}");
-                        continue;
-                    };
-                    room_info.timeline.clone()
+                let Some(main_timeline) = get_room_timeline(&room_id) else {
+                    log!("BUG: skipping set favorite flag request for not-yet-known room {room_id}");
+                    continue;
                 };
                 let _set_favorite_task = Handle::current().spawn(async move {
-                    let result = timeline.room().set_is_favourite(is_favorite, None).await;
+                    let result = main_timeline.room().set_is_favourite(is_favorite, None).await;
                     match result {
                         Ok(_) => log!("Set favorite to {} for room {}", is_favorite, room_id),
                         Err(e) => error!("Failed to set favorite to {} for room {}: {:?}", is_favorite, room_id, e),
                     }
                 });
             }
+
             MatrixRequest::SetIsLowPriority { room_id, is_low_priority } => {
-                let timeline = {
-                    let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
-                        log!("Skipping set low priority request for not-yet-known room {room_id}");
-                        continue;
-                    };
-                    room_info.timeline.clone()
+                let Some(main_timeline) = get_room_timeline(&room_id) else {
+                    log!("BUG: skipping set low priority flag request for not-yet-known room {room_id}");
+                    continue;
                 };
                 let _set_lp_task = Handle::current().spawn(async move {
-                    let result = timeline.room().set_is_low_priority(is_low_priority, None).await;
+                    let result = main_timeline.room().set_is_low_priority(is_low_priority, None).await;
                     match result {
                         Ok(_) => log!("Set low priority to {} for room {}", is_low_priority, room_id),
                         Err(e) => error!("Failed to set low priority to {} for room {}: {:?}", is_low_priority, room_id, e),
                     }
                 });
             }
+
             MatrixRequest::SetAvatar { avatar_url } => {
                 let Some(client) = get_client() else { continue };
                 let _set_avatar_task = Handle::current().spawn(async move {
@@ -1141,6 +1286,7 @@ async fn matrix_worker_task(
                     }
                 });
             }
+
             MatrixRequest::SetDisplayName { new_display_name } => {
                 let Some(client) = get_client() else { continue };
                 let _set_display_name_task = Handle::current().spawn(async move {
@@ -1162,6 +1308,7 @@ async fn matrix_worker_task(
                     }
                 });
             }
+
             MatrixRequest::GenerateMatrixLink { room_id, event_id, use_matrix_scheme, join_on_click } => {
                 let Some(client) = get_client() else { continue };
                 let _gen_link_task = Handle::current().spawn(async move {
@@ -1193,6 +1340,7 @@ async fn matrix_worker_task(
                     }
                 });
             }
+
             MatrixRequest::IgnoreUser { ignore, room_member, room_id } => {
                 let Some(client) = get_client() else { continue };
                 let _ignore_task = Handle::current().spawn(async move {
@@ -1238,8 +1386,8 @@ async fn matrix_worker_task(
                     // Note that here we only proactively re-paginate the *current* room
                     // (the one being viewed by the user when this ignore request was issued),
                     // and all other rooms will be re-paginated in `handle_ignore_user_list_subscriber()`.`
-                    submit_async_request(MatrixRequest::PaginateRoomTimeline {
-                        room_id,
+                    submit_async_request(MatrixRequest::PaginateTimeline {
+                        timeline_kind: TimelineKind::MainRoom { room_id },
                         num_events: 50,
                         direction: PaginationDirection::Backwards,
                     });
@@ -1247,43 +1395,40 @@ async fn matrix_worker_task(
             }
 
             MatrixRequest::SendTypingNotice { room_id, typing } => {
-                let Some(room) = get_client().and_then(|c| c.get_room(&room_id)) else {
-                    error!("BUG: client/room not found for typing notice request {room_id}");
+                let Some(main_room_timeline) = get_room_timeline(&room_id) else {
+                    log!("BUG: skipping send typing notice request for not-yet-known room {room_id}");
                     continue;
                 };
                 let _typing_task = Handle::current().spawn(async move {
-                    if let Err(e) = room.typing_notice(typing).await {
+                    if let Err(e) = main_room_timeline.room().typing_notice(typing).await {
                         error!("Failed to send typing notice to room {room_id}: {e:?}");
                     }
                 });
             }
 
             MatrixRequest::SubscribeToTypingNotices { room_id, subscribe } => {
-                let (room, timeline_update_sender, mut typing_notice_receiver) = {
+                let (main_timeline, timeline_update_sender, mut typing_notice_receiver) = {
                     let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
+                    let Some(jrd) = all_joined_rooms.get_mut(&room_id) else {
                         log!("BUG: room info not found for subscribe to typing notices request, room {room_id}");
                         continue;
                     };
-                    let (room, recv) = if subscribe {
-                        if room_info.typing_notice_subscriber.is_some() {
+                    let (main_timeline, receiver) = if subscribe {
+                        if jrd.typing_notice_subscriber.is_some() {
                             warning!("Note: room {room_id} is already subscribed to typing notices.");
                             continue;
                         } else {
-                            let Some(room) = get_client().and_then(|c| c.get_room(&room_id)) else {
-                                error!("BUG: client/room not found when subscribing to typing notices request, room: {room_id}");
-                                continue;
-                            };
-                            let (drop_guard, recv) = room.subscribe_to_typing_notifications();
-                            room_info.typing_notice_subscriber = Some(drop_guard);
-                            (room, recv)
+                            let main_timeline = jrd.main_timeline.timeline.clone();
+                            let (drop_guard, receiver) = main_timeline.room().subscribe_to_typing_notifications();
+                            jrd.typing_notice_subscriber = Some(drop_guard);
+                            (main_timeline, receiver)
                         }
                     } else {
-                        room_info.typing_notice_subscriber.take();
+                        jrd.typing_notice_subscriber.take();
                         continue;
                     };
                     // Here: we don't have an existing subscriber running, so we fall through and start one.
-                    (room, room_info.timeline_update_sender.clone(), recv)
+                    (main_timeline, jrd.main_timeline.timeline_update_sender.clone(), receiver)
                 };
 
                 let _typing_notices_task = Handle::current().spawn(async move {
@@ -1292,7 +1437,8 @@ async fn matrix_worker_task(
                         let mut users = Vec::with_capacity(user_ids.len());
                         for user_id in user_ids {
                             users.push(
-                                room.get_member_no_sync(&user_id)
+                                main_timeline.room()
+                                    .get_member_no_sync(&user_id)
                                     .await
                                     .ok()
                                     .flatten()
@@ -1308,60 +1454,60 @@ async fn matrix_worker_task(
                     // log!("Note: typing notifications recv loop has ended for room {}", room_id);
                 });
             }
-            MatrixRequest::SubscribeToOwnUserReadReceiptsChanged { room_id, subscribe } => {
+
+            MatrixRequest::SubscribeToOwnUserReadReceiptsChanged { timeline_kind, subscribe } => {
                 if !subscribe {
-                    if let Some(task_handler) = subscribers_own_user_read_receipts.remove(&room_id) {
+                    if let Some(task_handler) = subscribers_own_user_read_receipts.remove(&timeline_kind) {
                         task_handler.abort();
                     }
                     continue;
                 }
-                let (timeline, sender) = {
-                    let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
-                        log!("BUG: room info not found for subscribe to own user read receipts changed request, room {room_id}");
-                        continue;
-                    };
-                    (room_info.timeline.clone(), room_info.timeline_update_sender.clone())
+                let Some((timeline, sender)) = get_timeline_and_sender(&timeline_kind) else {
+                    log!("BUG: skipping subscribe to own user read receipts changed request for {timeline_kind}");
+                    continue;
                 };
-                let room_id_clone = room_id.clone();
+
+                let timeline_kind_clone = timeline_kind.clone();
                 let subscribe_own_read_receipt_task = Handle::current().spawn(async move {
                     let update_receiver = timeline.subscribe_own_user_read_receipts_changed().await;
                     pin_mut!(update_receiver);
                     if let Some(client_user_id) = current_user_id() {
                         if let Some((event_id, receipt)) = timeline.latest_user_read_receipt(&client_user_id).await {
-                            log!("Received own user read receipt for room {room_id_clone}: {receipt:?}, event ID: {event_id:?}");
-                            if let Err(e) = sender.send(TimelineUpdate::OwnUserReadReceipt(receipt)) {
-                                error!("Failed to get own user read receipt: {e:?}");
+                            log!("Received own user read receipt for {timeline_kind}: {receipt:?}, event ID: {event_id:?}");
+                            if sender.send(TimelineUpdate::OwnUserReadReceipt(receipt)).is_err() {
+                                error!("Failed to send own user read receipt to UI.");
                             }
                         }
 
-                        while (update_receiver.next().await).is_some() {
+                        while update_receiver.next().await.is_some() {
                             if let Some((_, receipt)) = timeline.latest_user_read_receipt(&client_user_id).await {
-                                if let Err(e) = sender.send(TimelineUpdate::OwnUserReadReceipt(receipt)) {
-                                    error!("Failed to send own user read receipt: {e:?}");
+                                if sender.send(TimelineUpdate::OwnUserReadReceipt(receipt)).is_err() {
+                                    error!("Failed to send own user read receipt to UI.");
                                 }
                                 // When read receipts change (from other devices), update unread count
                                 let unread_count = timeline.room().num_unread_messages();
                                 let unread_mentions = timeline.room().num_unread_mentions();
-                                // Send updated unread count to the UI
-                                if let Err(e) = sender.send(TimelineUpdate::NewUnreadMessagesCount(
+                                if sender.send(TimelineUpdate::NewUnreadMessagesCount(
                                     UnreadMessageCount::Known(unread_count)
-                                )) {
-                                    error!("Failed to send unread message count update: {e:?}");
+                                )).is_err() {
+                                    error!("Failed to send unread message count update to UI.");
+                                }
+                                if let TimelineKind::MainRoom { room_id } = &timeline_kind {
+                                    // Update the rooms list with new unread counts
+                                    enqueue_rooms_list_update(RoomsListUpdate::UpdateNumUnreadMessages {
+                                        room_id: room_id.clone(),
+                                        is_marked_unread: timeline.room().is_marked_unread(),
+                                        unread_messages: UnreadMessageCount::Known(unread_count),
+                                        unread_mentions,
+                                    });
                                 }
-                                // Update the rooms list with new unread counts
-                                enqueue_rooms_list_update(RoomsListUpdate::UpdateNumUnreadMessages {
-                                    room_id: room_id_clone.clone(),
-                                    is_marked_unread: timeline.room().is_marked_unread(),
-                                    unread_messages: UnreadMessageCount::Known(unread_count),
-                                    unread_mentions,
-                                });
                             }
                         }
                     }
                 });
-                subscribers_own_user_read_receipts.insert(room_id, subscribe_own_read_receipt_task);
+                subscribers_own_user_read_receipts.insert(timeline_kind_clone, subscribe_own_read_receipt_task);
             }
+
             MatrixRequest::SubscribeToPinnedEvents { room_id, subscribe } => {
                 if !subscribe {
                     if let Some(task_handler) = subscribers_pinned_events.remove(&room_id) {
@@ -1369,22 +1515,19 @@ async fn matrix_worker_task(
                     }
                     continue;
                 }
-                let (timeline, sender) = {
-                    let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get_mut(&room_id) else {
-                        log!("BUG: room info not found for subscribe to pinned events request, room {room_id}");
-                        continue;
-                    };
-                    (room_info.timeline.clone(), room_info.timeline_update_sender.clone())
+                let kind = TimelineKind::MainRoom { room_id: room_id.clone() };
+                let Some((main_timeline, sender)) = get_timeline_and_sender(&kind) else {
+                    log!("BUG: skipping subscribe to pinned events request for unknown room {room_id}");
+                    continue;
                 };
                 let subscribe_pinned_events_task = Handle::current().spawn(async move {
                     // Send an initial update, as the stream may not update immediately.
-                    let pinned_events = timeline.room().pinned_event_ids().unwrap_or_default();
+                    let pinned_events = main_timeline.room().pinned_event_ids().unwrap_or_default();
                     match sender.send(TimelineUpdate::PinnedEvents(pinned_events)) {
                         Ok(()) => SignalToUI::set_ui_signal(),
-                        Err(e) => log!("Failed to send initial pinned events update: {e:?}"),
+                        Err(_) => log!("Failed to send initial pinned events update to UI."),
                     }
-                    let update_receiver = timeline.room().pinned_event_ids_stream();
+                    let update_receiver = main_timeline.room().pinned_event_ids_stream();
                     pin_mut!(update_receiver);
                     while let Some(pinned_events) = update_receiver.next().await {
                         match sender.send(TimelineUpdate::PinnedEvents(pinned_events)) {
@@ -1395,9 +1538,11 @@ async fn matrix_worker_task(
                 });
                 subscribers_pinned_events.insert(room_id, subscribe_pinned_events_task);
             }
+
             MatrixRequest::SpawnSSOServer { brand, homeserver_url, identity_provider_id} => {
                 spawn_sso_server(brand, homeserver_url, identity_provider_id, login_sender.clone()).await;
             }
+
             MatrixRequest::ResolveRoomAlias(room_alias) => {
                 let Some(client) = get_client() else { continue };
                 let _resolve_task = Handle::current().spawn(async move {
@@ -1407,6 +1552,7 @@ async fn matrix_worker_task(
                     todo!("Send the resolved room alias back to the UI thread somehow.");
                 });
             }
+
             MatrixRequest::FetchAvatar { mxc_uri, on_fetched } => {
                 let Some(client) = get_client() else { continue };
                 Handle::current().spawn(async move {
@@ -1423,34 +1569,30 @@ async fn matrix_worker_task(
 
             MatrixRequest::FetchMedia { media_request, on_fetched, destination, update_sender } => {
                 let Some(client) = get_client() else { continue };
-                let media = client.media();
-
+                
                 let _fetch_task = Handle::current().spawn(async move {
                     // log!("Sending fetch media request for {media_request:?}...");
-                    let res = media.get_media_content(&media_request, true).await;
+                    let res = client.media().get_media_content(&media_request, true).await;
                     on_fetched(&destination, media_request, res, update_sender);
                 });
             }
 
             MatrixRequest::SendMessage {
-                room_id,
+                timeline_kind,
                 message,
                 replied_to,
                 #[cfg(feature = "tsp")]
                 sign_with_tsp,
             } => {
-                let timeline = {
-                    let all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get(&room_id) else {
-                        log!("BUG: room info not found for send message request {room_id}");
-                        continue;
-                    };
-                    room_info.timeline.clone()
+                // TODO: use this timeline `_sender` once we support sending-message status/operations in the UI.
+                let Some((timeline, _sender)) = get_timeline_and_sender(&timeline_kind) else {
+                    log!("BUG: {timeline_kind} not found for send message request");
+                    continue;
                 };
 
                 // Spawn a new async task that will send the actual message.
                 let _send_message_task = Handle::current().spawn(async move {
-                    log!("Sending message to room {room_id}: {message:?}...");
+                    log!("Sending message to {timeline_kind}: {message:?}...");
                     let message = {
                         #[cfg(not(feature = "tsp"))] {
                             message
@@ -1496,18 +1638,34 @@ async fn matrix_worker_task(
                     };
 
                     if let Some(replied_to_info) = replied_to {
-                        match timeline.send_reply(message.into(), replied_to_info.event_id).await {
-                            Ok(_send_handle) => log!("Sent reply message to room {room_id}."),
+                        let reply_content = match timeline
+                            .room()
+                            .make_reply_event(message.into(), replied_to_info)
+                            .await
+                        {
+                            Ok(content) => content,
+                            Err(_e) => {
+                                error!("Failed to build reply content to send to {timeline_kind}: {_e:?}");
+                                enqueue_popup_notification(
+                                    format!("Failed to send reply: {_e}"),
+                                    PopupKind::Error,
+                                    None,
+                                );
+                                return;
+                            }
+                        };
+                        match timeline.send(reply_content.into()).await {
+                            Ok(_send_handle) => log!("Sent reply message to {timeline_kind}."),
                             Err(_e) => {
-                                error!("Failed to send reply message to room {room_id}: {_e:?}");
+                                error!("Failed to send reply message to {timeline_kind}: {_e:?}");
                                 enqueue_popup_notification(format!("Failed to send reply: {_e}"), PopupKind::Error, None);
                             }
                         }
                     } else {
                         match timeline.send(message.into()).await {
-                            Ok(_send_handle) => log!("Sent message to room {room_id}."),
+                            Ok(_send_handle) => log!("Sent message to {timeline_kind}."),
                             Err(_e) => {
-                                error!("Failed to send message to room {room_id}: {_e:?}");
+                                error!("Failed to send message to {timeline_kind}: {_e:?}");
                                 enqueue_popup_notification(format!("Failed to send message: {_e}"), PopupKind::Error, None);
                             }
                         }
@@ -1516,65 +1674,33 @@ async fn matrix_worker_task(
                 });
             }
 
-            MatrixRequest::ReadReceipt { room_id, event_id } => {
-                let timeline = {
-                    let all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get(&room_id) else {
-                        log!("BUG: room info not found when sending read receipt, room {room_id}, {event_id}");
-                        continue;
-                    };
-                    room_info.timeline.clone()
+            MatrixRequest::ReadReceipt { timeline_kind, event_id, receipt_type } => {
+                let Some(timeline) = get_timeline(&timeline_kind) else {
+                    log!("BUG: {timeline_kind} not found when sending read receipt, {event_id}");
+                    continue;
                 };
-                let _send_rr_task = Handle::current().spawn(async move {
-                    match timeline.send_single_receipt(ReceiptType::Read, event_id.clone()).await {
-                        Ok(sent) => log!("{} read receipt to room {room_id} for event {event_id}", if sent { "Sent" } else { "Already sent" }),
-                        Err(_e) => error!("Failed to send read receipt to room {room_id} for event {event_id}; error: {_e:?}"),
-                    }
-                    // Also update the number of unread messages in the room.
-                    enqueue_rooms_list_update(RoomsListUpdate::UpdateNumUnreadMessages {
-                        room_id: room_id.clone(),
-                        is_marked_unread: timeline.room().is_marked_unread(),
-                        unread_messages: UnreadMessageCount::Known(timeline.room().num_unread_messages()),
-                        unread_mentions: timeline.room().num_unread_mentions()
-                    });
-                });
-            },
 
-            MatrixRequest::FullyReadReceipt { room_id, event_id, .. } => {
-                let timeline = {
-                    let all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get(&room_id) else {
-                        log!("BUG: room info not found when sending fully read receipt, room {room_id}, {event_id}");
-                        continue;
-                    };
-                    room_info.timeline.clone()
-                };
-                let _send_frr_task = Handle::current().spawn(async move {
-                    match timeline.send_single_receipt(ReceiptType::FullyRead, event_id.clone()).await {
-                        Ok(sent) => log!("{} fully read receipt to room {room_id} for event {event_id}",
-                            if sent { "Sent" } else { "Already sent" }
-                        ),
-                        Err(_e) => error!("Failed to send fully read receipt to room {room_id} for event {event_id}; error: {_e:?}"),
-                    }
-                    // Also update the number of unread messages in the room.
-                    enqueue_rooms_list_update(RoomsListUpdate::UpdateNumUnreadMessages {
-                        room_id: room_id.clone(),
-                        is_marked_unread: timeline.room().is_marked_unread(),
-                        unread_messages: UnreadMessageCount::Known(timeline.room().num_unread_messages()),
-                        unread_mentions: timeline.room().num_unread_mentions()
-                    });
+                let _send_rr_task = Handle::current().spawn(async move {
+                    match timeline.send_single_receipt(receipt_type.clone(), event_id.clone()).await {
+                        Ok(sent) => log!("{} {receipt_type} read receipt to {timeline_kind} for event {event_id}", if sent { "Sent" } else { "Already sent" }),
+                        Err(_e) => error!("Failed to send {receipt_type} read receipt to {timeline_kind} for event {event_id}; error: {_e:?}"),
+                    }
+                    if let TimelineKind::MainRoom { room_id } = timeline_kind {
+                        // Also update the number of unread messages in the room.
+                        enqueue_rooms_list_update(RoomsListUpdate::UpdateNumUnreadMessages {
+                            room_id,
+                            is_marked_unread: timeline.room().is_marked_unread(),
+                            unread_messages: UnreadMessageCount::Known(timeline.room().num_unread_messages()),
+                            unread_mentions: timeline.room().num_unread_mentions()
+                        });
+                    }
                 });
             },
 
-            MatrixRequest::GetRoomPowerLevels { room_id } => {
-                let (timeline, sender) = {
-                    let all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get(&room_id) else {
-                        log!("BUG: room info not found for get room power levels request {room_id}");
-                        continue;
-                    };
-
-                    (room_info.timeline.clone(), room_info.timeline_update_sender.clone())
+            MatrixRequest::GetRoomPowerLevels { timeline_kind } => {
+                let Some((timeline, sender)) = get_timeline_and_sender(&timeline_kind) else {
+                    log!("BUG: {timeline_kind} not found for room power levels request");
+                    continue;
                 };
 
                 let Some(user_id) = current_user_id() else { continue };
@@ -1582,57 +1708,50 @@ async fn matrix_worker_task(
                 let _power_levels_task = Handle::current().spawn(async move {
                     match timeline.room().power_levels().await {
                         Ok(power_levels) => {
-                            log!("Successfully fetched power levels for room {room_id}.");
-                            if let Err(e) = sender.send(TimelineUpdate::UserPowerLevels(
+                            log!("Successfully fetched power levels for {timeline_kind}.");
+                            if sender.send(TimelineUpdate::UserPowerLevels(
                                 UserPowerLevels::from(&power_levels, &user_id),
-                            )) {
-                                error!("Failed to send the result of if user can send message: {e}")
+                            )).is_err() {
+                                error!("Failed to send room power levels to UI.")
                             }
                             SignalToUI::set_ui_signal();
                         }
                         Err(e) => {
-                            error!("Failed to fetch power levels for room {room_id}: {e:?}");
+                            error!("Failed to fetch power levels for {timeline_kind}: {e:?}");
                         }
                     }
                 });
             },
-            MatrixRequest::ToggleReaction { room_id, timeline_event_id, reaction } => {
-                let timeline = {
-                    let all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get(&room_id) else {
-                        log!("BUG: room info not found for send toggle reaction {room_id}");
-                        continue;
-                    };
-                    room_info.timeline.clone()
+
+            MatrixRequest::ToggleReaction { timeline_kind, timeline_event_id, reaction } => {
+                let Some(timeline) = get_timeline(&timeline_kind) else {
+                    log!("BUG: {timeline_kind} not found for toggle reaction request");
+                    continue;
                 };
 
                 let _toggle_reaction_task = Handle::current().spawn(async move {
-                    log!("Toggle Reaction to room {room_id}: ...");
+                    log!("Sending toggle reaction {reaction:?} to {timeline_kind}: ...");
                     match timeline.toggle_reaction(&timeline_event_id, &reaction).await {
                         Ok(_send_handle) => {
+                            log!("Sent toggle reaction {reaction:?} to {timeline_kind}.");
                             SignalToUI::set_ui_signal();
-                            log!("Sent toggle reaction to room {room_id} {reaction}.")
                         },
-                        Err(_e) => error!("Failed to send toggle reaction to room {room_id} {reaction}; error: {_e:?}"),
+                        Err(_e) => error!("Failed to send toggle reaction to {timeline_kind}; error: {_e:?}"),
                     }
                 });
-
             },
-            MatrixRequest::RedactMessage { room_id, timeline_event_id, reason } => {
-                let timeline = {
-                    let all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get(&room_id) else {
-                        log!("BUG: room info not found for redact message {room_id}");
-                        continue;
-                    };
-                    room_info.timeline.clone()
+
+            MatrixRequest::RedactMessage { timeline_kind, timeline_event_id, reason } => {
+                let Some(timeline) = get_timeline(&timeline_kind) else {
+                    log!("BUG: {timeline_kind} not found for redact message request");
+                    continue;
                 };
 
                 let _redact_task = Handle::current().spawn(async move {
                     match timeline.redact(&timeline_event_id, reason.as_deref()).await {
-                        Ok(()) => log!("Successfully redacted message in room {room_id}."),
+                        Ok(()) => log!("Successfully redacted message in {timeline_kind}."),
                         Err(e) => {
-                            error!("Failed to redact message in {room_id}; error: {e:?}");
+                            error!("Failed to redact message in {timeline_kind}; error: {e:?}");
                             enqueue_popup_notification(
                                 format!("Failed to redact message. Error: {e}"),
                                 PopupKind::Error,
@@ -1642,14 +1761,11 @@ async fn matrix_worker_task(
                     }
                 });
             },
-            MatrixRequest::PinEvent { room_id, event_id, pin } => {
-                let (timeline, sender) = {
-                    let all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-                    let Some(room_info) = all_joined_rooms.get(&room_id) else {
-                        log!("BUG: room info not found for pin message {room_id}");
-                        continue;
-                    };
-                    (room_info.timeline.clone(), room_info.timeline_update_sender.clone())
+
+            MatrixRequest::PinEvent { timeline_kind, event_id, pin } => {
+                let Some((timeline, sender)) = get_timeline_and_sender(&timeline_kind) else {
+                    log!("BUG: {timeline_kind} not found for pin event request");
+                    continue;
                 };
 
                 let _pin_task = Handle::current().spawn(async move {
@@ -1660,10 +1776,11 @@ async fn matrix_worker_task(
                     };
                     match sender.send(TimelineUpdate::PinResult { event_id, pin, result }) {
                         Ok(_) => SignalToUI::set_ui_signal(),
-                        Err(e) => log!("Failed to send timeline update for pin event: {e:?}"),
+                        Err(_) => log!("Failed to send UI update for pin event."),
                     }
                 });
             }
+
             MatrixRequest::GetMatrixRoomLinkPillInfo { matrix_id, via } => {
                 let Some(client) = get_client() else { continue };
                 let _fetch_matrix_link_pill_info_task = Handle::current().spawn(async move {
@@ -1690,7 +1807,8 @@ async fn matrix_worker_task(
                     }
                 });
             }
-            MatrixRequest::GetUrlPreview { url, on_fetched, destination, update_sender,} => {
+
+            MatrixRequest::GetUrlPreview { url, on_fetched, destination, update_sender } => {
                 // const MAX_LOG_RESPONSE_BODY_LENGTH: usize = 1000;
                 // log!("Starting URL preview fetch for: {}", url);
                 let _fetch_url_preview_task = Handle::current().spawn(async move {
@@ -1890,30 +2008,39 @@ pub struct TimelineEndpoints {
     pub successor_room: Option<SuccessorRoom>,
 }
 
-/// Backend-specific details about a joined room that our client currently knows about.
-struct JoinedRoomDetails {
-    #[allow(unused)]
-    room_id: OwnedRoomId,
-    /// A reference to this room's timeline of events.
+/// Info about a timeline for a joined room or a thread in a joined room.
+struct PerTimelineDetails {
+    /// A shared reference to a room's main timeline or thread's timeline of events.
     timeline: Arc<Timeline>,
-    /// An instance of the clone-able sender that can be used to send updates to this room's timeline.
+    /// A clone-able sender for updates to this timeline.
     timeline_update_sender: crossbeam_channel::Sender<TimelineUpdate>,
     /// A tuple of two separate channel endpoints that can only be taken *once* by the main UI thread.
     ///
-    /// 1. The single receiver that can receive updates to this room's timeline.
-    ///    * When a new room is joined, an unbounded crossbeam channel will be created
+    /// 1. The single receiver that can receive updates from this timeline.
+    ///    * When a new room is joined (or a thread is opened), an unbounded crossbeam channel will be created
     ///      and its sender given to a background task (the `timeline_subscriber_handler()`)
     ///      that enqueues timeline updates as it receives timeline vector diffs from the server.
     ///    * The UI thread can take ownership of this update receiver in order to receive updates
-    ///      to this room's timeline, but only one receiver can exist at a time.
+    ///      to this room or thread timeline, but only one receiver can exist at a time.
     /// 2. The sender that can send requests to the background timeline subscriber handler,
     ///    e.g., to watch for a specific event to be prepended to the timeline (via back pagination).
     timeline_singleton_endpoints: Option<(
         crossbeam_channel::Receiver<TimelineUpdate>,
         TimelineRequestSender,
     )>,
-    /// The async task that listens for timeline updates for this room and sends them to the UI thread.
+    /// The async task that listens for updates for this timeline.
     timeline_subscriber_handler_task: JoinHandle<()>,
+}
+
+struct JoinedRoomDetails {
+    /// The room ID of this joined room.
+    room_id: OwnedRoomId,
+    /// Details about the main timeline for this room.
+    main_timeline: PerTimelineDetails,
+    /// Thread-focused timelines for this room, keyed by thread root event ID.
+    thread_timelines: HashMap<OwnedEventId, PerTimelineDetails>,
+    /// The set of thread timelines currently being created, to avoid duplicate in-flight work.
+    pending_thread_timelines: HashSet<OwnedEventId>,
     /// A drop guard for the event handler that represents a subscription to typing notices for this room.
     typing_notice_subscriber: Option<EventHandlerDropGuard>,
     /// A drop guard for the event handler that represents a subscription to pinned events for this room.
@@ -1922,7 +2049,10 @@ struct JoinedRoomDetails {
 impl Drop for JoinedRoomDetails {
     fn drop(&mut self) {
         log!("Dropping JoinedRoomDetails for room {}", self.room_id);
-        self.timeline_subscriber_handler_task.abort();
+        self.main_timeline.timeline_subscriber_handler_task.abort();
+        for thread_timeline in self.thread_timelines.values() {
+            thread_timeline.timeline_subscriber_handler_task.abort();
+        }
         drop(self.typing_notice_subscriber.take());
         drop(self.pinned_events_subscriber.take());
     }
@@ -1936,6 +2066,37 @@ type ConstHasher = BuildHasherDefault<DefaultHasher>;
 /// We use a `HashMap` for O(1) lookups, as this is accessed frequently (e.g. every timeline update).
 static ALL_JOINED_ROOMS: Mutex<HashMap<OwnedRoomId, JoinedRoomDetails, ConstHasher>> = Mutex::new(HashMap::with_hasher(BuildHasherDefault::new()));
 
+/// Returns the timeline and timeline update sender for the given joined room/thread timeline.
+fn get_per_timeline_details<'a>(
+    all_joined_rooms: &'a mut HashMap<OwnedRoomId, JoinedRoomDetails, ConstHasher>,
+    kind: &TimelineKind,
+) -> Option<&'a mut PerTimelineDetails> {
+    let room_info = all_joined_rooms.get_mut(kind.room_id())?;
+    match kind {
+        TimelineKind::MainRoom { .. } => Some(&mut room_info.main_timeline),
+        TimelineKind::Thread { thread_root_event_id, .. } => room_info.thread_timelines.get_mut(thread_root_event_id),
+    }
+}
+
+/// Obtains the lock on `ALL_JOINED_ROOMS` and returns the timeline for the given timeline kind.
+fn get_timeline(kind: &TimelineKind) -> Option<Arc<Timeline>> {
+    get_per_timeline_details(ALL_JOINED_ROOMS.lock().unwrap().deref_mut(), kind)
+        .map(|details| details.timeline.clone())
+}
+
+/// Obtains the lock on `ALL_JOINED_ROOMS` and returns the timeline and timeline update sender for the given timeline kind.
+fn get_timeline_and_sender(kind: &TimelineKind) -> Option<(Arc<Timeline>, crossbeam_channel::Sender<TimelineUpdate>)> {
+    get_per_timeline_details(ALL_JOINED_ROOMS.lock().unwrap().deref_mut(), kind)
+        .map(|details| (details.timeline.clone(), details.timeline_update_sender.clone()))
+}
+
+/// Obtains the lock on `ALL_JOINED_ROOMS` and returns the main timeline for the given room.
+fn get_room_timeline(room_id: &RoomId) -> Option<Arc<Timeline>> {
+    ALL_JOINED_ROOMS.lock().unwrap()
+        .get(room_id)
+        .map(|jrd| jrd.main_timeline.timeline.clone())
+}
+
 /// The logged-in Matrix client, which can be freely and cheaply cloned.
 static CLIENT: Mutex<Option<Client>> = Mutex::new(None);
 
@@ -1975,35 +2136,28 @@ pub fn is_user_ignored(user_id: &UserId) -> bool {
 }
 
 
-/// Returns three channel endpoints related to the timeline for the given joined room.
+/// Returns three channel endpoints related to the timeline for the given joined room or thread.
 ///
 /// 1. A timeline update sender.
 /// 2. The timeline update receiver, which is a singleton, and can only be taken once.
 /// 3. A `tokio::watch` sender that can be used to send requests to the timeline subscriber handler.
 ///
-/// This will only succeed once per room, as only a single channel receiver can exist.
-pub fn take_timeline_endpoints(
-    room_id: &OwnedRoomId,
-) -> Option<TimelineEndpoints> {
+/// This will only succeed once per room (or once per room thread),
+/// as only a single channel receiver can exist.
+pub fn take_timeline_endpoints(kind: &TimelineKind) -> Option<TimelineEndpoints> {
     let mut all_joined_rooms = ALL_JOINED_ROOMS.lock().unwrap();
-    all_joined_rooms
-        .get_mut(room_id)
-        .and_then(|jrd| jrd.timeline_singleton_endpoints.take()
-            .map(|(update_receiver, request_sender)| (
-                jrd.timeline_update_sender.clone(),
-                update_receiver,
-                request_sender,
-                jrd.timeline.room().successor_room(),
-            ))
-        )
-        .map(|(update_sender, update_receiver, request_sender, successor_room)| {
-            TimelineEndpoints {
-                update_sender,
-                update_receiver,
-                request_sender,
-                successor_room,
-            }
-        })
+    let jrd = all_joined_rooms.get_mut(kind.room_id())?;
+    let details = match kind {
+        TimelineKind::MainRoom { .. } => &mut jrd.main_timeline,
+        TimelineKind::Thread { thread_root_event_id, .. } => jrd.thread_timelines.get_mut(thread_root_event_id)?,
+    };
+    let (update_receiver, request_sender) = details.timeline_singleton_endpoints.take()?;
+    Some(TimelineEndpoints {
+        update_sender: details.timeline_update_sender.clone(),
+        update_receiver,
+        request_sender,
+        successor_room: details.timeline.room().successor_room(),
+    })
 }
 
 const DEFAULT_HOMESERVER: &str = "matrix.org";
@@ -2731,7 +2885,7 @@ async fn update_room(
             let mut get_timeline_update_sender = |room_id| {
                 if __timeline_update_sender_opt.is_none() {
                     if let Some(jrd) = ALL_JOINED_ROOMS.lock().unwrap().get(room_id) {
-                        __timeline_update_sender_opt = Some(jrd.timeline_update_sender.clone());
+                        __timeline_update_sender_opt = Some(jrd.main_timeline.timeline_update_sender.clone());
                     }
                 }
                 __timeline_update_sender_opt.clone()
@@ -2863,6 +3017,10 @@ async fn add_new_room(
 
     let timeline = Arc::new(
         new_room.room.timeline_builder()
+            .with_focus(TimelineFocus::Live {
+                // we show threads as separate timelines in their own RoomScreen
+                hide_threaded_events: true,
+            })
             .track_read_marker_and_receipts(TimelineReadReceiptTracking::AllEvents)
             .build()
             .await
@@ -2876,6 +3034,7 @@ async fn add_new_room(
         timeline.clone(),
         timeline_update_sender.clone(),
         request_receiver,
+        None,
     ));
 
     // We need to add the room to the `ALL_JOINED_ROOMS` list before we can send
@@ -2886,10 +3045,14 @@ async fn add_new_room(
         new_room.room_id.clone(),
         JoinedRoomDetails {
             room_id: new_room.room_id.clone(),
-            timeline,
-            timeline_singleton_endpoints: Some((timeline_update_receiver, request_sender)),
-            timeline_update_sender,
-            timeline_subscriber_handler_task,
+            main_timeline: PerTimelineDetails {
+                timeline,
+                timeline_singleton_endpoints: Some((timeline_update_receiver, request_sender)),
+                timeline_update_sender,
+                timeline_subscriber_handler_task,
+            },
+            thread_timelines: HashMap::new(),
+            pending_thread_timelines: HashSet::new(),
             typing_notice_subscriber: None,
             pinned_events_subscriber: None,
         },
@@ -2965,8 +3128,10 @@ fn handle_ignore_user_list_subscriber(client: Client) {
                 // and currently the only way to actually accomplish this is via pagination.
                 // See: <https://github.com/matrix-org/matrix-rust-sdk/issues/1703#issuecomment-2250297923>
                 for joined_room in client.joined_rooms() {
-                    submit_async_request(MatrixRequest::PaginateRoomTimeline {
-                        room_id: joined_room.room_id().to_owned(),
+                    submit_async_request(MatrixRequest::PaginateTimeline {
+                        timeline_kind: TimelineKind::MainRoom {
+                            room_id: joined_room.room_id().to_owned(),
+                        },
                         num_events: 50,
                         direction: PaginationDirection::Backwards,
                     });
@@ -3143,6 +3308,121 @@ async fn fetch_room_preview_with_avatar(
     Ok(FetchedRoomPreview::from(room_preview, room_avatar))
 }
 
+/// Fetches key details about the given thread root event.
+///
+/// Returns a tuple of:
+/// 1. the number of replies in the thread (excluding the root event itself),
+/// 2. the latest reply event, if it could be fetched.
+async fn fetch_thread_summary_details(
+    room: &Room,
+    thread_root_event_id: &EventId,
+) -> (u32, Option<matrix_sdk::deserialized_responses::TimelineEvent>) {
+    let mut num_replies = 0;
+    let mut latest_reply_event = None;
+
+    if let Ok(thread_root_event) = room.load_or_fetch_event(thread_root_event_id, None).await
+        && let Some(thread_summary) = thread_root_event.thread_summary.summary()
+    {
+        num_replies = thread_summary.num_replies;
+
+        if let Some(latest_reply_event_id) = thread_summary.latest_reply.as_ref()
+            && let Ok(latest_reply) = room.load_or_fetch_event(latest_reply_event_id, None).await
+        {
+            latest_reply_event = Some(latest_reply);
+        }
+    }
+
+    if latest_reply_event.is_none() {
+        latest_reply_event = fetch_latest_thread_reply_event(room, thread_root_event_id).await;
+    }
+
+    // Always compute the reply count directly from the fetched thread relations,
+    // for some reason we can't rely on the SDK-provided thread_summary to be accurate
+    // (it's almost always totally wrong or out-of-date...).
+    if let Some(count) = count_thread_replies(room, thread_root_event_id).await {
+        num_replies = count;
+    }
+
+    (num_replies, latest_reply_event)
+}
+
+/// Fetches the latest reply event in the thread rooted at `thread_root_event_id`.
+async fn fetch_latest_thread_reply_event(
+    room: &Room,
+    thread_root_event_id: &EventId,
+) -> Option<matrix_sdk::deserialized_responses::TimelineEvent> {
+    let options = RelationsOptions {
+        dir: Direction::Backward,
+        limit: Some(uint!(1)),
+        include_relations: IncludeRelations::RelationsOfType(RelationType::Thread),
+        ..Default::default()
+    };
+
+    room.relations(thread_root_event_id.to_owned(), options)
+        .await
+        .ok()
+        .and_then(|relations| relations.chunk.into_iter().next())
+}
+
+/// Counts all replies in the given thread by paginating `/relations` in batches.
+async fn count_thread_replies(
+    room: &Room,
+    thread_root_event_id: &EventId,
+) -> Option<u32> {
+    let mut total_replies: u32 = 0;
+    let mut next_batch_token = None;
+
+    loop {
+        let options = RelationsOptions {
+            from: next_batch_token.clone(),
+            dir: Direction::Backward,
+            limit: Some(uint!(100)),
+            include_relations: IncludeRelations::RelationsOfType(RelationType::Thread),
+            ..Default::default()
+        };
+
+        let relations = room.relations(thread_root_event_id.to_owned(), options).await.ok()?;
+        if relations.chunk.is_empty() {
+            break;
+        }
+        total_replies = total_replies.saturating_add(relations.chunk.len() as u32);
+
+        next_batch_token = relations.next_batch_token;
+        if next_batch_token.is_none() {
+            break;
+        }
+    }
+
+    Some(total_replies)
+}
+
+/// Returns an HTML-formatted text preview of the given latest thread reply event.
+async fn text_preview_of_latest_thread_reply(
+    room: &Room,
+    latest_reply_event: &matrix_sdk::deserialized_responses::TimelineEvent,
+) -> Option<String> {
+    let raw = latest_reply_event.raw();
+    let sender_id = raw.get_field::<OwnedUserId>("sender").ok().flatten()?;
+    let sender_room_member = match room.get_member_no_sync(&sender_id).await {
+        Ok(Some(rm)) => Some(rm),
+        _ => room.get_member(&sender_id).await.ok().flatten(),
+    };
+    let sender_name = sender_room_member.as_ref()
+        .and_then(|rm| rm.display_name())
+        .unwrap_or(sender_id.as_str());
+    let text_preview = text_preview_of_raw_timeline_event(raw, sender_name).unwrap_or_else(|| {
+        let event_type = raw.get_field::<String>("type").ok().flatten();
+        TextPreview::from((
+            event_type.unwrap_or_else(|| "unknown event type".to_string()),
+            BeforeText::UsernameWithColon,
+        ))
+    });
+
+    Some(utils::replace_linebreaks_separators(
+        &text_preview.format_with(sender_name, true)
+    ))
+}
+
 
 /// Returns the timestamp and an HTML-formatted text preview of the given `latest_event`.
 ///
@@ -3226,14 +3506,16 @@ const LOG_TIMELINE_DIFFS: bool = cfg!(feature = "log_timeline_diffs");
 /// Whether to enable verbose logging of all room list service diff updates.
 const LOG_ROOM_LIST_DIFFS: bool = cfg!(feature = "log_room_list_diffs");
 
-/// A per-room async task that listens for timeline updates and sends them to the UI thread.
+/// A per-timeline async task that listens for timeline updates and sends them to the UI thread.
 ///
-/// One instance of this async task is spawned for each room the client knows about.
+/// One instance of this async task is spawned for each room the client knows about,
+/// and also one for each thread that the user opens in a thread view.
 async fn timeline_subscriber_handler(
     room: Room,
     timeline: Arc<Timeline>,
     timeline_update_sender: crossbeam_channel::Sender<TimelineUpdate>,
     mut request_receiver: watch::Receiver<Vec<BackwardsPaginateUntilEventRequest>>,
+    thread_root_event_id: Option<OwnedEventId>,
 ) {
 
     /// An inner function that searches the given new timeline items for a target event.
@@ -3262,14 +3544,14 @@ async fn timeline_subscriber_handler(
 
 
     let room_id = room.room_id().to_owned();
-    log!("Starting timeline subscriber for room {room_id}...");
+    log!("Starting timeline subscriber for room {room_id}, thread {thread_root_event_id:?}...");
     let (mut timeline_items, mut subscriber) = timeline.subscribe().await;
-    log!("Received initial timeline update of {} items for room {room_id}.", timeline_items.len());
+    log!("Received initial timeline update of {} items for room {room_id}, thread {thread_root_event_id:?}.", timeline_items.len());
 
     timeline_update_sender.send(TimelineUpdate::FirstUpdate {
         initial_items: timeline_items.clone(),
     }).unwrap_or_else(
-        |_e| panic!("Error: timeline update sender couldn't send first update ({} items) to room {room_id}!", timeline_items.len())
+        |_e| panic!("Error: timeline update sender couldn't send first update ({} items) to room {room_id}, thread {thread_root_event_id:?}...!", timeline_items.len())
     );
 
     // the event ID to search for while loading previous items into the timeline.
@@ -3305,7 +3587,7 @@ async fn timeline_subscriber_handler(
                         // Instead, we have no choice but to start from the end of the timeline.
                         timeline_items.len()
                     };
-                    // log!("Received new request to search for event {new_target_event_id} in room {room_id} starting from index {starting_index} (tl len {}).", timeline_items.len());
+                    // log!("Received new request to search for event {new_target_event_id} in room {room_id}, thread {thread_root_event_id:?} starting from index {starting_index} (tl len {}).", timeline_items.len());
                     // Search backwards for the target event in the timeline, starting from the given index.
                     if let Some(target_event_tl_index) = timeline_items
                         .focus()
@@ -3318,7 +3600,7 @@ async fn timeline_subscriber_handler(
                         )
                         .map(|i| starting_index.saturating_sub(i).saturating_sub(1))
                     {
-                        // log!("Found existing target event {new_target_event_id} in room {room_id} at index {target_event_tl_index}.");
+                        // log!("Found existing target event {new_target_event_id} in room {room_id}, thread {thread_root_event_id:?} at index {target_event_tl_index}.");
 
                         // Nice! We found the target event in the current timeline items,
                         // so there's no need to actually proceed with backwards pagination;
@@ -3331,20 +3613,29 @@ async fn timeline_subscriber_handler(
                                 index: target_event_tl_index,
                             }
                         ).unwrap_or_else(
-                            |_e| panic!("Error: timeline update sender couldn't send TargetEventFound({new_target_event_id}, {target_event_tl_index}) to room {room_id}!")
+                            |_e| panic!("Error: timeline update sender couldn't send TargetEventFound({new_target_event_id}, {target_event_tl_index}) to room {room_id}, thread {thread_root_event_id:?}!")
                         );
                         // Send a Makepad-level signal to update this room's timeline UI view.
                         SignalToUI::set_ui_signal();
                     }
                     else {
                         log!("Target event not in timeline. Starting backwards pagination \
-                            in room {room_id} to find target event {new_target_event_id} \
-                            starting from index {starting_index}.",
+                            in room {room_id}, thread {thread_root_event_id:?} to find target event \
+                            {new_target_event_id} starting from index {starting_index}.",
                         );
                         // If we didn't find the target event in the current timeline items,
                         // we need to start loading previous items into the timeline.
-                        submit_async_request(MatrixRequest::PaginateRoomTimeline {
-                            room_id: room_id.clone(),
+                        submit_async_request(MatrixRequest::PaginateTimeline {
+                            timeline_kind: if let Some(thread_root_event_id) = thread_root_event_id.clone() {
+                                TimelineKind::Thread {
+                                    room_id: room_id.clone(),
+                                    thread_root_event_id,
+                                }
+                            } else {
+                                TimelineKind::MainRoom {
+                                    room_id: room_id.clone(),
+                                }
+                            },
                             num_events: 50,
                             direction: PaginationDirection::Backwards,
                         });
@@ -3371,16 +3662,16 @@ async fn timeline_subscriber_handler(
                         index_of_first_change = min(index_of_first_change, timeline_items.len());
                         timeline_items.extend(values);
                         index_of_last_change = max(index_of_last_change, timeline_items.len());
-                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id} diff Append {_values_len}. Changes: {index_of_first_change}..{index_of_last_change}"); }
+                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id}, thread {thread_root_event_id:?} diff Append {_values_len}. Changes: {index_of_first_change}..{index_of_last_change}"); }
                         is_append = true;
                     }
                     VectorDiff::Clear => {
-                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id} diff Clear"); }
+                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id}, thread {thread_root_event_id:?} diff Clear"); }
                         clear_cache = true;
                         timeline_items.clear();
                     }
                     VectorDiff::PushFront { value } => {
-                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id} diff PushFront"); }
+                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id}, thread {thread_root_event_id:?} diff PushFront"); }
                         if let Some((index, _ev)) = found_target_event_id.as_mut() {
                             *index += 1; // account for this new `value` being prepended.
                         } else {
@@ -3394,11 +3685,11 @@ async fn timeline_subscriber_handler(
                         index_of_first_change = min(index_of_first_change, timeline_items.len());
                         timeline_items.push_back(value);
                         index_of_last_change = max(index_of_last_change, timeline_items.len());
-                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id} diff PushBack. Changes: {index_of_first_change}..{index_of_last_change}"); }
+                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id}, thread {thread_root_event_id:?} diff PushBack. Changes: {index_of_first_change}..{index_of_last_change}"); }
                         is_append = true;
                     }
                     VectorDiff::PopFront => {
-                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id} diff PopFront"); }
+                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id}, thread {thread_root_event_id:?} diff PopFront"); }
                         clear_cache = true;
                         timeline_items.pop_front();
                         if let Some((i, _ev)) = found_target_event_id.as_mut() {
@@ -3410,7 +3701,7 @@ async fn timeline_subscriber_handler(
                         timeline_items.pop_back();
                         index_of_first_change = min(index_of_first_change, timeline_items.len());
                         index_of_last_change = usize::MAX;
-                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id} diff PopBack. Changes: {index_of_first_change}..{index_of_last_change}"); }
+                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id}, thread {thread_root_event_id:?} diff PopBack. Changes: {index_of_first_change}..{index_of_last_change}"); }
                     }
                     VectorDiff::Insert { index, value } => {
                         if index == 0 {
@@ -3434,13 +3725,13 @@ async fn timeline_subscriber_handler(
                         }
 
                         timeline_items.insert(index, value);
-                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id} diff Insert at {index}. Changes: {index_of_first_change}..{index_of_last_change}"); }
+                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id}, thread {thread_root_event_id:?} diff Insert at {index}. Changes: {index_of_first_change}..{index_of_last_change}"); }
                     }
                     VectorDiff::Set { index, value } => {
                         index_of_first_change = min(index_of_first_change, index);
                         index_of_last_change  = max(index_of_last_change, index.saturating_add(1));
                         timeline_items.set(index, value);
-                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id} diff Set at {index}. Changes: {index_of_first_change}..{index_of_last_change}"); }
+                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id}, thread {thread_root_event_id:?} diff Set at {index}. Changes: {index_of_first_change}..{index_of_last_change}"); }
                     }
                     VectorDiff::Remove { index } => {
                         if index == 0 {
@@ -3456,7 +3747,7 @@ async fn timeline_subscriber_handler(
                             }
                         }
                         timeline_items.remove(index);
-                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id} diff Remove at {index}. Changes: {index_of_first_change}..{index_of_last_change}"); }
+                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id}, thread {thread_root_event_id:?} diff Remove at {index}. Changes: {index_of_first_change}..{index_of_last_change}"); }
                     }
                     VectorDiff::Truncate { length } => {
                         if length == 0 {
@@ -3466,10 +3757,10 @@ async fn timeline_subscriber_handler(
                             index_of_last_change = usize::MAX;
                         }
                         timeline_items.truncate(length);
-                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id} diff Truncate to length {length}. Changes: {index_of_first_change}..{index_of_last_change}"); }
+                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id}, thread {thread_root_event_id:?} diff Truncate to length {length}. Changes: {index_of_first_change}..{index_of_last_change}"); }
                     }
                     VectorDiff::Reset { values } => {
-                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id} diff Reset, new length {}", values.len()); }
+                        if LOG_TIMELINE_DIFFS { log!("timeline_subscriber: room {room_id}, thread {thread_root_event_id:?} diff Reset, new length {}", values.len()); }
                         clear_cache = true; // we must assume all items have changed.
                         timeline_items = values;
                     }
@@ -3490,7 +3781,7 @@ async fn timeline_subscriber_handler(
                 let changed_indices = index_of_first_change..index_of_last_change;
 
                 if LOG_TIMELINE_DIFFS {
-                    log!("timeline_subscriber: applied {num_updates} updates for room {room_id}, timeline now has {} items. is_append? {is_append}, clear_cache? {clear_cache}. Changes: {changed_indices:?}.", timeline_items.len());
+                    log!("timeline_subscriber: applied {num_updates} updates for room {room_id}, thread {thread_root_event_id:?}, timeline now has {} items. is_append? {is_append}, clear_cache? {clear_cache}. Changes: {changed_indices:?}.", timeline_items.len());
                 }
                 timeline_update_sender.send(TimelineUpdate::NewItems {
                     new_items: timeline_items.clone(),
@@ -3509,7 +3800,7 @@ async fn timeline_subscriber_handler(
                             index,
                         }
                     ).unwrap_or_else(
-                        |_e| panic!("Error: timeline update sender couldn't send TargetEventFound({found_event_id}, {index}) to room {room_id}!")
+                        |_e| panic!("Error: timeline update sender couldn't send TargetEventFound({found_event_id}, {index}) to room {room_id}, thread {thread_root_event_id:?}!")
                     );
                 }
 
@@ -3523,7 +3814,7 @@ async fn timeline_subscriber_handler(
         }
     } }
 
-    error!("Error: unexpectedly ended timeline subscriber for room {room_id}.");
+    error!("Error: unexpectedly ended timeline subscriber for room {room_id}, thread {thread_root_event_id:?}.");
 }
 
 /// Spawn a new async task to fetch the room's new avatar.
diff --git a/src/utils.rs b/src/utils.rs
index 7c5ee6d0..36622733 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -8,7 +8,10 @@ use makepad_widgets::{Cx, Event, ImageRef, error, image_cache::ImageError};
 use matrix_sdk::{media::{MediaFormat, MediaThumbnailSettings}, ruma::{api::client::media::get_content_thumbnail::v3::Method, MilliSecondsSinceUnixEpoch, OwnedRoomId, RoomId}, RoomDisplayName};
 use matrix_sdk_ui::timeline::{EventTimelineItem, PaginationError, TimelineDetails};
 
-use crate::{room::FetchedRoomAvatar, sliding_sync::{submit_async_request, MatrixRequest}};
+use crate::{
+    room::FetchedRoomAvatar,
+    sliding_sync::{submit_async_request, MatrixRequest, TimelineKind},
+};
 
 /// The scheme for GEO links, used for location messages in Matrix.
 pub const GEO_URI_SCHEME: &str = "geo:";
@@ -629,7 +632,9 @@ pub fn get_or_fetch_event_sender(
             if let Some(room_id) = room_id {
                 if let Some(event_id) = event_tl_item.event_id() {
                     submit_async_request(MatrixRequest::FetchDetailsForEvent {
-                        room_id: room_id.clone(),
+                        timeline_kind: TimelineKind::MainRoom {
+                            room_id: room_id.clone(),
+                        },
                         event_id: event_id.to_owned(),
                     });
                 }