diff --git a/src/app.rs b/src/app.rs
index b29d4e16..378edbcf 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -2,7 +2,7 @@ use makepad_widgets::*;
 use matrix_sdk::ruma::OwnedRoomId;
 
 use crate::{
-    home::{main_desktop_ui::RoomsPanelAction, room_screen::MessageAction, rooms_list::RoomListAction}, login::login_screen::LoginAction, verification::VerificationAction, verification_modal::{VerificationModalAction, VerificationModalWidgetRefExt}
+    home::{main_desktop_ui::RoomsPanelAction, room_screen::MessageAction, rooms_list::RoomListAction}, login::login_screen::LoginAction, shared::popup_list::PopupNotificationAction, verification::VerificationAction, verification_modal::{VerificationModalAction, VerificationModalWidgetRefExt}
 };
 
 live_design! {
@@ -15,7 +15,8 @@ live_design! {
     use crate::profile::my_profile_screen::MyProfileScreen;
     use crate::verification_modal::VerificationModal;
     use crate::login::login_screen::LoginScreen;
-
+    use crate::shared::popup_list::PopupList;
+    
     ICON_CHAT = dep("crate://self/resources/icons/chat.svg")
     ICON_CONTACTS = dep("crate://self/resources/icons/contacts.svg")
     ICON_DISCOVER = dep("crate://self/resources/icons/discover.svg")
@@ -118,12 +119,18 @@ live_design! {
                         visible: true
                         login_screen = <LoginScreen> {}
                     }
-
+                    popup = <PopupNotification> {
+                        margin: {top: 45, right: 13},
+                        content: {
+                            <PopupList> {}
+                        }
+                    }
                     verification_modal = <Modal> {
                         content: {
                             verification_modal_inner = <VerificationModal> {}
                         }
                     }
+                    
                     // message_source_modal = <Modal> {
                     //     content: {
                     //         message_source_modal_inner = <MessageSourceModal> {}
@@ -188,7 +195,15 @@ impl MatchEvent for App {
                 self.update_login_visibility(cx);
                 self.ui.redraw(cx);
             }
-
+            match action.downcast_ref() {
+                Some(PopupNotificationAction::Open) => {
+                    self.ui.popup_notification(id!(popup)).open(cx);
+                }
+                Some(PopupNotificationAction::Close) => {
+                    self.ui.popup_notification(id!(popup)).close(cx);
+                }
+                _ => {}
+            }
             match action.as_widget_action().cast() {
                 // A room has been selected, update the app state and navigate to the main content view.
                 RoomListAction::Selected {
diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 7f87a68e..94136bb8 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -21,13 +21,12 @@ use matrix_sdk_ui::timeline::{
 use robius_location::Coordinates;
 
 use crate::{
-    avatar_cache::{self, AvatarCacheEntry}, event_preview::{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::loading_modal::LoadingModalWidgetExt, location::{get_latest_location, init_location_subscriber, request_location_update, LocationAction, LocationRequest, LocationUpdate}, media_cache::{MediaCache, MediaCacheEntry}, profile::{
+    avatar_cache::{self, AvatarCacheEntry}, event_preview::{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::{loading_modal::LoadingModalWidgetExt, message_context_menu::MessageActionBarWidgetRefExt}, location::{get_latest_location, init_location_subscriber, request_location_update, LocationAction, LocationRequest, LocationUpdate}, media_cache::{MediaCache, MediaCacheEntry}, profile::{
         user_profile::{AvatarState, ShowUserProfileAction, UserProfile, UserProfileAndRoomId, UserProfilePaneInfo, UserProfileSlidingPaneRef, UserProfileSlidingPaneWidgetExt},
         user_profile_cache,
     }, shared::{
-        avatar::{AvatarRef, AvatarWidgetRefExt}, html_or_plaintext::{HtmlOrPlaintextRef, HtmlOrPlaintextWidgetRefExt}, jump_to_bottom_button::{JumpToBottomButtonWidgetExt, UnreadMessageCount}, text_or_image::{TextOrImageRef, TextOrImageWidgetRefExt}, typing_animation::TypingAnimationWidgetExt
+        avatar::{AvatarRef, AvatarWidgetRefExt}, html_or_plaintext::{HtmlOrPlaintextRef, HtmlOrPlaintextWidgetRefExt}, jump_to_bottom_button::{JumpToBottomButtonWidgetExt, UnreadMessageCount}, popup_list::enqueue_popup_notification, text_or_image::{TextOrImageRef, TextOrImageWidgetRefExt}, typing_animation::TypingAnimationWidgetExt
     }, sliding_sync::{self, get_client, submit_async_request, take_timeline_endpoints, BackwardsPaginateUntilEventRequest, MatrixRequest, PaginationDirection, TimelineRequestSender}, utils::{self, unix_time_millis_to_datetime, ImageFormat, MediaFormatConst},
-    home::message_context_menu::MessageActionBarWidgetRefExt,
 };
 use rangemap::RangeSet;
 
@@ -1187,6 +1186,7 @@ impl Widget for RoomScreen {
                 log!("Add location button clicked; requesting current location...");
                 if let Err(_e) = init_location_subscriber(cx) {
                     error!("Failed to initialize location subscriber");
+                    enqueue_popup_notification(String::from("Failed to initialize location services."));
                 }
                 self.show_location_preview(cx);
             }
@@ -1832,6 +1832,7 @@ impl RoomScreen {
                 log!("Opening URL \"{}\"", url);
                 if let Err(e) = robius_open::Uri::new(&url).open() {
                     error!("Failed to open URL {:?}. Error: {:?}", url, e);
+                    enqueue_popup_notification("Could not open URL: {url}".to_string());
                 }
             }
             true
@@ -3063,20 +3064,22 @@ fn populate_image_message_content(
         )
         .unwrap_or_default();
 
-    // If we have a known mimetype and it's not an image (e.g., an animated)
-    // then show a message about it being unsupported.
+    // If we have a known mimetype and it's not a static image,
+    // then show a message about it being unsupported (e.g., for animated gifs).
     if let Some(mime) = mimetype.as_ref() {
         if ImageFormat::from_mimetype(mime).is_none() {
             text_or_image_ref.show_text(format!(
                 "{body}\n\nImages/Stickers of type {mime:?} are not yet supported.",
             ));
-            return true;
+            return true; // consider this as fully drawn
         }
     }
 
     let mut fully_drawn = false;
 
-    let mut fetch_and_show_image = |mxc_uri: OwnedMxcUri|
+    // A closure that fetches and shows the image from the given `mxc_uri`,
+    // marking it as fully drawn if the image was available.
+    let mut fetch_and_show_image_uri = |mxc_uri: OwnedMxcUri|
         match media_cache.try_get_media_or_fetch(mxc_uri.clone(), None) {
             MediaCacheEntry::Loaded(data) => {
                 let show_image_result = text_or_image_ref.show_image(|img| {
@@ -3089,53 +3092,54 @@ fn populate_image_message_content(
                     text_or_image_ref.show_text(&err_str);
                 }
 
-                // We're done drawing thumbnail of the image message content, so mark it as fully drawn.
-                fully_drawn = true
+                // We're done drawing the image, so mark it as fully drawn.
+                fully_drawn = true;
             }
             MediaCacheEntry::Requested => {
                 text_or_image_ref.show_text(format!("{body}\n\nFetching image from {:?}", mxc_uri));
                 // Do not consider this thumbnail as being fully drawn, as we're still fetching it.
-                fully_drawn = true
+                fully_drawn = false;
             }
             MediaCacheEntry::Failed => {
                 text_or_image_ref
                     .show_text(format!("{body}\n\nFailed to fetch image from {:?}", mxc_uri));
                 // For now, we consider this as being "complete". In the future, we could support
                 // retrying to fetch thumbnail of the image on a user click/tap.
-                fully_drawn = true
+                fully_drawn = true;
             }
         };
 
-    let mut match_media_source = |media_source: MediaSource| {
+    let mut fetch_and_show_media_source = |media_source: MediaSource| {
         match media_source {
             MediaSource::Encrypted(encrypted) => {
-            // We consider this as "fully drawn" since we don't yet support encryption.
-            text_or_image_ref.show_text(format!(
-                "{body}\n\n[TODO] fetch encrypted image at {:?}",
-                encrypted.url
-            ));
+                // We consider this as "fully drawn" since we don't yet support encryption.
+                text_or_image_ref.show_text(format!(
+                    "{body}\n\n[TODO] fetch encrypted image at {:?}",
+                    encrypted.url
+                ));
             },
             MediaSource::Plain(mxc_uri) => {
-                fetch_and_show_image(mxc_uri)
+                fetch_and_show_image_uri(mxc_uri)
             }
         }
     };
 
     match image_info_source {
         Some((None, media_source)) => {
-            // We fetch the origin of the media if its thumbnail doesnot exist.
-            match_media_source(media_source);
+            // We fetch the original (full-size) media if it does not have a thumbnail.
+            fetch_and_show_media_source(media_source);
         },
-
         Some((Some(image_info), media_source)) => {
-            if let Some(media_source) =  image_info.thumbnail_source {
-                match_media_source(media_source);
+            if let Some(thumbnail_source) =  image_info.thumbnail_source {
+                fetch_and_show_media_source(thumbnail_source);
             } else {
-                match_media_source(media_source);
+                fetch_and_show_media_source(media_source);
             }
         },
-
-        None => { }
+        None => {
+            text_or_image_ref.show_text("{body}\n\nImage message had no source URL.");
+            fully_drawn = true;
+        }
     }
 
     fully_drawn
diff --git a/src/shared/mod.rs b/src/shared/mod.rs
index 2f7c296b..e517cb66 100644
--- a/src/shared/mod.rs
+++ b/src/shared/mod.rs
@@ -10,6 +10,7 @@ pub mod search_bar;
 pub mod styles;
 pub mod text_or_image;
 pub mod typing_animation;
+pub mod popup_list;
 pub mod verification_badge;
 
 pub fn live_design(cx: &mut Cx) {
@@ -23,6 +24,7 @@ pub fn live_design(cx: &mut Cx) {
     html_or_plaintext::live_design(cx);
     typing_animation::live_design(cx);
     jump_to_bottom_button::live_design(cx);
+    popup_list::live_design(cx);
     verification_badge::live_design(cx);
     color_tooltip::live_design(cx);
 }
diff --git a/src/shared/popup_list.rs b/src/shared/popup_list.rs
new file mode 100644
index 00000000..f2a914b9
--- /dev/null
+++ b/src/shared/popup_list.rs
@@ -0,0 +1,202 @@
+use crossbeam_queue::SegQueue;
+use makepad_widgets::*;
+
+static POPUP_NOTIFICATION: SegQueue<String> = SegQueue::new();
+
+/// Displays a new popup notification with the given message.
+/// 
+/// Popup notifications will be shown in the order they were enqueued,
+/// and are currently only removed when manually closed by the user.
+pub fn enqueue_popup_notification(message: String) {
+    POPUP_NOTIFICATION.push(message);
+    Cx::post_action(PopupNotificationAction::Open);
+}
+
+live_design! {
+    use link::theme::*;
+    use link::shaders::*;
+    use link::widgets::*;
+
+    use crate::shared::styles::*;
+    use crate::shared::icon_button::RobrixIconButton;
+    ICO_CLOSE = dep("crate://self/resources/icons/close.svg")
+
+    PopupDialog = <RoundedView> {
+        width: 275
+        height: Fit
+        margin: {top: 20, right: 20}
+        padding: 0
+
+        show_bg: true
+        draw_bg: {
+            color: #fff
+            instance border_radius: 4.0
+            fn pixel(self) -> vec4 {
+                let border_color = #d4;
+                let border_width = 1;
+                let sdf = Sdf2d::viewport(self.pos * self.rect_size);
+                let body = #fff
+
+                sdf.box(
+                    1.,
+                    1.,
+                    self.rect_size.x - 2.0,
+                    self.rect_size.y - 2.0,
+                    self.border_radius
+                )
+                sdf.fill_keep(body)
+
+                sdf.stroke(
+                    border_color,
+                    border_width
+                )
+                return sdf.result
+            }
+        }
+    }
+
+    pub PopupList = {{PopupList}} {
+        width: 275,
+        height: Fit
+        flow: Down
+        spacing: 0,
+        popup_content: <PopupDialog> {
+            flow: Right
+            padding: {top: 5, right: 5, bottom: 5, left: 10}
+            align: {y: 0.0}
+
+            <View> {
+                width: Fill,
+                height: Fit,
+                align: {x: 0.0, y: 0.5}
+                padding: {left: 5, top: 10, bottom: 10, right: 0}
+                popup_label = <Label> {
+                    width: Fill,
+                    height: Fit,
+                    draw_text: {
+                        color: #000,
+                        text_style: <MESSAGE_TEXT_STYLE>{ font_size: 10 },
+                        wrap: Word
+                    }
+                }
+            }
+            // The "X" close button on the top right
+            close_button = <RobrixIconButton> {
+                width: Fit,
+                height: Fit,
+                margin: {left: 0, top: 4, bottom: 4, right: 4},
+                padding: 8,
+                draw_icon: {
+                    svg_file: (ICON_CLOSE),
+                    fn get_color(self) -> vec4 {
+                        return #x888;
+                    }
+                }
+                icon_walk: {width: 12, height: 12}
+            }
+        }
+    }
+
+}
+
+/// A widget that displays a vertical list of popups.
+#[derive(Live, Widget)]
+pub struct PopupList {
+    #[deref]
+    view: View,
+    #[layout]
+    layout: Layout,
+    /// A pointer to the popup content widget.
+    #[live]
+    popup_content: Option<LivePtr>,
+    /// A list of tuples containing individual widgets and their content in the order they were added.
+    #[rust]
+    popups: Vec<(View, String)>,
+}
+
+impl LiveHook for PopupList {
+    fn after_apply(&mut self, cx: &mut Cx, apply: &mut Apply, index: usize, nodes: &[LiveNode]) {
+        for (button, _ ) in self.popups.iter_mut() {
+            if let Some(index) = nodes.child_by_name(index, live_id!(popup_content).as_field()) {
+                button.apply(cx, apply, index, nodes);
+            }
+        }
+    }
+}
+
+impl Widget for PopupList {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        while let Some(message) = POPUP_NOTIFICATION.pop() {
+            self.push(cx, message);            
+        }
+        for (view, _) in self.popups.iter_mut() {
+            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 {
+        if self.popups.is_empty() {
+            return DrawStep::done();
+        }
+        cx.begin_turtle(walk, self.layout);
+        for (view, data) in self.popups.iter_mut() {
+            view.label(id!(popup_label)).set_text(data);
+            let walk = walk.with_margin_bottom(10.0);
+            let _ = view.draw_walk(cx, scope, walk);
+        }
+        cx.end_turtle();
+        DrawStep::done()
+    }
+}
+impl PopupList {
+    /// Adds a new popup with a close button to the right side of the screen. 
+    /// 
+    /// The popup's content is a string given by the `message` parameter.
+    /// New popup will be displayed below the previous ones. 
+    pub fn push(&mut self, cx: &mut Cx, message: String) {
+        self.popups.push((View::new_from_ptr(cx, self.popup_content), message));
+        self.redraw(cx);
+    }
+}
+impl WidgetMatchEvent for PopupList {
+    fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions, _scope: &mut Scope) {
+        let mut removed_indices = Vec::new();
+        for (i, (view, _data)) in self.popups.iter().enumerate() {
+            if view.button(id!(close_button)).clicked(actions) {
+                removed_indices.push(i);
+            }
+        }
+        if removed_indices.is_empty() {
+            return;
+        }
+        for &i in removed_indices.iter() {
+            self.popups.remove(i);
+        }
+        for (view, _) in self.popups.iter_mut() {
+            view.redraw(cx);
+        }
+        if self.popups.is_empty() {
+            Cx::post_action(PopupNotificationAction::Close);
+        }
+    }
+}
+
+impl PopupListRef {
+    /// See [`PopupList::push()`].
+    pub fn push(&self, cx: &mut Cx, message: String) {
+        if let Some(mut inner) = self.borrow_mut() {
+            inner.push(cx, message);
+        }
+    }
+}
+
+/// Popup notification actions
+#[derive(Clone, DefaultNone, Debug)]
+pub enum PopupNotificationAction {
+    None,
+    /// Open popup notification layer
+    Open,
+    /// Close popup notification layer
+    Close,
+}
\ No newline at end of file
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index eefe13b8..a2bbb168 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -34,7 +34,7 @@ use crate::{
     }, login::login_screen::LoginAction, media_cache::MediaCacheEntry, persistent_state::{self, ClientSessionPersisted}, profile::{
         user_profile::{AvatarState, UserProfile},
         user_profile_cache::{enqueue_user_profile_update, UserProfileUpdate},
-    }, shared::jump_to_bottom_button::UnreadMessageCount, utils::MEDIA_THUMBNAIL_FORMAT, verification::add_verification_event_handlers_and_sync_client
+    }, shared::{jump_to_bottom_button::UnreadMessageCount, popup_list::enqueue_popup_notification}, utils::MEDIA_THUMBNAIL_FORMAT, verification::add_verification_event_handlers_and_sync_client
 };
 
 #[derive(Parser, Debug, Default)]
@@ -165,18 +165,20 @@ async fn login(
                 .await?;
             if client.logged_in() {
                 log!("Logged in successfully? {:?}", client.logged_in());
-                enqueue_rooms_list_update(RoomsListUpdate::Status {
-                    status: format!("Logged in as {}. Loading rooms...", cli.user_id),
-                });
+                let status = format!("Logged in as {}.\n → Loading rooms...", cli.user_id);
+                // enqueue_popup_notification(status.clone());
+                enqueue_rooms_list_update(RoomsListUpdate::Status { status });
                 if let Err(e) = persistent_state::save_session(&client, client_session).await {
-                    error!("Failed to save session state to storage: {e:?}");
+                    let err_msg = format!("Failed to save session state to storage: {e}");
+                    error!("{err_msg}");
+                    enqueue_popup_notification(err_msg);
                 }
                 Ok((client, None))
             } else {
-                enqueue_rooms_list_update(RoomsListUpdate::Status {
-                    status: format!("Failed to login as {}: {:?}", cli.user_id, login_result),
-                });
-                bail!("Failed to login as {}: {login_result:?}", cli.user_id);
+                let err_msg = format!("Failed to login as {}: {:?}", cli.user_id, login_result);
+                enqueue_popup_notification(err_msg.clone());
+                enqueue_rooms_list_update(RoomsListUpdate::Status { status: err_msg.clone() });
+                bail!(err_msg);
             }
         }
 
@@ -492,7 +494,9 @@ async fn async_worker(
                         Ok(_) => {
                             // log!("Successfully fetched details for event {event_id} in room {room_id}.");
                         }
-                        Err(ref e) => error!("Error fetching details for event {event_id} in room {room_id}: {e:?}"),
+                        Err(ref _e) => {
+                            // error!("Error fetching details for event {event_id} in room {room_id}: {e:?}");
+                        }
                     }
                     sender.send(TimelineUpdate::EventDetailsFetched {
                         event_id,
@@ -830,12 +834,18 @@ async fn async_worker(
                     if let Some(replied_to_info) = replied_to {
                         match timeline.send_reply(message.into(), replied_to_info, ForwardThread::Yes).await {
                             Ok(_send_handle) => log!("Sent reply message to room {room_id}."),
-                            Err(_e) => error!("Failed to send reply message to room {room_id}: {_e:?}"),
+                            Err(_e) => {
+                                error!("Failed to send reply message to room {room_id}: {_e:?}");
+                                enqueue_popup_notification(format!("Failed to send reply: {_e}"));
+                            }
                         }
                     } else {
                         match timeline.send(message.into()).await {
                             Ok(_send_handle) => log!("Sent message to room {room_id}."),
-                            Err(_e) => error!("Failed to send message to room {room_id}: {_e:?}"),
+                            Err(_e) => {
+                                error!("Failed to send message to room {room_id}: {_e:?}");
+                                enqueue_popup_notification(format!("Failed to send message: {_e}"));
+                            }
                         }
                     }
                     SignalToUI::set_ui_signal();
@@ -960,6 +970,7 @@ pub fn start_matrix_tokio() -> Result<()> {
                             rooms_list::enqueue_rooms_list_update(RoomsListUpdate::Status {
                                 status: e.to_string(),
                             });
+                            enqueue_popup_notification(format!("Rooms list update error: {e}"));
                         },
                         Err(e) => {
                             error!("BUG: failed to join main async loop task: {e:?}");
@@ -977,6 +988,7 @@ pub fn start_matrix_tokio() -> Result<()> {
                             rooms_list::enqueue_rooms_list_update(RoomsListUpdate::Status {
                                 status: e.to_string(),
                             });
+                            enqueue_popup_notification(format!("Rooms list update error: {e}"));
                         },
                         Err(e) => {
                             error!("BUG: failed to join async worker task: {e:?}");
@@ -1179,7 +1191,7 @@ async fn async_main_loop(
                 if let Err(e) = populate_login_types(homeserver_url, &mut login_types).await {
                     error!("Populating Login types failed: {e:?}");
                     Cx::post_action(LoginAction::LoginFailure(
-                        format!("Failed to fetch supported login types from homeserver {homeserver_url}.\n\n{e:?}")
+                        format!("Failed to fetch supported login types from homeserver {homeserver_url}")
                     ));
                 }
                 match login(cli, LoginRequest::LoginByCli, &login_types).await {
@@ -1187,7 +1199,7 @@ async fn async_main_loop(
                     Err(e) => {
                         error!("CLI-based login failed: {e:?}");
                         Cx::post_action(LoginAction::LoginFailure(
-                            format!("Could not login with CLI-provided arguments.\n\nPlease login manually.\n\nError: {e:?}")
+                            format!("Could not login with CLI-provided arguments.\n\nPlease login manually.\n\nError: {e}")
                         ));
                         enqueue_rooms_list_update(RoomsListUpdate::Status {
                             status: format!("Login failed: {e:?}"),
@@ -1212,7 +1224,7 @@ async fn async_main_loop(
             if let Err(e) = populate_login_types(homeserver_url, &mut login_types).await {
                 error!("Populating Login types failed for {homeserver_url}: {e:?}");
                 Cx::post_action(LoginAction::LoginFailure(
-                    format!("Failed to fetch supported login types from homeserver {homeserver_url}.\n\nError: {e:?}")
+                    format!("Failed to fetch supported login types from homeserver {homeserver_url}")
                 ));
             }
             loop {
@@ -1223,7 +1235,7 @@ async fn async_main_loop(
                             if let Err(e) = populate_login_types(&homeserver_url, &mut login_types).await {
                                 error!("Populating Login types failed: {e:?}");
                                 Cx::post_action(LoginAction::LoginFailure(
-                                    format!("Failed to fetch supported login types from homeserver {homeserver_url}.\n\nError: {e:?}")
+                                    format!("Failed to fetch supported login types from homeserver {homeserver_url}")
                                 ));
                             }
                             continue
@@ -1234,11 +1246,11 @@ async fn async_main_loop(
                             }
                             Err(e) => {
                                 error!("Login failed: {e:?}");
-                                Cx::post_action(LoginAction::LoginFailure(format!("{e:?}")));
+                                Cx::post_action(LoginAction::LoginFailure(format!("{e}")));
                                 enqueue_rooms_list_update(RoomsListUpdate::Status {
-                                    status: format!("Login failed: {e:?}"),
+                                    status: format!("Login failed: {e}"),
                                 });
-                            }
+                    }
                         }
                     },
                     None => {
@@ -1252,9 +1264,11 @@ async fn async_main_loop(
 
     Cx::post_action(LoginAction::LoginSuccess);
 
-    enqueue_rooms_list_update(RoomsListUpdate::Status {
-        status: format!("Logged in as {}. Loading rooms...", client.user_id().unwrap()),
-    });
+    let logged_in_user_id = client.user_id()
+        .expect("BUG: client.user_id() returned None after successful login!");
+    let status = format!("Logged in as {}.\n → Loading rooms...", logged_in_user_id);
+    // enqueue_popup_notification(status.clone());
+    enqueue_rooms_list_update(RoomsListUpdate::Status { status });
 
     CLIENT.set(client.clone()).expect("BUG: CLIENT already set!");
 
@@ -2214,7 +2228,7 @@ async fn spawn_sso_server(
                     }
                     enqueue_rooms_list_update(RoomsListUpdate::Status {
                         status: format!(
-                            "Logged in as {:?}. Loading rooms...",
+                            "Logged in as {:?}.\n → Loading rooms...",
                             &identity_provider_res.user_id
                         ),
                     });