diff --git a/Cargo.lock b/Cargo.lock
index fad88d2d..1d6fa1fc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4669,6 +4669,7 @@ dependencies = [
  "quinn",
  "rand 0.8.5",
  "rangemap",
+ "regex",
  "reqwest",
  "robius-directories",
  "robius-location",
diff --git a/Cargo.toml b/Cargo.toml
index aef2e8c4..0ba6f2a4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -73,6 +73,7 @@ bytesize = "2.0"
 bitflags = "2.6.0"
 indexmap = "2.6.0"
 blurhash = { version = "0.2.3", default-features = false }
+regex = "1.11.1"
 
 ## Dependencies for TSP support.
 tsp_sdk = { git = "https://github.com/openwallet-foundation-labs/tsp.git", optional = true, features = ["async", "resolve"] }
diff --git a/src/app.rs b/src/app.rs
index 174e89fb..d96a540d 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -10,7 +10,7 @@ use makepad_widgets::{makepad_micro_serde::*, *};
 use matrix_sdk::ruma::{OwnedRoomId, RoomId};
 use crate::{
     avatar_cache::clear_avatar_cache, home::{
-        main_desktop_ui::MainDesktopUiAction, new_message_context_menu::NewMessageContextMenuWidgetRefExt, room_screen::{clear_timeline_states, MessageAction}, rooms_list::{clear_all_invited_rooms, enqueue_rooms_list_update, RoomsListAction, RoomsListRef, RoomsListUpdate}
+        home_screen::MessageSearchInputAction, main_desktop_ui::MainDesktopUiAction, new_message_context_menu::NewMessageContextMenuWidgetRefExt, room_screen::{clear_timeline_states, MessageAction}, rooms_list::{clear_all_invited_rooms, enqueue_rooms_list_update, RoomsListAction, RoomsListRef, RoomsListUpdate}
     }, join_leave_room_modal::{
         JoinLeaveModalKind, JoinLeaveRoomModalAction, JoinLeaveRoomModalWidgetRefExt
     }, login::login_screen::LoginAction, logout::logout_confirm_modal::{LogoutAction, LogoutConfirmModalAction, LogoutConfirmModalWidgetRefExt}, persistence, profile::user_profile_cache::clear_user_profile_cache, room::BasicRoomDetails, shared::callout_tooltip::{
@@ -170,6 +170,7 @@ impl LiveRegister for App {
         crate::settings::live_design(cx);
         crate::room::live_design(cx);
         crate::join_leave_room_modal::live_design(cx);
+        crate::right_drawer::live_design(cx);
         crate::verification_modal::live_design(cx);
         crate::home::live_design(cx);
         crate::profile::live_design(cx);
@@ -287,6 +288,11 @@ impl MatchEvent for App {
                     &Scope::default().path,
                     StackNavigationAction::Push(live_id!(main_content_view))
                 );
+                cx.widget_action(
+                    self.ui.widget_uid(),
+                    &Scope::default().path,
+                    MessageSearchInputAction::Show
+                );
                 self.ui.redraw(cx);
                 continue;
             }
@@ -295,10 +301,20 @@ impl MatchEvent for App {
             match action.downcast_ref() {
                 Some(AppStateAction::RoomFocused(selected_room)) => {
                     self.app_state.selected_room = Some(selected_room.clone());
+                    cx.widget_action(
+                        self.ui.widget_uid(),
+                        &Scope::default().path,
+                        MessageSearchInputAction::Show
+                    );
                     continue;
                 }
                 Some(AppStateAction::FocusNone) => {
                     self.app_state.selected_room = None;
+                    cx.widget_action(
+                        self.ui.widget_uid(),
+                        &Scope::default().path,
+                        MessageSearchInputAction::Hide
+                    );
                     continue;
                 }
                 Some(AppStateAction::UpgradedInviteToJoinedRoom(room_id)) => {
@@ -677,7 +693,7 @@ impl Eq for SelectedRoom {}
 /// Actions sent to the top-level App in order to update / restore its [`AppState`].
 ///
 /// These are *NOT* widget actions.
-#[derive(Debug)]
+#[derive(Debug, Clone, Default)]
 pub enum AppStateAction {
     /// The given room was focused (selected).
     RoomFocused(SelectedRoom),
@@ -698,5 +714,6 @@ pub enum AppStateAction {
         room_to_close: Option<OwnedRoomId>,
         destination_room: BasicRoomDetails,
     },
+    #[default]
     None,
 }
diff --git a/src/home/home_screen.rs b/src/home/home_screen.rs
index 2b604116..7dd52775 100644
--- a/src/home/home_screen.rs
+++ b/src/home/home_screen.rs
@@ -1,6 +1,6 @@
 use makepad_widgets::*;
 
-use crate::settings::{settings_screen::SettingsScreenWidgetRefExt, SettingsAction};
+use crate::{settings::{settings_screen::SettingsScreenWidgetRefExt, SettingsAction}, shared::message_search_input_bar::{MessageSearchAction, MessageSearchInputBarRef, MessageSearchInputBarWidgetExt}};
 
 live_design! {
     use link::theme::*;
@@ -12,8 +12,12 @@ live_design! {
     use crate::home::spaces_dock::SpacesDock;
     use crate::shared::styles::*;
     use crate::shared::room_filter_input_bar::RoomFilterInputBar;
+    use crate::shared::message_search_input_bar::MessageSearchInputBar;
+    use crate::shared::icon_button::RobrixIconButton;
     use crate::home::main_desktop_ui::MainDesktopUI;
+    use crate::home::search_message::SearchResultStackView;
     use crate::settings::settings_screen::SettingsScreen;
+    use crate::right_drawer::RightDrawer;
 
     NavigationWrapper = {{NavigationWrapper}} {
         view_stack = <StackNavigation> {}
@@ -52,10 +56,35 @@ live_design! {
                         width: Fill, height: Fill
                         flow: Down
 
-                        <CachedWidget> {
-                            room_filter_input_bar = <RoomFilterInputBar> {}
+                        <View> {
+                            width: Fill, height: Fit
+                            flow: Right,
+
+                            <CachedWidget> {
+                                room_filter_input_bar = <RoomFilterInputBar> {
+                                    align: {x: 0.0 }
+                                }
+                            }
+                            message_search_input_view = <View> {
+                                width: Fill, height: Fit,
+                                visible: false,
+                                align: {x: 1.0},
+
+                                <CachedWidget> {
+                                    message_search_input_bar = <MessageSearchInputBar> {
+                                        width: 300,
+                                    }
+                                }
+                            }
+                        }
+
+                        <View> {
+                            width: Fill, height: Fill
+                            flow: Right
+                            
+                            <MainDesktopUI> {}
+                            <RightDrawer> {}
                         }
-                        <MainDesktopUI> {}
                     }
 
                     settings_page = <View> {
@@ -128,12 +157,56 @@ live_design! {
                                             }
                                         }
                                     }
+                                    <View> {
+                                        height: Fit,
+                                        width: Fill,
+                                        align: {x: 1.0 }
+                                        <View> {
+                                            height: Fit,
+                                            width: 140,
+                                            <CachedWidget> {
+                                                message_search_input_bar = <MessageSearchInputBar> {
+                                                    width: 300
+                                                }
+                                            }
+                                        }
+                                    }
                                 }
                             }
                             body = {
                                 main_content = <MainMobileUI> {}
                             }
                         }
+                        search_result_view = <SearchResultStackView> {
+                            flow: Overlay
+                            header = {
+                                height: 50.0,
+                                margin: { top: 30.0 },
+                                content = {
+                                    flow: Right,
+                                    title_container = {
+                                        width: 0
+                                    }
+                                    button_container = <View> {
+                                        align: { y: 0.5 }
+                                        left_button = <RobrixIconButton> {
+                                            draw_icon: {
+                                                color: #666;
+                                            }
+                                            text: "Back"
+                                        }
+                                    }
+                                    <CachedWidget> {
+                                        message_search_input_bar = <MessageSearchInputBar> {
+                                            width: 300
+                                        }
+                                    }
+                                }
+                            }
+                            body = {
+                                margin: { top: 80.0 },
+                            }
+                        }
                     }
                 }
             }
@@ -188,6 +261,29 @@ impl Widget for HomeScreen {
                     }
                     _ => {}
                 }
+                match action.as_widget_action().cast() {
+                    MessageSearchInputAction::Show => {
+                        if !cx.has_global::<MessageSearchInputBarRef>() {
+                            if self.view.message_search_input_bar(id!(message_search_input_bar)).borrow().is_some() {
+                                Cx::set_global(cx, self.view.message_search_input_bar(id!(message_search_input_bar)));
+                            }
+                        }
+                        self.view.view(id!(message_search_input_view)).set_visible(cx, true)
+                    },
+                    MessageSearchInputAction::Hide => self.view.view(id!(message_search_input_view)).set_visible(cx, false),
+                }
+
+                if let MessageSearchAction::Clicked = action.as_widget_action().cast() {
+                    if !self.view
+                        .stack_navigation(id!(view_stack))
+                        .stack_view_ids().contains(&live_id!(search_result_view)) {
+                            cx.widget_action(
+                                self.widget_uid(),
+                                &Scope::default().path,
+                                StackNavigationAction::Push(live_id!(search_result_view))
+                            );
+                        }
+                }
             }
         }
 
@@ -242,3 +338,11 @@ impl MatchEvent for NavigationWrapper {
             .handle_stack_view_actions(cx, actions);
     }
 }
+
+/// An action that controls the visibility of the message search input bar.
+#[derive(Clone, Debug, Default)]
+pub enum MessageSearchInputAction {
+    #[default]
+    Show,
+    Hide,
+}
diff --git a/src/home/main_desktop_ui.rs b/src/home/main_desktop_ui.rs
index 9657c843..acef2ff9 100644
--- a/src/home/main_desktop_ui.rs
+++ b/src/home/main_desktop_ui.rs
@@ -3,7 +3,7 @@ use matrix_sdk::ruma::OwnedRoomId;
 use tokio::sync::Notify;
 use std::{collections::HashMap, sync::Arc};
 
-use crate::{app::{AppState, AppStateAction, SelectedRoom}, utils::room_name_or_id};
+use crate::{app::{AppState, AppStateAction, SelectedRoom}, shared::message_search_input_bar::{MessageSearchAction, MessageSearchInputBarRef}, utils::room_name_or_id};
 use super::{invite_screen::InviteScreenWidgetRefExt, room_screen::RoomScreenWidgetRefExt, rooms_list::RoomsListAction};
 
 live_design! {
@@ -172,7 +172,13 @@ impl MainDesktopUI {
         }
 
         self.open_rooms.insert(room_id_as_live_id, room.clone());
-        self.most_recently_selected_room = Some(room);
+        self.most_recently_selected_room = Some(room.clone());
+        // Call AppStateAction::RoomFocused action to display the search message input box when a room is open.
+        cx.widget_action(
+            self.widget_uid(), 
+            &HeapLiveIdPath::default(), 
+            AppStateAction::RoomFocused(room)
+        );
     }
 
     /// Closes a tab in the dock and focuses on the latest open room.
@@ -206,6 +212,10 @@ impl MainDesktopUI {
         dock.close_tab(cx, tab_id);
         self.tab_to_close = None;
         self.open_rooms.remove(&tab_id);
+        // Clear the search input when a room is closed
+        cx.get_global::<MessageSearchInputBarRef>().set_text("");
+        // Clear the search results when a room is closed
+        cx.widget_action(self.widget_uid(), &Scope::empty().path, MessageSearchAction::Changed(String::new()));
     }
 
     /// Closes all tabs
@@ -384,6 +394,13 @@ impl WidgetMatchEvent for MainDesktopUI {
 
                     if let Some(ref selected_room) = &app_state.selected_room {
                         self.focus_or_create_tab(cx, selected_room.clone());
+                    } else {
+                        // If there is no selected room, focus on the home tab.
+                        cx.widget_action(
+                            self.widget_uid(),
+                            &HeapLiveIdPath::default(),
+                            AppStateAction::FocusNone,
+                        );
                     }
                     self.view.redraw(cx);
                 }
diff --git a/src/home/mod.rs b/src/home/mod.rs
index e4ab4bfd..071a6813 100644
--- a/src/home/mod.rs
+++ b/src/home/mod.rs
@@ -20,6 +20,7 @@ pub mod spaces_dock;
 pub mod welcome_screen;
 pub mod event_reaction_list;
 pub mod new_message_context_menu;
+pub mod search_message;
 
 pub fn live_design(cx: &mut Cx) {
     home_screen::live_design(cx);
@@ -42,4 +43,5 @@ pub fn live_design(cx: &mut Cx) {
     welcome_screen::live_design(cx);
     light_themed_dock::live_design(cx);
     event_reaction_list::live_design(cx);
+    search_message::live_design(cx);
 }
diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 7506fa8d..8d3a6e47 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -26,7 +26,7 @@ use matrix_sdk_ui::timeline::{
 };
 
 use crate::{
-    app::AppStateAction, avatar_cache, event_preview::{plaintext_body_of_timeline_item, text_preview_of_encrypted_message, text_preview_of_member_profile_change, text_preview_of_other_state, text_preview_of_redacted_message, text_preview_of_room_membership_change, text_preview_of_timeline_item}, home::{edited_indicator::EditedIndicatorWidgetRefExt, editing_pane::EditingPaneState, loading_pane::{LoadingPaneState, LoadingPaneWidgetExt}, rooms_list::RoomsListRef, tombstone_footer::TombstoneFooterWidgetExt}, location::init_location_subscriber, media_cache::{MediaCache, MediaCacheEntry}, profile::{
+    app::{AppStateAction, 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_state, text_preview_of_redacted_message, text_preview_of_room_membership_change, text_preview_of_timeline_item}, home::{edited_indicator::EditedIndicatorWidgetRefExt, editing_pane::EditingPaneState, loading_pane::{LoadingPaneState, LoadingPaneWidgetExt}, rooms_list::{RoomsListAction, RoomsListRef}, tombstone_footer::TombstoneFooterWidgetExt}, location::init_location_subscriber, media_cache::{MediaCache, MediaCacheEntry}, profile::{
         user_profile::{AvatarState, ShowUserProfileAction, UserProfile, UserProfileAndRoomId, UserProfilePaneInfo, UserProfileSlidingPaneRef, UserProfileSlidingPaneWidgetExt},
         user_profile_cache,
     }, shared::{
@@ -37,7 +37,7 @@ use crate::home::event_reaction_list::ReactionListWidgetRefExt;
 use crate::home::room_read_receipt::AvatarRowWidgetRefExt;
 use crate::room::room_input_bar::RoomInputBarWidgetExt;
 use crate::shared::mentionable_text_input::{MentionableTextInputWidgetRefExt, MentionableTextInputAction};
-
+use std::num::NonZeroU32;
 use rangemap::RangeSet;
 
 use super::{editing_pane::{EditingPaneAction, EditingPaneWidgetExt}, event_reaction_list::ReactionData, loading_pane::LoadingPaneRef, location_preview::LocationPreviewWidgetExt, new_message_context_menu::{MessageAbilities, MessageDetails}, room_read_receipt::{self, populate_read_receipts, MAX_VISIBLE_AVATARS_IN_READ_RECEIPT}};
@@ -51,10 +51,14 @@ const GEO_URI_SCHEME: &str = "geo:";
 /// from getting into a long-running loop if an event cannot be found quickly.
 const MAX_ITEMS_TO_SEARCH_THROUGH: usize = 100;
 
+/// The time required to scroll to the targeted message in milliseconds.
+/// 
+/// This value cannot be zero.
+const SMOOTH_SCROLL_TIME: NonZeroU32 = NonZeroU32::new(500).unwrap();
+
 /// The max size (width or height) of a blurhash image to decode.
 const BLURHASH_IMAGE_MAX_SIZE: u32 = 500;
 
-
 live_design! {
     use link::theme::*;
     use link::shaders::*;
@@ -207,10 +211,10 @@ live_design! {
 
 
     // An empty view that takes up no space in the portal list.
-    Empty = <View> { }
+    pub Empty = <View> { }
 
     // The view used for each text-based message event in a room's timeline.
-    Message = {{Message}} {
+    pub Message = {{Message}} {
         width: Fill,
         height: Fit,
         margin: 0.0
@@ -339,6 +343,28 @@ live_design! {
                         }
                         text: "<Username not available>"
                     }
+
+                    jump_to_this_message = <View> {
+                        visible: false,
+                        width: Fit,
+                        height: Fit,
+
+                        jump_button = <Button> {
+                            width: Fit,
+                            draw_bg: {
+                                color_hover: (COLOR_FG_DISABLED)
+                            }
+                            draw_text: {
+                                text_style: <REGULAR_TEXT>{
+                                    font_size: 9,
+                                },
+                                color: (COLOR_TEXT),
+                                color_hover: (COLOR_TEXT_IDLE),
+                                color_focus: (COLOR_TEXT),
+                            }
+                            text: "Jump"
+                        }
+                    }
                 }
 
                 message = <HtmlOrPlaintext> { }
@@ -398,7 +424,7 @@ live_design! {
 
     // The view used for each static image-based message event in a room's timeline.
     // This excludes stickers and other animated GIFs, video clips, audio clips, etc.
-    ImageMessage = <Message> {
+    pub ImageMessage = <Message> {
         body = {
             content = {
                 width: Fill,
@@ -815,6 +841,8 @@ pub struct RoomScreen {
     #[rust] is_loaded: bool,
     /// Whether or not all rooms have been loaded (received from the homeserver).
     #[rust] all_rooms_loaded: bool,
+    /// Whether the timeline loaded notification has been sent for the current room.
+    #[rust] timeline_loaded_notified: bool,
 }
 impl Drop for RoomScreen {
     fn drop(&mut self) {
@@ -1462,6 +1490,7 @@ impl RoomScreen {
     fn process_timeline_updates(&mut self, cx: &mut Cx, portal_list: &PortalListRef) {
         let top_space = self.view(id!(top_space));
         let jump_to_bottom = self.jump_to_bottom_button(id!(jump_to_bottom));
+        let loading_pane = self.loading_pane(id!(loading_pane));
         let curr_first_id = portal_list.first_id();
         let ui = self.widget_uid();
         let Some(tl) = self.tl_state.as_mut() else { return };
@@ -1740,6 +1769,60 @@ impl RoomScreen {
                     }
                     tl.tombstone_info = tombstone_info;
                 }
+                TimelineUpdate::ScrollToMessage { event_id } => {
+                    // Search through the timeline to find the message with the given event_id
+                    let mut num_items_searched = 0;
+                    let target_msg_tl_index = tl.items
+                        .focus()
+                        .into_iter()
+                        .position(|item| {
+                            num_items_searched += 1;
+                            item.as_event()
+                                .and_then(|e| e.event_id())
+                                .is_some_and(|ev_id| ev_id == event_id)
+                        });
+                    if let Some(index) = target_msg_tl_index {
+                        let current_first_index = portal_list.first_id();
+                        let speed = index.saturating_sub(1).abs_diff(current_first_index) as f64 / (SMOOTH_SCROLL_TIME.get() as f64 * 0.001);
+                        portal_list.smooth_scroll_to(
+                            cx,
+                            index.saturating_sub(1),
+                            speed,
+                            None,
+                        );
+                        // start highlight animation.
+                        tl.message_highlight_animation_state = MessageHighlightAnimationState::Pending {
+                            item_id: index
+                        };
+                    } else {
+                        log!("Message not found - trigger backwards pagination to find it");
+                        // Message not found - trigger backwards pagination to find it
+                        loading_pane.set_state(
+                            cx,
+                            LoadingPaneState::BackwardsPaginateUntilEvent {
+                                target_event_id: event_id.clone(),
+                                events_paginated: 0,
+                                request_sender: tl.request_sender.clone(),
+                            },
+                        );
+                        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) {
+                                // Re-use existing request
+                                existing.target_event_id = event_id.clone();
+                            } else {
+                                requests.push(BackwardsPaginateUntilEventRequest {
+                                    room_id: tl.room_id.clone(),
+                                    target_event_id: event_id.clone(),
+                                    starting_index: 0, // Search from the beginning since we don't know where it is
+                                    current_tl_len: tl.items.len(),
+                                });
+                            }
+                            true
+                        });
+                    }
+                }
             }
         }
 
@@ -2557,6 +2640,8 @@ impl RoomScreen {
         self.loading_pane(id!(loading_pane)).take_state();
         self.room_name = room_name_or_id(room_name.into(), &room_id);
         self.room_id = Some(room_id.clone());
+        // Reset timeline loaded notification flag for the new room
+        self.timeline_loaded_notified = false;
 
         // We initially tell every MentionableTextInput widget that the current user
         // *does not* has privileges to notify the entire room;
@@ -2818,6 +2903,10 @@ pub enum TimelineUpdate {
     /// includes a `SuccessorRoom` that contains the successor room.
     /// If the room is not tombstoned, then the `SuccessorRoom` is `None`.
     Tombstoned(Option<SuccessorRoom>),
+    /// A notice that portal list is required to scroll to the given event.
+    ScrollToMessage {
+        event_id: OwnedEventId,
+    }
 }
 
 thread_local! {
@@ -3020,22 +3109,22 @@ fn find_new_item_matching_current_item(
 }
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
-struct ItemDrawnStatus {
+pub struct ItemDrawnStatus {
     /// Whether the profile info (avatar and displayable username) were drawn for this item.
-    profile_drawn: bool,
+    pub profile_drawn: bool,
     /// Whether the content of the item was drawn (e.g., the message text, image, video, sticker, etc).
-    content_drawn: bool,
+    pub content_drawn: bool,
 }
 impl ItemDrawnStatus {
     /// Returns a new `ItemDrawnStatus` with both `profile_drawn` and `content_drawn` set to `false`.
-    const fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             profile_drawn: false,
             content_drawn: false,
         }
     }
     /// Returns a new `ItemDrawnStatus` with both `profile_drawn` and `content_drawn` set to `true`.
-    const fn both_drawn() -> Self {
+    pub const fn both_drawn() -> Self {
         Self {
             profile_drawn: true,
             content_drawn: true,
@@ -3573,7 +3662,7 @@ fn populate_message_view(
 }
 
 /// Draws the Html or plaintext body of the given Text or Notice message into the `message_content_widget`.
-fn populate_text_message_content(
+pub fn populate_text_message_content(
     cx: &mut Cx,
     message_content_widget: &HtmlOrPlaintextRef,
     body: &str,
@@ -4332,6 +4421,16 @@ pub enum MessageAction {
     None,
 }
 
+/// Contains the information needed to jump to a specific message.
+/// Used primarily for search results to allow navigation to the original message location.
+#[derive(Clone, Debug)]
+pub struct JumpToMessageRequest {
+    /// The room ID where the target message is located.
+    pub room_id: OwnedRoomId,
+    /// The event ID of the target message.
+    pub event_id: OwnedEventId,
+}
+
 /// A widget representing a single message of any kind within a room timeline.
 #[derive(Live, LiveHook, Widget)]
 pub struct Message {
@@ -4339,6 +4438,9 @@ pub struct Message {
     #[animator] animator: Animator,
 
     #[rust] details: Option<MessageDetails>,
+    /// The jump option required for searched messages.
+    /// Contains the room ID, event ID for the message to jump to.
+    #[rust] jump_option: Option<JumpToMessageRequest>,
 }
 
 impl Widget for Message {
@@ -4352,7 +4454,35 @@ impl Widget for Message {
         {
             self.animator_play(cx, id!(highlight.off));
         }
-
+        // If this message is a search result with a jump option, handle clicks on the
+        // "Jump" button.
+        if let Some(jump_request) = &self.jump_option {
+            if let Event::Actions(actions) = event {
+                if self.view.button(id!(jump_to_this_message.jump_button)).clicked(actions) {
+                    cx.widget_action(
+                        self.widget_uid(),
+                        &Scope::default().path,
+                        StackNavigationAction::PopToRoot
+                    );
+                    let room_name: Option<String> = {
+                        let rooms_list_ref = cx.get_global::<RoomsListRef>();
+                        rooms_list_ref.get_room_name(&jump_request.room_id)
+                    };
+                    let target_selected_room = SelectedRoom::JoinedRoom {
+                        room_id: jump_request.room_id.clone().into(),
+                        room_name,
+                    };
+                    cx.widget_action(
+                        self.widget_uid(),
+                        &scope.path,
+                        RoomsListAction::Selected(target_selected_room)
+                    );
+                    submit_async_request(MatrixRequest::WaitForRoomTimelineLoadedToJump { room_id: jump_request.room_id.clone(), event_id: jump_request.event_id.clone() });
+                }
+            }
+            self.view.handle_event(cx, event, scope);
+            return;
+        }
         let Some(details) = self.details.clone() else { return };
 
         // We first handle a click on the replied-to message preview, if present,
@@ -4474,6 +4604,15 @@ impl Message {
     fn set_data(&mut self, details: MessageDetails) {
         self.details = Some(details);
     }
+
+    /// If there is a jump option, show the jump button at the top right corner.
+    /// 
+    /// Used primarily for search results to allow navigation to the original message location.
+    pub fn set_jump_option(&mut self, cx: &mut Cx, jump_option: JumpToMessageRequest) {
+        self.jump_option = Some(jump_option);
+        self.view.view(id!(jump_to_this_message))
+            .set_visible(cx, true);
+    }
 }
 
 impl MessageRef {
@@ -4481,6 +4620,12 @@ impl MessageRef {
         let Some(mut inner) = self.borrow_mut() else { return };
         inner.set_data(details);
     }
+
+    /// See [`Message::set_jump_option()`].
+    pub fn set_jump_option(&self, cx: &mut Cx, jump_option: JumpToMessageRequest) {
+        let Some(mut inner) = self.borrow_mut() else { return };
+        inner.set_jump_option(cx, jump_option);
+    }
 }
 
 /// Clears all UI-related timeline states for all known rooms.
diff --git a/src/home/rooms_list.rs b/src/home/rooms_list.rs
index b94e7047..4676b796 100644
--- a/src/home/rooms_list.rs
+++ b/src/home/rooms_list.rs
@@ -226,6 +226,8 @@ pub struct JoinedRoomInfo {
     pub is_direct: bool,
     /// Whether this room is tombstoned (shut down and replaced with a successor room).
     pub is_tombstoned: bool,
+    /// Whether this room is currently encrypted.
+    pub is_room_encrypted: bool,
 }
 
 /// UI-related info about a room that the user has been invited to.
@@ -796,8 +798,36 @@ impl RoomsList {
                     .map(|room_info| (room_info.room_avatar.clone(), room_info.room_name.clone()))
             })
     }
+
+    /// Returns the name of the room associated with the given room_id if it exists.
+    pub fn get_room_name(&self, room_id: &OwnedRoomId) -> Option<String> {
+        self.all_joined_rooms.get(room_id).and_then(|room| room.room_name.clone())
+    }
+
+    /// Returns `true` if the room associated with the given room_id is encrypted.
+    pub fn is_room_encrypted(&self, room_id: &OwnedRoomId) -> bool {
+        self.all_joined_rooms.get(room_id).map(|room| room.is_room_encrypted).unwrap_or(false)
+    }
 }
+impl RoomsListRef {
+    // See [`RoomsList::get_room_name`].
+    pub fn get_room_name(&self, room_id: &OwnedRoomId) -> Option<String> {
+        if let Some(inner) = self.borrow() {
+            inner.get_room_name(room_id)
+        } else {
+            None
+        }
+    }
 
+    // See [`RoomsList::is_room_encrypted`].
+    pub fn is_room_encrypted(&self, room_id: &OwnedRoomId) -> bool {
+        if let Some(inner) = self.borrow() {
+            inner.is_room_encrypted(room_id)
+        } else {
+            false
+        }
+    }
+}
 impl Widget for RoomsList {
     fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
         // Process all pending updates to the list of all rooms, and then redraw it.
diff --git a/src/home/search_message.rs b/src/home/search_message.rs
new file mode 100644
index 00000000..690d5116
--- /dev/null
+++ b/src/home/search_message.rs
@@ -0,0 +1,1199 @@
+//! The SearchResult is the widget that contains search results interface for Desktop's right drawer.
+//!
+//! The SearchResultStackView is the stack navigation view that contains the `SearchResult` widget for Mobile view.
+use std::{borrow::Cow, collections::BTreeMap, ops::DerefMut};
+use regex::Regex;
+
+use imbl::Vector;
+use makepad_widgets::*;
+use matrix_sdk::ruma::{
+    api::client::{filter::RoomEventFilter, search::search_events::v3::{Criteria as MatrixCriteria, EventContext, OrderBy}}, events::{
+        room::message::{
+            AudioMessageEventContent, EmoteMessageEventContent, FileMessageEventContent, FormattedBody, ImageMessageEventContent, KeyVerificationRequestEventContent, MessageType, NoticeMessageEventContent, RoomMessageEventContent, TextMessageEventContent, VideoMessageEventContent
+        }, AnyTimelineEvent
+    }, uint, OwnedRoomId, OwnedUserId
+};
+use matrix_sdk_ui::timeline::{Profile, TimelineDetails};
+use rangemap::RangeSet;
+
+use crate::{
+    app::{AppState, AppStateAction},
+    home::{
+        room_screen::{
+            populate_text_message_content, ItemDrawnStatus, JumpToMessageRequest, MessageWidgetRefExt,
+        },
+        rooms_list::RoomsListRef,
+    },
+    shared::{
+        avatar::AvatarWidgetRefExt, html_or_plaintext::HtmlOrPlaintextWidgetRefExt, message_search_input_bar::{MessageSearchAction, MessageSearchInputBarRef}, popup_list::{enqueue_popup_notification, PopupItem, PopupKind}, timestamp::TimestampWidgetRefExt
+    },
+    sliding_sync::{submit_async_request, MatrixRequest},
+    utils::unix_time_millis_to_datetime,
+};
+
+// Consider extracting this constant
+const SEARCH_HIGHLIGHT_COLOR: &str = "#fcdb03";
+
+live_design! {
+    use link::theme::*;
+    use link::shaders::*;
+    use link::widgets::*;
+    use crate::shared::styles::*;
+    use crate::shared::helpers::*;
+    use crate::shared::icon_button::RobrixIconButton;
+    use crate::home::room_screen::*;
+
+    COLOR_BUTTON_GREY = #B6BABF
+
+    // The bottom space is used to display a loading message while the room is being paginated.
+    BottomSpace = <View> {
+        width: Fill, height: Fit,
+        visible: true,
+        align: {x: 0.5, y: 0}
+        show_bg: true,
+        draw_bg: {
+            color: #xDAF5E5F0, // mostly opaque light green
+        }
+        flow: Right,
+
+        label = <Label> {
+            width: Fit, height: Fit,
+            align: {x: 0.5, y: 0.5},
+            padding: { top: 10.0, bottom: 7.0, left: 15.0, right: 15.0 }
+            draw_text: {
+                text_style: <MESSAGE_TEXT_STYLE> { font_size: 10 },
+                color: (TIMESTAMP_TEXT_COLOR)
+            }
+            text: "Loading older search results..."
+        }
+        <LoadingSpinner> {
+            width: 20,
+            height: Fill,
+            visible: true,
+            draw_bg: {
+                color: (COLOR_ACTIVE_PRIMARY)
+                border_size: 3.0,
+            }
+        }
+    }
+
+    SearchIcon = <Icon> {
+        width: Fit, height: Fit,
+        margin: {top: 0, left: 10},
+        align: {x: 0.0}
+        spacing: 10,
+        padding: 10,
+        draw_bg: {
+            instance color: (COLOR_BUTTON_GREY)
+            instance color_hover: #fef65b
+            uniform border_width: 1.5
+            uniform border_radius: 4.0
+            uniform hover: 0.0
+            fn get_color(self) -> vec4 {
+                return mix(self.color, mix(self.color, self.color_hover, 0.2), self.hover)
+            }
+            fn pixel(self) -> vec4 {
+                let sdf = Sdf2d::viewport(self.pos * self.rect_size);
+                sdf.box(
+                    self.border_width,
+                    self.border_width,
+                    self.rect_size.x - self.border_width * 2.0,
+                    self.rect_size.y - self.border_width * 2.0,
+                    max(1.0, self.border_radius)
+                )
+                sdf.fill(self.get_color());
+                return sdf.result;
+            }
+        }
+        draw_icon: {
+            svg_file: (ICON_SEARCH),
+            fn get_color(self) -> vec4 {
+                return (COLOR_TEXT_INPUT_IDLE);
+            }
+        }
+        icon_walk: {width: 16, height: 16}
+    }
+
+    SearchResultSummary = {{SearchResultSummary}} {
+        width: Fill, height: 60,
+        show_bg: true,
+        align: {y: 0.5}
+        draw_bg: {
+            color: (COLOR_SECONDARY)
+        }
+
+        <SearchIcon> {}
+        summary_label = <Label> {
+            width:Fill, height: Fit,
+            margin: {left: 10, top: 0},
+            align: {x: 0.0, y: 0.5}
+            padding: 5,
+            draw_text: {
+                color: (MESSAGE_TEXT_COLOR),
+                text_style: <REGULAR_TEXT> { font_size: (MESSAGE_FONT_SIZE) }
+            }
+            text: "Type to search."
+        }
+        search_all_rooms_button = <RobrixIconButton> {
+            flow: RightWrap,
+            width: 90,
+            padding: { top:2, bottom:2, left: 10, right: 10}
+            margin: {top: 5, bottom: 10}
+            align: {x: 0.5, y: 0.5}
+            draw_bg: {
+                color: (COLOR_ACTIVE_PRIMARY)
+            }
+            draw_text: {
+                color: (COLOR_PRIMARY)
+                text_style: <REGULAR_TEXT> {}
+            }
+            text: "Search All Rooms"
+        }
+        search_again_button = <RobrixIconButton> {
+            flow: RightWrap,
+            width: 70,
+            visible: false,
+            padding: { top:2, bottom:2, left: 10, right: 10}
+            margin: {top: 5, bottom: 10}
+            align: {x: 0.5, y: 0.5}
+            draw_bg: {
+                color: (COLOR_ACTIVE_PRIMARY)
+            }
+            draw_text: {
+                color: (COLOR_PRIMARY)
+                text_style: <REGULAR_TEXT> {}
+            }
+            text: "Search Again"
+        }
+    }
+
+    // White rounded message card against a grey backdrop.
+    MessageCard = <Message> {
+        draw_bg: {
+            instance border_radius: 4.0,
+            instance border_size: 1.0,
+            instance border_color: #000000,
+            fn pixel(self) -> vec4 {
+                let sdf = Sdf2d::viewport(self.pos * self.rect_size);
+                // draw bg
+                sdf.box(
+                    self.border_size,
+                    self.border_size,
+                    self.rect_size.x - self.border_size * 2.0,
+                    self.rect_size.y - self.border_size * 2.0,
+                    max(1.0, self.border_radius)
+                )
+                sdf.fill(self.color);
+                sdf.stroke(
+                    self.border_color,
+                    self.border_size
+                )
+                return sdf.result;
+            }
+        }
+    }
+
+    SearchedMessages = <View> {
+        width: Fill, height: Fill,
+        align: {x: 0.5, y: 0.0} // center horizontally, align to top vertically
+        flow: Overlay,
+
+        list = <PortalList> {
+            width: Fill, height: Fill,
+            flow: Down
+            auto_tail: false, // set to `true` to lock the view to the last item.
+            max_pull_down: 0.0, // set to `0.0` to disable the pulldown bounce animation.
+
+            // Below, we must place all of the possible templates (views) that can be used in the portal list.
+            MessageCard = <MessageCard> {}
+            Empty = <Empty> {}
+            RoomHeader = <Label> {
+                margin: {left: 10},
+                draw_text: {
+                    text_style: <REGULAR_TEXT> {
+                        font_size: 12.5,
+                    },
+                    color: #000,
+                }
+                text: "Unknown Room Name"
+            }
+        }
+    }
+
+    // SearchResult widget displays the main search results interface.
+    pub SearchResult = {{SearchResult}} {
+        no_more_template: <Label> {
+            draw_text: {
+                text_style: <REGULAR_TEXT>{
+                    font_size: 11.5,
+                },
+                color: (COLOR_TEXT),
+            }
+            text: "No more results."
+        }
+
+        <View> {
+            width: Fill, height: Fill,
+            flow: Down,
+
+            search_result_plane = <SearchResultSummary> {
+                visible: true
+            }
+            searched_messages = <SearchedMessages> { }
+            bottom_space = <BottomSpace> {
+                visible: false
+            }
+        }
+    }
+    // SearchResultStackView is the main container widget for the search results screen.
+    //
+    // This widget provides the overall layout structure for displaying search results
+    // within a navigation view. It's designed as a StackNavigationView that includes:
+    // - A header with the title "Search Results"
+    // - A body containing the SearchResult widget
+    //
+    pub SearchResultStackView = <StackNavigationView> {
+        width: Fill, height: Fill
+        full_screen: false
+        padding: 0,
+        draw_bg: {
+            color: (COLOR_SECONDARY)
+        }
+        flow: Down
+
+        body = {
+            margin: {top: 0.0 },
+            <SearchResult> {}
+        }
+
+        header = {
+            height: 30.0,
+            padding: {bottom: 10., top: 10.}
+            content = {
+                title_container = {
+                    title = {
+                        draw_text: {
+                            wrap: Ellipsis,
+                            text_style: { font_size: 10. }
+                            color: #B,
+                        }
+                        text: "Search Results"
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Apply highlights to a string by wrapping matching terms in HTML spans.
+fn apply_highlights(text: String, highlights: &[String]) -> String {
+    let mut result = text;
+    for highlight in highlights {
+        let re = Regex::new(&format!(r"(?i){}", regex::escape(highlight))).unwrap();
+        result = re
+            .replace_all(&result, |caps: &regex::Captures| {
+                format!(
+                    "<span data-mx-bg-color=\"{}\">{}</span>",
+                    SEARCH_HIGHLIGHT_COLOR,
+                    &caps[0].to_string() // Preserves original case
+                )
+            })
+            .to_string();
+    }
+    result
+}
+
+/// Injects search term highlights into message content by wrapping matching terms in HTML spans.
+///
+/// This function modifies the message's formatted content to include visual highlighting
+/// for search terms. It processes only text messages and preserves the original case
+/// of matched terms while adding background color styling.
+///
+/// # Arguments
+/// * `message` - The room message event content to modify
+/// * `highlights` - Array of search terms to highlight in the message content
+///
+/// # Behavior
+/// - Uses case-insensitive matching to find search terms
+/// - Wraps matches in `<span data-mx-bg-color="#fcdb03">` tags for yellow highlighting
+/// - Preserves original case and formatting of the matched text
+/// - Creates or updates the message's `formatted` field with highlighted HTML content
+pub fn highlight_search_terms_in_message(
+    message: &mut RoomMessageEventContent,
+    highlights: &[String],
+) {
+    /// Macro to apply highlights and set formatted content for message types with formatted fields
+    macro_rules! apply_highlights_to_content {
+        ($text:expr) => {{
+            let formatted = if let Some(ref mut formatted) = $text.formatted {
+                apply_highlights(formatted.body.clone(), highlights)
+            } else {
+                apply_highlights($text.body.clone(), highlights)
+            };
+            $text.formatted = Some(FormattedBody::html(formatted));
+        }};
+    }
+
+    match &mut message.msgtype {
+        MessageType::Text(content) => {
+            apply_highlights_to_content!(content);
+        }
+        MessageType::Notice(content) => {
+            apply_highlights_to_content!(content);
+        }
+        MessageType::Emote(content) => {
+            apply_highlights_to_content!(content);
+        }
+        MessageType::File(content) => {
+            apply_highlights_to_content!(content);
+        }
+        MessageType::Image(content) => {
+            apply_highlights_to_content!(content);
+        }
+        MessageType::Video(content) => {
+            apply_highlights_to_content!(content);
+        }
+        MessageType::Audio(content) => {
+            apply_highlights_to_content!(content);
+        }
+        MessageType::VerificationRequest(content) => {
+            apply_highlights_to_content!(content);
+        }
+        _ => {}
+    }
+}
+
+/// States that are necessary to display search results.
+/// Contains all the data needed to render the search UI and manage pagination.
+#[derive(Default)]
+struct SearchState {
+    /// The list of events in the search results.
+    items: Vector<SearchResultItem>,
+    /// See [`TimelineUiState.content_drawn_since_last_update`].
+    content_drawn_since_last_update: RangeSet<usize>,
+    /// Same as `content_drawn_since_last_update`, but for the event **profiles** (avatar, username).
+    profile_drawn_since_last_update: RangeSet<usize>,
+    /// All profile infos for the search results.
+    profile_infos: BTreeMap<OwnedUserId, TimelineDetails<Profile>>,
+    /// Token to be used for pagination of earlier search results.
+    next_batch_token: Option<String>,
+    /// The search term for the last search request.
+    prev_search_term: Option<String>,
+    /// Whether all search results have been fully paginated.
+    is_fully_paginated: bool,
+    /// This index is used when back pagination of the searched results fails.
+    /// We will restore the scroll position to this index with enough offset
+    /// so that the user can scroll down to try back pagination again.
+    scroll_restore_checkpoint: usize,
+}
+
+/// The main widget that displays a list of search results.
+///
+/// SearchResult is a complex widget that manages the display and interaction
+/// with Matrix message search results. It provides:
+///
+/// ## Key Features:
+/// - **Infinite scrolling**: Automatically loads more results when scrolling
+/// - **Message highlighting**: Highlights search terms in message content
+/// - **Room filtering**: Can search in specific rooms or all rooms
+/// - **Pagination**: Handles Matrix server pagination tokens efficiently
+/// - **Loading states**: Shows loading indicators during search operations
+///
+/// ## State Management:
+/// The widget maintains a `SearchState` that tracks:
+/// - Search result items and their drawing status
+/// - User profile information for message authors
+/// - Pagination tokens for loading additional results
+/// - Search parameters and room context
+///
+/// ## UI Components:
+/// - Search summary bar showing result counts and search terms
+/// - Scrollable message list with rich content rendering
+/// - Loading indicators for ongoing operations
+/// - "Search All Rooms" and "Search Again" action buttons
+///
+/// ## Event Handling:
+/// The widget responds to scroll events to trigger pagination,
+/// search input changes to update results, and button clicks
+/// for room-specific vs global search operations.
+#[derive(Live, LiveHook, Widget)]
+struct SearchResult {
+    #[deref]
+    view: View,
+    #[layout]
+    layout: Layout,
+    #[walk]
+    walk: Walk,
+    #[rust]
+    search_state: SearchState,
+    #[live]
+    no_more_template: Option<LivePtr>,
+    #[rust]
+    room_id: Option<OwnedRoomId>,
+}
+
+impl Widget for SearchResult {
+    /// Handles events and actions for the SearchResult widget and its inner Timeline view.
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        // Handle pagination when user scrolls to the top
+        if let Event::Actions(actions) = event {
+            let search_portal_list = self.portal_list(id!(searched_messages.list));
+            self.paginate_search_results_based_on_scroll_pos(
+                cx,
+                actions,
+                &search_portal_list,
+                scope,
+            );
+        }
+        self.view.handle_event(cx, event, scope);
+        self.widget_match_event(cx, event, scope);
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        let tl_items = &self.search_state.items;
+        while let Some(subview) = self.view.draw_walk(cx, scope, walk).step() {
+            // We only care about drawing the portal list.
+            let portal_list_ref = subview.as_portal_list();
+            let Some(mut list_ref) = portal_list_ref.borrow_mut() else {
+                error!("!!! SearchResult::draw_walk(): BUG: expected a PortalList widget, but got something else");
+                continue;
+            };
+            if tl_items.is_empty() {
+                continue;
+            }
+            // Set the portal list's range based on the number of searched items.
+            let last_item_id = tl_items.len();
+            let list = list_ref.deref_mut();
+            list.set_item_range(cx, 0, last_item_id);
+
+            while let Some(item_id) = list.next_visible_item(cx) {
+                // Show "No More" template at the bottom when fully paginated
+                let item = {
+                    let tl_idx = item_id;
+                    let Some(search_item) = tl_items.get(tl_idx) else {
+                        // This shouldn't happen (unless the timeline gets corrupted or some other weird error),
+                        // but we can always safely fill the item with an empty widget that takes up no space.
+                        list.item(cx, item_id, live_id!(Empty));
+                        continue;
+                    };
+                    let item_drawn_status = ItemDrawnStatus {
+                        content_drawn: self
+                            .search_state
+                            .content_drawn_since_last_update
+                            .contains(&tl_idx),
+                        profile_drawn: self
+                            .search_state
+                            .profile_drawn_since_last_update
+                            .contains(&tl_idx),
+                    };
+                    let (item, item_new_draw_status) = populate_message_search_view(
+                        cx,
+                        list,
+                        item_id,
+                        search_item,
+                        &self.search_state.profile_infos,
+                        item_drawn_status,
+                    );
+                    if item_new_draw_status.content_drawn {
+                        self.search_state
+                            .content_drawn_since_last_update
+                            .insert(tl_idx..tl_idx + 1);
+                    }
+                    if item_new_draw_status.profile_drawn {
+                        self.search_state
+                            .profile_drawn_since_last_update
+                            .insert(tl_idx..tl_idx + 1);
+                    }
+                    item
+                };
+                item.draw_all(cx, &mut Scope::empty());
+                if item_id == last_item_id.saturating_sub(1)
+                    && self.search_state.is_fully_paginated
+                    && last_item_id > 0
+                {
+                    WidgetRef::new_from_ptr(cx, self.no_more_template)
+                        .as_label()
+                        .draw_all(cx, &mut Scope::empty());
+                    continue;
+                }
+            }
+        }
+        DrawStep::done()
+    }
+}
+
+impl SearchResult {
+    /// Sends a pagination request when the user is scrolling down and approaching the bottom of the search results.
+    /// The request is sent with the `next_batch` token from the last search result received.
+    fn paginate_search_results_based_on_scroll_pos(
+        &mut self,
+        cx: &mut Cx,
+        actions: &ActionsBuf,
+        portal_list: &PortalListRef,
+        _scope: &mut Scope,
+    ) {
+        let total_items = self.search_state.items.len();
+        if total_items == 0 {
+            return;
+        };
+        if self.search_state.is_fully_paginated {
+            return;
+        };
+        if !portal_list.scrolled(actions) {
+            return;
+        };
+        let first_index = portal_list.first_id();
+        let visible_items: usize = portal_list.visible_items();
+        log!(
+            "Scrolled down from item {} --> {:?}, before sending room {:?} last index {:?}",
+            self.search_state.scroll_restore_checkpoint,
+            total_items,
+            self.room_id,
+            first_index + visible_items
+        );
+        if first_index + visible_items >= total_items.saturating_sub(1)
+            && self.search_state.scroll_restore_checkpoint < first_index
+        {
+            if let Some(next_batch_token) = self.search_state.next_batch_token.take() {
+                log!("Scrolled down from item {} --> {:?}, sending back pagination request for search result in room {:?}",
+                    self.search_state.scroll_restore_checkpoint, total_items, self.room_id,
+                );
+                let search_result_summary_ref =
+                    self.view.search_result_summary(id!(search_result_plane));
+                let includes_all_rooms = search_result_summary_ref.includes_all_rooms();
+                self.display_bottom_space(cx);
+                let message_search_choice =
+                    if let (false, Some(room_id)) = (includes_all_rooms, &self.room_id) {
+                        MessageSearchChoice::OneRoom(room_id.clone())
+                    } else {
+                        MessageSearchChoice::AllRooms
+                    };
+                let message_search_input_bar_ref = cx.get_global::<MessageSearchInputBarRef>();
+                let search_term = message_search_input_bar_ref.get_text();
+                submit_async_request(MatrixRequest::SearchMessages {
+                    criteria: create_search_criteria(search_term, message_search_choice),
+                    next_batch: Some(next_batch_token.clone()),
+                    abort_previous_search: false,
+                });
+            }
+        }
+    }
+}
+
+impl SearchResult {
+    /// Processes a new batch of search results and updates the UI and state.
+    /// Optimized to take ownership of results to avoid clones.
+    fn process_search_results(
+        &mut self,
+        cx: &mut Cx,
+        scope: &mut Scope,
+        results: SearchResultReceived,
+    ) {
+        let message_search_input_bar_ref = cx.get_global::<MessageSearchInputBarRef>();
+        let search_term = message_search_input_bar_ref.get_text();
+        let search_result_summary_ref = self.view.search_result_summary(id!(search_result_plane));
+        // If the search input text has changed, reset everything.
+        if search_term != results.search_term {
+            cx.widget_action(
+                self.widget_uid(),
+                &scope.path,
+                MessageSearchAction::Changed(search_term),
+            );
+            return;
+        }
+        self.hide_bottom_space(cx);
+        // Re-enable the search all rooms button when results are received
+        self.view
+            .button(id!(search_all_rooms_button))
+            .set_enabled(cx, true);
+
+        search_result_summary_ref.display_result_summary(cx, &results);
+        // Take ownership of profile infos instead of cloning
+        self.search_state.profile_infos = results.profile_infos;
+        self.view.view(id!(searched_messages)).set_visible(cx, true);
+
+        // Clear draw caches
+        self.search_state.content_drawn_since_last_update.clear();
+        self.search_state.profile_drawn_since_last_update.clear();
+
+        // Append new items efficiently using Vector::append
+        self.search_state.items.append(results.items);
+        let search_portal_list = self.portal_list(id!(searched_messages.list));
+        search_portal_list.set_tail_range(false);
+        if let Some(mut search_portal_list) = search_portal_list.borrow_mut() {
+            search_portal_list.set_item_range(cx, 0, self.search_state.items.len());
+            if self.search_state.prev_search_term.is_none() {
+                search_portal_list.smooth_scroll_to(cx, 0, 0.0, None);
+            }
+        }
+        self.search_state.next_batch_token = results.next_batch.clone();
+        self.search_state.is_fully_paginated = results.next_batch.is_none();
+        self.search_state.prev_search_term = Some(results.search_term);
+        self.search_state.scroll_restore_checkpoint = search_portal_list.first_id();
+        self.redraw(cx);
+    }
+
+    /// Handles actions from the MessageSearchInputBar.
+    fn handle_search_bar_action(&mut self, cx: &mut Cx, scope: &mut Scope, action: &Action) {
+        match action.as_widget_action().cast() {
+            MessageSearchAction::Changed(search_term) => {
+                self.hide_bottom_space(cx);
+                let search_result_summary_ref =
+                    self.search_result_summary(id!(search_result_plane));
+                self.search_state = SearchState::default();
+                if search_term.is_empty() {
+                    self.view
+                        .button_set(ids!(search_all_rooms_button, search_again_button))
+                        .set_enabled(cx, false);
+                    // Abort previous inflight search request regardless of message choice if search term is empty.
+                    submit_async_request(MatrixRequest::SearchMessages {
+                        criteria: create_search_criteria(
+                            search_term,
+                            MessageSearchChoice::AllRooms,
+                        ),
+                        next_batch: None,
+                        abort_previous_search: true,
+                    });
+                    search_result_summary_ref.display_instruction(cx);
+                    return;
+                }
+                self.view
+                    .button_set(ids!(search_all_rooms_button, search_again_button))
+                    .set_enabled(cx, true);
+                if let Some(selected_room) = {
+                    let app_state = scope.data.get::<AppState>().unwrap();
+                    app_state.selected_room.clone()
+                } {
+                    let room_id = selected_room.room_id();
+                    let criteria = create_search_criteria(
+                        search_term.clone(),
+                        MessageSearchChoice::OneRoom(room_id.clone()),
+                    );
+                    search_result_summary_ref.display_search_criteria(cx, scope, criteria.clone());
+                    self.room_id = Some(room_id.clone());
+                    let rooms_list_ref = cx.get_global::<RoomsListRef>();
+                    let is_encrypted = rooms_list_ref.is_room_encrypted(room_id);
+                    if is_encrypted && criteria.filter.rooms.is_none() {
+                        enqueue_popup_notification(PopupItem {
+                            message: String::from(
+                                "Searching for encrypted messages is not supported yet.",
+                            ),
+                            auto_dismissal_duration: None,
+                            kind: PopupKind::Info,
+                        });
+                        return;
+                    }
+                    self.display_bottom_space(cx);
+                    // Disable the search all rooms button during search
+                    self.view
+                        .button(id!(search_all_rooms_button))
+                        .set_enabled(cx, false);
+                    submit_async_request(MatrixRequest::SearchMessages {
+                        criteria,
+                        next_batch: None,
+                        abort_previous_search: true,
+                    });
+                }
+            }
+            MessageSearchAction::Clicked => {
+                let search_result_summary_ref =
+                    self.search_result_summary(id!(search_result_plane));
+                let message_search_input_bar_ref = cx.get_global::<MessageSearchInputBarRef>();
+                let search_term = message_search_input_bar_ref.get_text();
+                if search_term.is_empty() {
+                    search_result_summary_ref.display_instruction(cx);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn handle_room_focus_changed_action(&mut self, cx: &mut Cx, action: &Action) {
+        if let AppStateAction::RoomFocused(_room_id) = action.as_widget_action().cast() {
+            self.view
+                .button(id!(search_again_button))
+                .set_visible(cx, true);
+        }
+    }
+    /// Displays the loading view for backwards pagination for search result.
+    fn display_bottom_space(&mut self, cx: &mut Cx) {
+        self.view.view(id!(bottom_space)).set_visible(cx, true);
+    }
+
+    /// Hides the loading view for backwards pagination for search result.
+    fn hide_bottom_space(&mut self, cx: &mut Cx) {
+        self.view.view(id!(bottom_space)).set_visible(cx, false);
+    }
+}
+
+impl WidgetMatchEvent for SearchResult {
+    fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions, scope: &mut Scope) {
+        for action in actions.iter() {
+            self.handle_search_bar_action(cx, scope, action);
+            self.handle_room_focus_changed_action(cx, action);
+            match action.downcast_ref() {
+                Some(SearchResultAction::Received(results)) => {
+                    self.process_search_results(cx, scope, results.clone());
+                }
+                Some(SearchResultAction::ErrorWithNextBatchToken(next_batch_token)) => {
+                    self.search_state.next_batch_token = next_batch_token.clone();
+                    self.hide_bottom_space(cx);
+                    self.view
+                        .button(id!(search_all_rooms_button))
+                        .set_enabled(cx, true);
+                    // Show the search again button
+                    self.view
+                        .button(id!(search_again_button))
+                        .set_visible(cx, true);
+                    let search_portal_list = self.portal_list(id!(searched_messages.list));
+                    // Leave an Y offset 100.0, so that the user can still scroll down to trigger back pagination again.
+                    search_portal_list.set_first_id_and_scroll(
+                        self.search_state.scroll_restore_checkpoint,
+                        100.0,
+                    );
+                }
+                _ => {}
+            }
+            let search_all_rooms_button = self.view.button(id!(search_all_rooms_button));
+            if search_all_rooms_button.clicked(actions) {
+                let message_search_input_bar_ref = cx.get_global::<MessageSearchInputBarRef>();
+                let search_term = message_search_input_bar_ref.get_text();
+                if search_term.is_empty() {
+                    continue;
+                }
+                self.search_state = SearchState::default();
+                // Disable the button during search
+                search_all_rooms_button.set_enabled(cx, false);
+                let criteria = create_search_criteria(search_term, MessageSearchChoice::AllRooms);
+                let search_result_summary_ref =
+                    self.search_result_summary(id!(search_result_plane));
+                search_result_summary_ref.set_includes_all_rooms(cx, true);
+                search_result_summary_ref.display_search_criteria(cx, scope, criteria.clone());
+                self.display_bottom_space(cx);
+                submit_async_request(MatrixRequest::SearchMessages {
+                    criteria,
+                    next_batch: None,
+                    abort_previous_search: true,
+                });
+            }
+            let search_again_button_ref = self.view.button(id!(search_again_button));
+            if search_again_button_ref.clicked(actions) {
+                search_again_button_ref.set_visible(cx, false);
+                if let Some(selected_room) = {
+                    let app_state = scope.data.get::<AppState>().unwrap();
+                    app_state.selected_room.clone()
+                } {
+                    let search_result_summary_ref =
+                        self.search_result_summary(id!(search_result_plane));
+                    let Some(previous_room_id) = &self.room_id else {
+                        continue;
+                    };
+                    if previous_room_id != selected_room.room_id() {
+                        self.search_state = SearchState::default();
+                    }
+                    let includes_all_rooms = search_result_summary_ref.includes_all_rooms();
+                    let room_id = selected_room.room_id();
+                    self.room_id = Some(room_id.clone());
+                    let rooms_list_ref = cx.get_global::<RoomsListRef>();
+                    let is_encrypted = rooms_list_ref.is_room_encrypted(room_id);
+                    if is_encrypted && !includes_all_rooms {
+                        enqueue_popup_notification(PopupItem {
+                            message: String::from(
+                                "Searching for encrypted messages is not supported yet.",
+                            ),
+                            auto_dismissal_duration: None,
+                            kind: PopupKind::Info,
+                        });
+                        return;
+                    }
+                    self.display_bottom_space(cx);
+                    // Disable the search all rooms button during search
+                    search_all_rooms_button.set_enabled(cx, false);
+                    let message_search_input_bar_ref = cx.get_global::<MessageSearchInputBarRef>();
+                    let search_term = message_search_input_bar_ref.get_text();
+                    let criteria = create_search_criteria(
+                        search_term,
+                        if includes_all_rooms {
+                            MessageSearchChoice::AllRooms
+                        } else {
+                            MessageSearchChoice::OneRoom(room_id.clone())
+                        },
+                    );
+                    search_result_summary_ref.display_search_criteria(cx, scope, criteria.clone());
+                    submit_async_request(MatrixRequest::SearchMessages {
+                        criteria,
+                        next_batch: None,
+                        abort_previous_search: true,
+                    });
+                }
+            }
+        }
+    }
+}
+
+/// Actions related to search result processing.
+#[derive(Clone, Debug, DefaultNone)]
+pub enum SearchResultAction {
+    /// Search results have been received from the Matrix server.
+    Received(SearchResultReceived),
+    /// An error occurred while processing search results.
+    /// The previous token should be restored.
+    ErrorWithNextBatchToken(Option<String>),
+    None,
+}
+
+impl Default for SearchResultReceived {
+    fn default() -> Self {
+        Self {
+            items: Vector::new(),
+            profile_infos: BTreeMap::new(),
+            count: 0,
+            search_term: String::new(),
+            next_batch: None,
+            includes_all_rooms: false,
+            room_name: None,
+        }
+    }
+}
+
+/// Data structure containing search results received from the Matrix server.
+#[derive(Debug, Clone)]
+pub struct SearchResultReceived {
+    pub items: Vector<SearchResultItem>,
+    pub profile_infos: BTreeMap<OwnedUserId, TimelineDetails<Profile>>,
+    pub count: u32,
+    pub search_term: String,
+    pub next_batch: Option<String>,
+    pub room_name: Option<String>,
+    pub includes_all_rooms: bool,
+}
+
+// The widget that displays an overlay of the summary for search results.
+#[derive(Live, LiveHook, Widget)]
+pub struct SearchResultSummary {
+    #[deref]
+    pub view: View,
+    #[rust]
+    pub room_name: Option<String>,
+    #[rust]
+    pub includes_all_rooms: bool,
+}
+
+impl Widget for SearchResultSummary {
+    /// Handles events and actions for the SearchResultSummary widget and its inner Timeline view.
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        if !self.visible {
+            return;
+        }
+        self.view.handle_event(cx, event, scope);
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        if !self.visible {
+            return DrawStep::done();
+        }
+        let message_search_input_bar_ref = cx.get_global::<MessageSearchInputBarRef>();
+        let search_term = message_search_input_bar_ref.get_text();
+        self.view
+            .button(id!(search_again_button))
+            .set_visible(cx, !search_term.is_empty());
+        self.view.draw_walk(cx, scope, walk)
+    }
+}
+
+impl SearchResultSummary {
+    /// Display the search criteria for the SearchResultSummary widget.
+    ///
+    /// This function is used to display the search criteria in the top-right of the room screen.
+    /// It is typically used when a new search is initiated.
+    ///
+    pub fn display_search_criteria(
+        &mut self,
+        cx: &mut Cx,
+        scope: &mut Scope,
+        search_criteria: MatrixCriteria,
+    ) {
+        self.room_name = scope.data.get::<AppState>().and_then(|f| {
+            f.selected_room
+                .as_ref()
+                .and_then(|f| f.room_name().cloned())
+        });
+        let location_text = if search_criteria.filter.rooms.is_none() {
+            "in all rooms".to_string()
+        } else {
+            if let Some(room_name) = &self.room_name {
+                format!("in {}", room_name.clone())
+            } else {
+                "".to_string()
+            }
+        };
+        self.view.label(id!(summary_label)).set_text(
+            cx,
+            &format!(
+                "Searching for '{}' {}",
+                truncate_to_50(&search_criteria.search_term),
+                location_text
+            ),
+        );
+        self.visible = true;
+    }
+
+    /// Display result summary.
+    ///
+    /// This is used to display the number of search results and the search term at the top of the search result.
+    pub fn display_result_summary(&mut self, cx: &mut Cx, results: &SearchResultReceived) {
+        let location_text = if results.includes_all_rooms {
+            Cow::Borrowed("in all rooms")
+        } else {
+            Cow::Owned(format!(
+                "in {}",
+                results.room_name.as_deref().unwrap_or_default()
+            ))
+        };
+
+        self.view.label(id!(summary_label)).set_text(
+            cx,
+            &format!(
+                "{} result{} for '{}' {}",
+                results.count,
+                if results.count <= 1 { "" } else { "s" },
+                truncate_to_50(&results.search_term),
+                location_text
+            ),
+        );
+    }
+
+    /// Set whether the search criteria to include all rooms.
+    pub fn set_includes_all_rooms(&mut self, _cx: &mut Cx, includes_all_rooms: bool) {
+        self.includes_all_rooms = includes_all_rooms;
+    }
+}
+
+impl SearchResultSummaryRef {
+    /// Display instruction to type to search.
+    pub fn display_instruction(&self, cx: &mut Cx) {
+        let Some(mut inner) = self.borrow_mut() else {
+            return;
+        };
+        inner
+            .view
+            .label(id!(summary_label))
+            .set_text(cx, "Type to search.");
+        inner.visible = true;
+    }
+
+    /// See [`SearchResultSummary::display_search_criteria()`].
+    pub fn display_search_criteria(
+        &self,
+        cx: &mut Cx,
+        scope: &mut Scope,
+        search_criteria: MatrixCriteria,
+    ) {
+        let Some(mut inner) = self.borrow_mut() else {
+            return;
+        };
+        inner.display_search_criteria(cx, scope, search_criteria);
+    }
+
+    /// See [`SearchResultSummary::display_result_summary()`].
+    pub fn display_result_summary(&self, cx: &mut Cx, results: &SearchResultReceived) {
+        let Some(mut inner) = self.borrow_mut() else {
+            return;
+        };
+        inner.display_result_summary(cx, results);
+    }
+
+    /// See [`SearchResultSummary::includes_all_rooms()`].
+    pub fn includes_all_rooms(&self) -> bool {
+        let Some(inner) = self.borrow() else {
+            return false;
+        };
+        inner.includes_all_rooms
+    }
+
+    /// See [`SearchResultSummary::set_includes_all_rooms()`].
+    pub fn set_includes_all_rooms(&self, cx: &mut Cx, includes_all_rooms: bool) {
+        let Some(mut inner) = self.borrow_mut() else {
+            return;
+        };
+        inner.set_includes_all_rooms(cx, includes_all_rooms);
+    }
+}
+
+/// Search result as timeline item
+#[allow(clippy::large_enum_variant)]
+#[derive(Clone, Debug)]
+pub enum SearchResultItem {
+    /// The event that matches the search criteria with precomputed formatted content.
+    Event {
+        event: AnyTimelineEvent,
+        formatted_content: Option<RoomMessageEventContent>,
+    },
+    /// The room id used for displaying room header for all searched messages in a screen.
+    RoomHeader(OwnedRoomId),
+}
+
+/// Message search choice.
+#[derive(Clone, Debug)]
+pub enum MessageSearchChoice {
+    /// Search in all rooms
+    AllRooms,
+    /// Search in one room
+    OneRoom(OwnedRoomId),
+}
+
+fn populate_message_search_view(
+    cx: &mut Cx2d,
+    list: &mut PortalList,
+    item_id: usize,
+    search_item: &SearchResultItem,
+    user_profiles: &BTreeMap<OwnedUserId, TimelineDetails<Profile>>,
+    item_drawn_status: ItemDrawnStatus,
+) -> (WidgetRef, ItemDrawnStatus) {
+    let mut new_drawn_status = item_drawn_status;
+    let (event, formatted_content) = match search_item {
+        SearchResultItem::Event {
+            event,
+            formatted_content,
+        } => (event, formatted_content),
+        SearchResultItem::RoomHeader(room_id) => {
+            // Handle room header case
+            let item = list.item(cx, item_id, live_id!(RoomHeader));
+            let rooms_list_ref = cx.get_global::<RoomsListRef>();
+            let room_name = rooms_list_ref
+                .get_room_name(room_id)
+                .unwrap_or(room_id.to_string());
+            item.set_text(cx, &format!("Room {}", room_name));
+            return (item, ItemDrawnStatus::both_drawn());
+        }
+    };
+
+    let ts_millis = event.origin_server_ts();
+
+    // Use precomputed formatted content
+    let (item, used_cached_item) = if let Some(content) = formatted_content {
+        match &content.msgtype {
+            MessageType::Text(TextMessageEventContent {
+                body, formatted, ..
+            })
+            | MessageType::Notice(NoticeMessageEventContent {
+                body, formatted, ..
+            })
+            | MessageType::Emote(EmoteMessageEventContent {
+                body, formatted, ..
+            })
+            | MessageType::Image(ImageMessageEventContent {
+                body, formatted, ..
+            })
+            | MessageType::File(FileMessageEventContent {
+                body, formatted, ..
+            })
+            | MessageType::Audio(AudioMessageEventContent {
+                body, formatted, ..
+            })
+            | MessageType::Video(VideoMessageEventContent {
+                body, formatted, ..
+            })
+            | MessageType::VerificationRequest(KeyVerificationRequestEventContent {
+                body,
+                formatted,
+                ..
+            }) => {
+                let template = live_id!(MessageCard);
+                let (item, existed) = list.item_with_existed(cx, item_id, template);
+                if existed && item_drawn_status.content_drawn {
+                    (item, true)
+                } else {
+                    populate_text_message_content(
+                        cx,
+                        &item.html_or_plaintext(id!(content.message)),
+                        body,
+                        formatted.as_ref(),
+                    );
+                    new_drawn_status.content_drawn = true;
+                    (item, false)
+                }
+            }
+            _ => {
+                let item = list.item(cx, item_id, live_id!(Empty));
+                (item, false)
+            }
+        }
+    } else {
+        let item = list.item(cx, item_id, live_id!(Empty));
+        (item, false)
+    };
+    // If `used_cached_item` is false, we should always redraw the profile, even if profile_drawn is true.
+    let skip_draw_profile = used_cached_item && item_drawn_status.profile_drawn;
+    if skip_draw_profile {
+        // log!("\t --> populate_message_view(): SKIPPING profile draw for item_id: {item_id}");
+        new_drawn_status.profile_drawn = true;
+    } else {
+        let username_label = item.label(id!(content.username));
+        let (username, profile_drawn) = item
+            .avatar(id!(profile.avatar))
+            .set_avatar_and_get_username(
+                cx,
+                event.room_id(),
+                event.sender(),
+                user_profiles.get(event.sender()),
+                Some(event.event_id()),
+            );
+        username_label.set_text(cx, &username);
+        new_drawn_status.profile_drawn = profile_drawn;
+    }
+
+    // If we've previously drawn the item content, skip all other steps.
+    if used_cached_item && item_drawn_status.content_drawn && item_drawn_status.profile_drawn {
+        return (item, new_drawn_status);
+    }
+    // Set the timestamp with date and time format.
+    if let Some(dt) = unix_time_millis_to_datetime(ts_millis) {
+        item.timestamp(id!(profile.timestamp))
+            .set_date_time_with_format(cx, dt, "%F\n%H:%M");
+    } else {
+        item.label(id!(profile.timestamp))
+            .set_text(cx, &format!("{}", ts_millis.get()));
+    }
+    item.as_message().set_jump_option(
+        cx,
+        JumpToMessageRequest {
+            room_id: event.room_id().to_owned(),
+            event_id: event.event_id().to_owned(),
+        },
+    );
+
+    (item, new_drawn_status)
+}
+
+/// Truncates a string to 50 characters and appends "..." if longer.
+/// Used for displaying search terms in the UI summary.
+/// Uses Cow for efficient string handling to avoid unnecessary allocations.
+fn truncate_to_50(s: &str) -> Cow<'_, str> {
+    if s.len() <= 50 {
+        Cow::Borrowed(s)
+    } else {
+        Cow::Owned(format!("{}...", &s[..47]))
+    }
+}
+
+/// Creates a search criteria object based on the search parameters.
+fn create_search_criteria(
+    search_term: String,
+    message_search_choice: MessageSearchChoice,
+) -> MatrixCriteria {
+    let mut room_filter = RoomEventFilter::empty();
+    if let MessageSearchChoice::OneRoom(room_id) = &message_search_choice {
+        room_filter.rooms = Some(vec![room_id.to_owned()]);
+    } else {
+        room_filter.rooms = None;
+    }
+    let mut criteria = MatrixCriteria::new(search_term);
+    criteria.filter = room_filter;
+    criteria.order_by = Some(OrderBy::Recent);
+    criteria.event_context = EventContext::new();
+    criteria.event_context.after_limit = uint!(0);
+    criteria.event_context.before_limit = uint!(0);
+    criteria.event_context.include_profile = true;
+    criteria
+}
diff --git a/src/lib.rs b/src/lib.rs
index 0f32ea84..00e16d1e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -28,6 +28,8 @@ pub mod shared;
 /// Generating text previews of timeline events/messages.
 mod event_preview;
 pub mod room;
+/// A drawer panel to be displayed on the right for the desktop view.
+pub mod right_drawer;
 
 
 /// All content related to TSP (Trust Spanning Protocol) wallets/identities.
diff --git a/src/right_drawer/mod.rs b/src/right_drawer/mod.rs
new file mode 100644
index 00000000..c7d190ba
--- /dev/null
+++ b/src/right_drawer/mod.rs
@@ -0,0 +1,82 @@
+use makepad_widgets::*;
+use crate::shared::message_search_input_bar::MessageSearchAction;
+
+live_design! {
+    use link::theme::*;
+    use link::shaders::*;
+    use link::widgets::*;
+
+    use crate::shared::styles::*;
+    use crate::home::search_message::SearchResult;
+    use crate::home::search_message::SearchResultStackView;
+
+    pub RightDrawer = {{RightDrawer}} {
+        width: 400, height: Fill,
+        flow: Down,
+        visible: false
+
+        view_stack = <StackNavigation> {
+            width: Fill, height: Fill
+            padding: 0.0
+
+            root_view = <View> {
+                padding: 0.0,
+            }
+            // One of the possible stack navigation views: displays message search results
+            search_result_view = <SearchResultStackView> {}
+        }
+    }
+}
+
+/// Drawer-like sliding panel that can show/hide search results.
+#[derive(Live, LiveHook, Widget)]
+pub struct RightDrawer {
+    #[deref]
+    view: View,
+}
+
+impl Widget for RightDrawer {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        self.view.handle_event(cx, event, scope);
+        self.widget_match_event(cx, event, scope);
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        self.view.draw_walk(cx, scope, walk)
+    }
+}
+
+impl WidgetMatchEvent for RightDrawer {
+    fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions, _scope: &mut Scope) {
+
+        for action in actions.iter() {
+            match action.as_widget_action().cast() {
+                MessageSearchAction::Clicked => {
+                    self.view.set_visible(cx, true);
+                    self.view.stack_navigation(id!(view_stack)).pop_to_root(cx);
+                    self.view
+                        .stack_navigation(id!(view_stack))
+                        .push(cx, live_id!(search_result_view));
+                }
+                MessageSearchAction::Changed(search_term) => {
+                    if !search_term.is_empty() {
+                        self.view.set_visible(cx, true);
+                        self.view.stack_navigation(id!(view_stack)).pop_to_root(cx);
+                        self.view
+                            .stack_navigation(id!(view_stack))
+                            .push(cx, live_id!(search_result_view));
+                    } else {
+                        self.view.set_visible(cx, false);
+                    }
+                }
+                _ => {}
+            }
+
+            if let StackNavigationTransitionAction::HideEnd(_) = action.as_widget_action().cast() {
+                if !self.view.stack_navigation(id!(view_stack)).can_pop() {
+                    self.view.set_visible(cx, false);
+                }
+            }
+        }
+    }
+}
diff --git a/src/shared/message_search_input_bar.rs b/src/shared/message_search_input_bar.rs
new file mode 100644
index 00000000..53c0de3c
--- /dev/null
+++ b/src/shared/message_search_input_bar.rs
@@ -0,0 +1,170 @@
+//! A text input used to search messages in a room
+//! with a search icon and a button to clear the input.
+//!
+//! This is a dedicated widget instead of a general "SearchBar"
+//! in order for us to be able to place it inside of a `CachedWidget`
+//! and have a single instance be shared across the Mobile and Desktop app views.
+
+use makepad_widgets::*;
+
+/// Delay in seconds before sending a search request.
+/// This is to avoid sending too many requests when the user is typing.
+const SEARCH_INPUT_DELAY_SECS: f64 = 1.0;
+
+live_design! {
+    use link::theme::*;
+    use link::shaders::*;
+    use link::widgets::*;
+
+    use crate::shared::styles::*;
+    use crate::shared::icon_button::RobrixIconButton;
+
+    ICON_SEARCH = dep("crate://self/resources/icons/search.svg")
+
+    pub MessageSearchInputBar = {{MessageSearchInputBar}}<RoundedView> {
+        width: Fill, height: 35,
+        show_bg: true,
+        draw_bg: {
+            color: (COLOR_PRIMARY),
+            border_radius: 4.0,
+            border_color: (COLOR_SECONDARY),
+            border_size: 0.0,
+        }
+        padding: {top: 3, bottom: 3, left: 10, right: 10}
+        margin: {top: 0, bottom: 3, left: 0, right: 0}
+        spacing: 4,
+        align: {x: 0.0, y: 0.5},
+
+        <Icon> {
+            draw_icon: {
+                svg_file: (ICON_SEARCH),
+                fn get_color(self) -> vec4 {
+                    return (COLOR_TEXT_INPUT_IDLE);
+                }
+            }
+            icon_walk: {width: 14, height: Fit}
+        }
+        input = <RobrixTextInput> {
+            width: Fill,
+            height: Fit,
+            flow: Right, // do not wrap
+            empty_text: "Search Messages..."
+            draw_text: {
+                text_style: { font_size: 10 },
+            }
+        }
+        clear_button = <RobrixIconButton> {
+            visible: false,
+            padding: {top: 7, bottom: 7, left: 10, right: 10},
+            spacing: 0,
+            align: {x: 0.5, y: 0.5}
+            draw_icon: {
+                svg_file: (ICON_CLOSE),
+                color: (COLOR_TEXT_INPUT_IDLE)
+            }
+            icon_walk: {width: Fit, height: 10, margin: 0}
+        }
+    }
+}
+
+/// Widget for searching messages across rooms
+#[derive(Live, LiveHook, Widget)]
+pub struct MessageSearchInputBar {
+    #[deref] view: View,
+    /// Debounce timer to prevent excessive search requests when typing
+    #[rust] debounce_timer: Timer,
+    /// The current search term entered by the user
+    #[rust] search_term: String,
+}
+
+/// Actions emitted by the `MessageSearchInputBar`.
+#[derive(Clone, Debug, DefaultNone)]
+pub enum MessageSearchAction {
+    /// Emitted when the user has changed the text (after debounce delay or clear button).
+    Changed(String),
+    /// Emitted when the user has clicked the input bar.
+    Clicked,
+    None,
+}
+
+impl Widget for MessageSearchInputBar {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        if let Event::Timer(te) = event {
+            if self.debounce_timer.is_timer(te).is_some() {
+                cx.widget_action(
+                    self.widget_uid(),
+                    &scope.path,
+                    MessageSearchAction::Changed(self.search_term.clone()),
+                );
+            }
+        }
+        let area = self.text_input(id!(input)).area();
+        if let Hit::FingerDown(..) = event.hits(cx, area) {
+            let widget_uid = self.widget_uid();
+            cx.widget_action(
+                widget_uid,
+                &scope.path,
+                MessageSearchAction::Clicked
+            );
+        }
+        self.view.handle_event(cx, event, scope);
+        self.widget_match_event(cx, event, scope);
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        self.text_input(id!(input)).set_text(cx, &self.search_term);
+        self.view.draw_walk(cx, scope, walk)
+    }
+}
+
+impl WidgetMatchEvent for MessageSearchInputBar {
+    fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions, scope: &mut Scope) {
+        let input = self.text_input(id!(input));
+        let clear_button = self.button(id!(clear_button));
+
+        // Handle user changing the input text
+        if let Some(keywords) = input.changed(actions) {
+            clear_button.set_visible(cx, !keywords.is_empty());
+            self.debounce_timer = cx.start_timeout(SEARCH_INPUT_DELAY_SECS);
+            self.search_term = keywords;
+        }
+
+        if clear_button.clicked(actions) {
+            clear_button.set_visible(cx, false);
+            input.set_key_focus(cx);
+            cx.widget_action(
+                self.widget_uid(),
+                &scope.path,
+                MessageSearchAction::Changed(String::new())
+            );
+            self.search_term = String::new();
+        }
+    }
+}
+
+impl MessageSearchInputBarRef {
+
+    /// Sets the text of the `MessageSearchInputBar`.
+    ///
+    /// `text` - The new text to set for the `MessageSearchInputBar`.
+    ///
+    /// This function sets the text of the `MessageSearchInputBar` to `text`.
+    /// If the `MessageSearchInputBar` is not being viewed, it will not be updated.
+    pub fn set_text(&self, text: &str) {
+        if let Some(mut inner) = self.borrow_mut() {
+            inner.search_term = text.to_string();
+        }
+    }
+
+    /// Returns the current search term entered by the user.
+    ///
+    /// Returns an empty string if the `MessageSearchInputBar` is not currently
+    /// being viewed.
+    pub fn get_text(&self) -> String {
+        if let Some(inner) = self.borrow() {
+            inner.search_term.clone()
+        } else {
+            String::new()
+        }
+    }
+}
diff --git a/src/shared/mod.rs b/src/shared/mod.rs
index 089f55d5..ae845c45 100644
--- a/src/shared/mod.rs
+++ b/src/shared/mod.rs
@@ -17,6 +17,7 @@ pub mod timestamp;
 pub mod typing_animation;
 pub mod unread_badge;
 pub mod verification_badge;
+pub mod message_search_input_bar;
 pub mod restore_status_view;
 
 
@@ -38,6 +39,7 @@ pub fn live_design(cx: &mut Cx) {
     verification_badge::live_design(cx);
     callout_tooltip::live_design(cx);
     mentionable_text_input::live_design(cx);
+    message_search_input_bar::live_design(cx);
     restore_status_view::live_design(cx);
     confirmation_modal::live_design(cx);
 }
diff --git a/src/shared/styles.rs b/src/shared/styles.rs
index afc0ca64..3877914f 100644
--- a/src/shared/styles.rs
+++ b/src/shared/styles.rs
@@ -32,6 +32,7 @@ live_design! {
     pub ICON_UPLOAD          = dep("crate://self/resources/icons/upload.svg")
     pub ICON_VIEW_SOURCE     = dep("crate://self/resources/icons/view_source.svg")
     pub ICON_WARNING         = dep("crate://self/resources/icons/warning.svg")
+    pub ICON_SEARCH          = dep("crate://self/resources/icons/search.svg")
 
     pub TITLE_TEXT = <THEME_FONT_REGULAR>{
         font_size: (13),
diff --git a/src/shared/timestamp.rs b/src/shared/timestamp.rs
index 66c7962d..f4190040 100644
--- a/src/shared/timestamp.rs
+++ b/src/shared/timestamp.rs
@@ -87,6 +87,21 @@ impl Timestamp {
         );
         self.dt = dt;
     }
+
+    /// Sets the timestamp label text with the given `DateTime` formatted according to the specified `format` string.
+    /// 
+    /// # Arguments
+    /// 
+    /// * `cx` - A mutable reference to the context that allows modification of the GUI.
+    /// * `dt` - The `DateTime<Local>` object representing the date and time to display.
+    /// * `format` - A format string used to determine how the `DateTime` should be displayed.
+    pub fn set_date_time_with_format(&mut self, cx: &mut Cx, dt: DateTime<Local>, format: &str) {
+        self.label(id!(ts_label)).set_text(
+            cx,
+            &dt.format(format).to_string()
+        );
+        self.dt = dt;
+    }
 }
 
 impl TimestampRef {
@@ -95,4 +110,11 @@ impl TimestampRef {
             inner.set_date_time(cx, dt);
         }
     }
+
+    /// See [`Timestamp::set_date_time_with_format()`].
+    pub fn set_date_time_with_format(&self, cx: &mut Cx, dt: DateTime<Local>, format: &str) {
+        if let Some(mut inner) = self.borrow_mut() {
+            inner.set_date_time_with_format(cx, dt, format);
+        }
+    }
 }
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 70e6178b..181aae4f 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -8,20 +8,20 @@ use imbl::Vector;
 use makepad_widgets::{error, log, warning, Cx, SignalToUI};
 use matrix_sdk::{
     config::RequestConfig, encryption::EncryptionSettings, event_handler::EventHandlerDropGuard, media::MediaRequestParameters, room::{edit::EditedContent, reply::Reply, RoomMember}, ruma::{
-        api::client::receipt::create_receipt::v3::ReceiptType, events::{
+        api::client::{receipt::create_receipt::v3::ReceiptType, search}, events::{
             receipt::ReceiptThread, room::{
-                message::RoomMessageEventContent, power_levels::RoomPowerLevels, MediaSource
-            }, FullStateEventContent, MessageLikeEventType, StateEventType
+                message::{Relation, RoomMessageEventContent}, power_levels::RoomPowerLevels, MediaSource
+            }, AnyMessageLikeEventContent, AnyTimelineEvent, FullStateEventContent, MessageLikeEventType, StateEventType
         }, matrix_uri::MatrixId, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId, OwnedUserId, RoomOrAliasId, UserId
     }, sliding_sync::VersionBuilder, Client, ClientBuildError, Error, OwnedServerName, Room, RoomMemberships, RoomState, SuccessorRoom
 };
 use matrix_sdk_ui::{
-    room_list_service::{RoomListLoadingState, SyncIndicator}, sync_service::{self, SyncService}, timeline::{AnyOtherFullStateEventContent, EventTimelineItem, MembershipChange, RoomExt, TimelineEventItemId, TimelineItem, TimelineItemContent}, RoomListService, Timeline
+    room_list_service::{RoomListLoadingState, SyncIndicator}, sync_service::{self, SyncService}, timeline::{AnyOtherFullStateEventContent, EventTimelineItem, MembershipChange, Profile, RoomExt, TimelineDetails, TimelineEventItemId, TimelineItem, TimelineItemContent}, RoomListService, Timeline
 };
 use robius_open::Uri;
 use tokio::{
     runtime::Handle,
-    sync::{mpsc::{Receiver, Sender, UnboundedReceiver, UnboundedSender}, watch, Notify}, task::JoinHandle, time::error::Elapsed,
+    sync::{mpsc::{Receiver, Sender, UnboundedReceiver, UnboundedSender}, watch, Notify}, task::{AbortHandle, JoinHandle}, time::error::Elapsed,
 };
 use url::Url;
 use std::{cmp::{max, min}, collections::{BTreeMap, BTreeSet}, future::Future, iter::Peekable, ops::Not, path:: Path, sync::{Arc, LazyLock, Mutex}, time::Duration};
@@ -35,17 +35,15 @@ use crate::{
         invite_screen::{JoinRoomResultAction, LeaveRoomResultAction},
         room_screen::TimelineUpdate,
         rooms_list::{self, enqueue_rooms_list_update, InvitedRoomInfo, InviterInfo, JoinedRoomInfo, RoomsListUpdate},
-        rooms_list_header::RoomsListHeaderAction,
+        rooms_list_header::RoomsListHeaderAction, search_message::{highlight_search_terms_in_message, SearchResultAction, SearchResultItem, SearchResultReceived},
     },
     login::login_screen::LoginAction,
-    logout::{logout_confirm_modal::LogoutAction, logout_state_machine::{logout_with_state_machine, LogoutConfig, is_logout_in_progress}}, media_cache::{MediaCacheEntry, MediaCacheEntryRef},
+    logout::{logout_confirm_modal::LogoutAction, logout_state_machine::{is_logout_in_progress, logout_with_state_machine, LogoutConfig}}, media_cache::{MediaCacheEntry, MediaCacheEntryRef},
     persistence::{self, load_app_state, ClientSessionPersisted},
     profile::{
         user_profile::{AvatarState, UserProfile},
         user_profile_cache::{enqueue_user_profile_update, UserProfileUpdate},
-    },
-    room::RoomPreviewAvatar,
-    shared::{
+    }, room::RoomPreviewAvatar, shared::{
         html_or_plaintext::MatrixLinkPillState,
         jump_to_bottom_button::UnreadMessageCount,
         popup_list::{enqueue_popup_notification, PopupItem, PopupKind}
@@ -414,6 +412,22 @@ pub enum MatrixRequest {
         matrix_id: MatrixId,
         via: Vec<OwnedServerName>
     },
+    /// General Matrix Search API with given categories
+    SearchMessages {
+        /// The search criteria containing all search parameters
+        criteria: search::search_events::v3::Criteria,
+        /// Token for next batch of search results.
+        next_batch: Option<String>,
+        /// Abort previous search only when debouncing from typing search term.
+        abort_previous_search: bool,
+    },
+    /// Wait for a room's timeline to be loaded before jumping to a specific event.
+    WaitForRoomTimelineLoadedToJump {
+        /// The ID of the room to jump to.
+        room_id: OwnedRoomId,
+        /// The ID of the event to jump to.
+        event_id: OwnedEventId,
+    }
 }
 
 /// Submits a request to the worker thread to be executed asynchronously.
@@ -450,6 +464,7 @@ async fn async_worker(
 ) -> Result<()> {
     log!("Started async_worker task.");
     let mut tasks_list: BTreeMap<OwnedRoomId, JoinHandle<()>> = BTreeMap::new();
+    let mut search_task_abort_handler: Option<AbortHandle> = None;
     while let Some(request) = request_receiver.recv().await {
         match request {
             MatrixRequest::Login(login_request) => {
@@ -1224,6 +1239,164 @@ async fn async_worker(
                     }
                 });
             }
+            MatrixRequest::SearchMessages {
+                criteria,
+                next_batch,
+                abort_previous_search,
+            } => {
+                log!("MatrixRequest::SearchMessages - search_term: '{}', next_batch: {:?}, abort_previous_search: {}",
+                    criteria.search_term, next_batch, abort_previous_search);
+                if abort_previous_search {
+                    if let Some(abort_handler) = search_task_abort_handler.take() {
+                        abort_handler.abort();
+                    }
+                }
+                if criteria.search_term.is_empty() {
+                    continue;
+                }
+                let Some(client) = get_client() else { continue };
+                let mut search_categories = search::search_events::v3::Categories::new();
+                let search_term = criteria.search_term.clone(); // Capture search term for async task
+                let room_filter = criteria.filter.rooms.clone(); // Capture room filter for async task
+                search_categories.room_events = Some(criteria);
+                let mut req = search::search_events::v3::Request::new(search_categories);
+                req.next_batch = next_batch.clone();
+                
+                let includes_all_rooms = room_filter.as_ref().is_none();
+                let room_name = room_filter.as_ref().and_then(
+                    |room_ids| room_ids.first()
+                ).and_then(
+                    |room_id| {
+                        client.get_room(room_id).and_then(|room| room.name().to_owned())
+                    }
+                );
+                
+                let handle = Handle::current().spawn(async move {
+                    match client.send(req).await {
+                        Ok(response) => {
+                            let next_batch =
+                                response.search_categories.room_events.next_batch.clone();
+                            let mut room_id_for_grouping = None;
+                            let result = response.search_categories;
+                            let mut items = Vector::new();
+                            let mut profile_infos = BTreeMap::new();
+                            let highlights = result.room_events.highlights;
+                            if highlights.is_empty() {
+                                log!("No highlights found in search results for term '{search_term}'");
+                            } else {
+                                log!("Found {} highlights in search results for term '{search_term}', highlighted string: {:?}", highlights.len(), highlights);
+                            }
+                            log!("Search results for term '{search_term}': {:?} events found", result.room_events.count);
+                            
+                            for item in result.room_events.results.iter() {
+                                let Some(event) =
+                                    item.result.as_ref().and_then(|f| f.deserialize().ok())
+                                else {
+                                    continue;
+                                };
+                                
+                                for (user_id, profile) in item.context.profile_info.iter() {
+                                    profile_infos.entry(user_id.clone()).or_insert_with(|| {
+                                        TimelineDetails::Ready(Profile {
+                                            display_name: profile.displayname.clone(),
+                                            display_name_ambiguous: false,
+                                            avatar_url: profile.avatar_url.clone(),
+                                        })
+                                    });
+                                }
+                                let mut message_option = None;
+                                if let AnyTimelineEvent::MessageLike(msg) = &event {
+                                    let mut content = msg.original_content();
+                                    if let Some(replace) = msg.relations().replace {
+                                        content = replace.original_content();
+                                    }
+                                    if let Some(AnyMessageLikeEventContent::RoomMessage(mut message)) = content {
+                                        // We clone the message here so we can inject HTML `<code>` tags
+                                        // for highlighting without modifying the original data in the timeline.
+                                        
+                                        if let Some(Relation::Replacement(replace)) = &message.relates_to {
+                                            let new_content = &replace.new_content;
+                                            message.msgtype = new_content.msgtype.clone();
+                                        }
+                                        highlight_search_terms_in_message(&mut message, &highlights);
+                                        message_option = Some(message);
+                                    }
+                                }
+                                let event_room_id = event.room_id().to_owned();
+                                // Include all rooms in the search results.
+                                if room_filter.is_none() {                                
+                                    if let Some(ref mut room_id_for_grouping) = room_id_for_grouping {
+                                        if room_id_for_grouping != &event_room_id {
+                                            *room_id_for_grouping = event_room_id.clone();
+                                            items.push_back(SearchResultItem::RoomHeader(event_room_id.clone()));
+                                        }
+                                    } else {
+                                        room_id_for_grouping = Some(event_room_id.clone());
+                                        items.push_back(SearchResultItem::RoomHeader(event_room_id.clone()));
+                                    }
+                                }
+                                items.push_back(SearchResultItem::Event{ event, formatted_content: message_option}
+                                );
+                            }
+                            let count = result
+                                .room_events
+                                .count
+                                .and_then(|f| f.to_string().parse().ok())
+                                .unwrap_or(0);
+                            
+                            Cx::post_action(SearchResultAction::Received(SearchResultReceived {
+                                items,
+                                count,
+                                search_term,
+                                profile_infos,
+                                next_batch,
+                                room_name,
+                                includes_all_rooms
+                            }));
+                        }
+                        Err(e) => {
+                            let context = if let Some(rooms) = &room_filter {
+                                if let Some(room_id) = rooms.first() {
+                                    format!("Failed to search messages in room {room_id}")
+                                } else {
+                                    "Failed to search messages".to_string()
+                                }
+                            } else {
+                                "Failed to search messages in all rooms".to_string()
+                            };
+                            error!("{context}: {e:?}");
+                            Cx::post_action(SearchResultAction::ErrorWithNextBatchToken(next_batch.clone()));
+                            enqueue_popup_notification(PopupItem {
+                                message: format!("{context}. Please try again."),
+                                auto_dismissal_duration: None,
+                                kind: PopupKind::Error
+                            });
+                        }
+                    }
+                });
+                search_task_abort_handler = Some(handle.abort_handle());
+            }
+            MatrixRequest::WaitForRoomTimelineLoadedToJump { room_id, event_id } => {
+                let (sender, 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 pagination request for not-yet-known room {room_id}");
+                        continue;
+                    };
+                    
+                    (room_info.timeline_update_sender.clone(), room_info.timeline.clone())
+                };
+                Handle::current().spawn(async move {
+                    // When first loading a room, back pagination will occur, resulting in scroll to message fail.
+                    if timeline.items().await.len() < 100 {
+                        let _ = timeline.paginate_backwards(50).await;
+                    }
+                    sender
+                        .send(TimelineUpdate::ScrollToMessage { event_id })
+                        .unwrap();
+                    SignalToUI::set_ui_signal();
+                });
+            }
         }
     }
 
@@ -2031,9 +2204,8 @@ async fn add_new_room(room: &matrix_sdk::Room, room_list_service: &RoomListServi
     let room_id = room.room_id().to_owned();
     // We must call `display_name()` here to calculate and cache the room's name.
     let room_name = room.display_name().await.map(|n| n.to_string()).ok();
-
+    let is_room_encrypted = room.encryption_state().is_encrypted();
     let is_direct = room.is_direct().await.unwrap_or(false);
-
     match room.state() {
         RoomState::Knocked => {
             // TODO: handle Knocked rooms (e.g., can you re-knock? or cancel a prior knock?)
@@ -2181,6 +2353,7 @@ async fn add_new_room(room: &matrix_sdk::Room, room_list_service: &RoomListServi
         is_selected: false,
         is_direct,
         is_tombstoned: room.is_tombstoned() || room.tombstone_content().is_some(),
+        is_room_encrypted: is_room_encrypted,
     }));
 
     Cx::post_action(AppStateAction::RoomLoadedSuccessfully(room_id));
@@ -2381,7 +2554,6 @@ async fn timeline_subscriber_handler(
     timeline_update_sender: crossbeam_channel::Sender<TimelineUpdate>,
     mut request_receiver: watch::Receiver<Vec<BackwardsPaginateUntilEventRequest>>,
 ) {
-
     /// An inner function that searches the given new timeline items for a target event.
     ///
     /// If the target event is found, it is removed from the `target_event_id_opt` and returned,
diff --git a/src/utils.rs b/src/utils.rs
index 6e9400c7..615a9687 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -365,11 +365,14 @@ pub const MEDIA_THUMBNAIL_FORMAT: MediaFormatConst = MediaFormatConst::Thumbnail
     }
 );
 
-/// Removes leading whitespace and HTML whitespace tags (`<p>` and `<br>`) from the given `text`.
+/// Removes leading whitespace and HTML whitespace tags (`<mx-reply>`, `<p>` and `<br>`) from the given `text`.
 pub fn trim_start_html_whitespace(mut text: &str) -> &str {
     let mut prev_text_len = text.len();
     loop {
         text = text
+        // Search result does not use matrix sdk ui's event timeline hence the body contains <mx-reply> for replied messages.
+        // Makepad html widget cannot display this tag for searched message. Hence <mx-reply> is removed.
+            .trim_start_matches("<mx-reply>")
             .trim_start_matches("<p>")
             .trim_start_matches("<br>")
             .trim_start_matches("<br/>")