diff --git a/src/app.rs b/src/app.rs
index 22476ba1..dc2d81e2 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -7,19 +7,11 @@ use makepad_widgets::*;
 use matrix_sdk::ruma::{OwnedRoomId, RoomId};
 use serde::{Deserialize, Serialize};
 use crate::{
-    avatar_cache::clear_avatar_cache,
-    home::{
+    avatar_cache::clear_avatar_cache, home::{
         main_desktop_ui::MainDesktopUiAction, new_message_context_menu::NewMessageContextMenuWidgetRefExt, room_screen::{MessageAction, clear_timeline_states}, rooms_list::{RoomsListAction, RoomsListRef, RoomsListUpdate, clear_all_invited_rooms, enqueue_rooms_list_update}
-    },
-    join_leave_room_modal::{
+    }, 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::{
+    }, login::login_screen::LoginAction, logout::logout_confirm_modal::{LogoutAction, LogoutConfirmModalAction, LogoutConfirmModalWidgetRefExt}, persistence, profile::user_profile_cache::clear_user_profile_cache, register::register_screen::RegisterAction, room::BasicRoomDetails, shared::{callout_tooltip::{
         CalloutTooltipWidgetRefExt,
         TooltipAction,
     }, image_viewer::{ImageViewerAction, LoadState}}, sliding_sync::current_user_id, utils::RoomNameId, verification::VerificationAction, verification_modal::{
@@ -38,6 +30,7 @@ live_design! {
     use crate::verification_modal::VerificationModal;
     use crate::join_leave_room_modal::JoinLeaveRoomModal;
     use crate::login::login_screen::LoginScreen;
+    use crate::register::register_screen::RegisterScreen;
     use crate::logout::logout_confirm_modal::LogoutConfirmModal;
     use crate::shared::popup_list::*;
     use crate::home::new_message_context_menu::*;
@@ -98,7 +91,10 @@ live_design! {
                             visible: true
                             login_screen = <LoginScreen> {}
                         }
-
+                        register_screen_view = <View> {
+                            visible: false
+                            register_screen = <RegisterScreen> {}
+                        }
                         image_viewer_modal = <Modal> {
                             content: {
                                 width: Fill, height: Fill,
@@ -183,6 +179,7 @@ impl LiveRegister for App {
         crate::home::live_design(cx);
         crate::profile::live_design(cx);
         crate::login::live_design(cx);
+        crate::register::live_design(cx);
         crate::logout::live_design(cx);
     }
 }
@@ -260,11 +257,59 @@ impl MatchEvent for App {
                 continue;
             }
 
-            if let Some(LoginAction::LoginSuccess) = action.downcast_ref() {
-                log!("Received LoginAction::LoginSuccess, hiding login view.");
-                self.app_state.logged_in = true;
-                self.update_login_visibility(cx);
-                self.ui.redraw(cx);
+            // Handle login-related actions
+            if let Some(login_action) = action.downcast_ref::<LoginAction>() {
+                match login_action {
+                    LoginAction::LoginSuccess => {
+                        log!("Received LoginAction::LoginSuccess, hiding login view.");
+                        self.app_state.logged_in = true;
+                        self.update_login_visibility(cx);
+                        self.ui.redraw(cx);
+                    }
+                    LoginAction::NavigateToRegister => {
+                        log!("Navigating from login to register screen");
+                        // Start from a clean register screen state
+                        if let Some(mut register_screen_ref) = self
+                            .ui
+                            .widget(ids!(register_screen_view.register_screen))
+                            .borrow_mut::<crate::register::register_screen::RegisterScreen>()
+                        {
+                            register_screen_ref.reset_screen_state(cx);
+                        }
+                        self.ui.view(ids!(login_screen_view)).set_visible(cx, false);
+                        self.ui.view(ids!(register_screen_view)).set_visible(cx, true);
+                        self.ui.redraw(cx);
+                    }
+                    _ => {}
+                }
+                continue;
+            }
+
+            // Handle register-related actions
+            if let Some(register_action) = action.downcast_ref::<RegisterAction>() {
+                match register_action {
+                    RegisterAction::NavigateToLogin => {
+                        log!("Navigating from register to login screen");
+                        // Reset the register screen state before hiding it
+                        if let Some(mut register_screen_ref) = self.ui.widget(ids!(register_screen_view.register_screen)).borrow_mut::<crate::register::register_screen::RegisterScreen>() {
+                            register_screen_ref.reset_screen_state(cx);
+                        }
+                        self.ui.view(ids!(register_screen_view)).set_visible(cx, false);
+                        self.ui.view(ids!(login_screen_view)).set_visible(cx, true);
+                        self.ui.redraw(cx);
+                    }
+                    RegisterAction::RegistrationSuccess => {
+                        log!("Registration successful, transitioning to logged in state");
+                        // Clear register screen state after successful registration
+                        if let Some(mut register_screen_ref) = self.ui.widget(ids!(register_screen_view.register_screen)).borrow_mut::<crate::register::register_screen::RegisterScreen>() {
+                            register_screen_ref.reset_screen_state(cx);
+                        }
+                        self.app_state.logged_in = true;
+                        self.update_login_visibility(cx);
+                        self.ui.redraw(cx);
+                    }
+                    _ => {}
+                }
                 continue;
             }
 
@@ -545,6 +590,7 @@ impl App {
                 .close(cx);
         }
         self.ui.view(ids!(login_screen_view)).set_visible(cx, show_login);
+        self.ui.view(ids!(register_screen_view)).set_visible(cx, false);
         self.ui.view(ids!(home_screen_view)).set_visible(cx, !show_login);
     }
 
diff --git a/src/lib.rs b/src/lib.rs
index 9b436777..0c677541 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,6 +13,8 @@ pub mod settings;
 
 /// Login screen
 pub mod login;
+/// Register screen
+pub mod register;
 /// Logout confirmation and state management
 pub mod logout;
 /// Core UI content: the main home screen (rooms list), room screen.
diff --git a/src/login/login_screen.rs b/src/login/login_screen.rs
index 208c24eb..7650ff25 100644
--- a/src/login/login_screen.rs
+++ b/src/login/login_screen.rs
@@ -286,8 +286,6 @@ live_design! {
     }
 }
 
-static MATRIX_SIGN_UP_URL: &str = "https://matrix.org/docs/chat_basics/matrix-for-im/#creating-a-matrix-account";
-
 #[derive(Live, LiveHook, Widget)]
 pub struct LoginScreen {
     #[deref] view: View,
@@ -321,8 +319,7 @@ impl MatchEvent for LoginScreen {
         let login_status_modal_inner = self.view.login_status_modal(ids!(login_status_modal_inner));
 
         if signup_button.clicked(actions) {
-            log!("Opening URL \"{}\"", MATRIX_SIGN_UP_URL);
-            let _ = robius_open::Uri::new(MATRIX_SIGN_UP_URL).open();
+            cx.action(LoginAction::NavigateToRegister);
         }
 
         if login_button.clicked(actions)
@@ -370,6 +367,7 @@ impl MatchEvent for LoginScreen {
             }
 
             // Handle login-related actions received from background async tasks.
+            // Skip processing if the login screen is not visible (e.g., user is on register screen)
             match action.downcast_ref() {
                 Some(LoginAction::CliAutoLogin { user_id, homeserver }) => {
                     user_id_input.set_text(cx, user_id);
@@ -454,7 +452,8 @@ impl MatchEvent for LoginScreen {
                 submit_async_request(MatrixRequest::SpawnSSOServer{
                     identity_provider_id: format!("oidc-{}",brand),
                     brand: brand.to_string(),
-                    homeserver_url: homeserver_input.text()
+                    homeserver_url: homeserver_input.text(),
+                    is_registration: false,
                 });
             }
         }
@@ -493,5 +492,7 @@ pub enum LoginAction {
     /// When an SSO-based login is pendng, pressing the cancel button will send
     /// an HTTP request to this SSO server URL to gracefully shut it down.
     SsoSetRedirectUrl(Url),
+    /// Navigate to the register screen.
+    NavigateToRegister,
     None,
 }
diff --git a/src/register/mod.rs b/src/register/mod.rs
new file mode 100644
index 00000000..5a867458
--- /dev/null
+++ b/src/register/mod.rs
@@ -0,0 +1,9 @@
+use makepad_widgets::*;
+
+pub mod register_screen;
+pub mod register_status_modal;
+
+pub fn live_design(cx: &mut Cx) {
+    register_screen::live_design(cx);
+    register_status_modal::live_design(cx);
+}
\ No newline at end of file
diff --git a/src/register/register_screen.rs b/src/register/register_screen.rs
new file mode 100644
index 00000000..a726d7b0
--- /dev/null
+++ b/src/register/register_screen.rs
@@ -0,0 +1,834 @@
+//! Registration screen implementation with support for both password-based and SSO registration.
+//!
+//! # Supported Registration Methods
+//!
+//! ## 1. Password-based Registration (Custom Homeservers)
+//! For custom Matrix homeservers, users can register with username/password:
+//! - Minimum password length: 8 characters
+//! - Automatic UIA handling for `m.login.dummy` and `m.login.registration_token`
+//! - Basic URL validation for custom homeserver addresses
+//!
+//! ## 2. SSO Registration (matrix.org)
+//! For matrix.org, registration uses Google SSO by default:
+//! - **Why Google SSO?** Following Element's implementation, matrix.org primarily uses
+//!   Google OAuth as the main SSO provider for public registrations
+//! - The SSO flow is shared with login - Matrix server automatically determines whether
+//!   to create a new account or login an existing user based on the OAuth identity
+//! - UI provides clear feedback during SSO process (button disabled, status modal)
+//!
+//! # Registration Flow
+//!
+//! ```text
+//! Password Registration:                    SSO Registration:
+//! User → Username/Password → Server         User → Continue with SSO → Browser OAuth
+//!        ↓                                          ↓
+//!        UIA Challenge (if needed)                 Google Authentication
+//!        ↓                                          ↓
+//!        Auto-handle m.login.dummy                 OAuth Callback
+//!        ↓                                          ↓
+//!        Registration Success                      Auto Login/Register
+//! ```
+//!
+//! # SSO Action Handling Design
+//!
+//! The register screen uses source-aware SSO handling:
+//!
+//! ## How It Works
+//! 1. Register screen sends `SpawnSSOServer` with `is_registration: true`
+//! 2. `sliding_sync.rs` sends appropriate actions based on this flag:
+//!    - For registration: `RegisterAction::SsoRegistrationPending/Status/Success/Failure`
+//!    - For login: `LoginAction::SsoPending/Status/LoginSuccess/LoginFailure`
+//! 3. Each screen only receives and handles its own actions
+//!
+//! ## Benefits
+//! - **Zero Coupling:** Login and register screens are completely independent
+//! - **Clear Intent:** The SSO flow knows its purpose from the start
+//! - **No Action Conversion:** No need to intercept and convert actions
+//! - **Maintainable:** Each screen has its own clear action flow
+//!
+//! # Implementation Notes
+//! - SSO at protocol level doesn't distinguish login/register - server decides based on account existence
+//! - Registration currently supports the dummy + registration token UIA stages; more complex flows
+//!   (captcha, email verification, etc.) are not yet implemented and will prompt users to register via web
+
+use makepad_widgets::*;
+use url::Url;
+use crate::sliding_sync::{submit_async_request, MatrixRequest, RegisterRequest};
+use crate::login::login_screen::LoginAction;
+use super::register_status_modal::RegisterStatusModalAction;
+
+live_design! {
+    use link::theme::*;
+    use link::shaders::*;
+    use link::widgets::*;
+
+    use crate::shared::helpers::*;
+    use crate::shared::styles::*;
+    use crate::shared::icon_button::*;
+    use crate::register::register_status_modal::RegisterStatusModal;
+
+    IMG_APP_LOGO = dep("crate://self/resources/robrix_logo_alpha.png")
+    
+    MaskableButton = <RobrixIconButton> {
+        draw_bg: {
+            instance mask: 0.0
+            fn pixel(self) -> vec4 {
+                let base_color = mix(self.color, mix(self.color, self.color_hover, 0.2), self.hover);
+                let gray = dot(base_color.rgb, vec3(0.299, 0.587, 0.114));
+                return mix(base_color, vec4(gray, gray, gray, base_color.a), self.mask);
+            }
+        }
+    }
+
+    pub RegisterScreen = {{RegisterScreen}} {
+        width: Fill, height: Fill,
+        align: {x: 0.5, y: 0.5}
+        show_bg: true,
+        draw_bg: {
+            color: #FFF
+        }
+
+        <ScrollXYView> {
+            width: Fit, height: Fill,
+            // Note: *do NOT* vertically center this, it will break scrolling.
+            align: {x: 0.5}
+            show_bg: true,
+            draw_bg: {
+                color: (COLOR_PRIMARY)
+            }
+
+            <RoundedView> {
+                margin: 40
+                width: Fit, height: Fit
+                align: {x: 0.5, y: 0.5}
+                flow: Overlay,
+
+                show_bg: true,
+                draw_bg: {
+                    color: (COLOR_SECONDARY)
+                    border_radius: 6.0
+                }
+
+                <View> {
+                    width: Fit, height: Fit
+                    flow: Down
+                    align: {x: 0.5, y: 0.5}
+                    padding: 30
+                    margin: 40
+                    spacing: 15.0
+
+                    logo_image = <Image> {
+                        fit: Smallest,
+                        width: 80
+                        source: (IMG_APP_LOGO),
+                    }
+
+                    title = <Label> {
+                        width: Fit, height: Fit
+                        margin: { bottom: 5 }
+                        padding: 0,
+                        draw_text: {
+                            color: (COLOR_TEXT)
+                            text_style: <TITLE_TEXT>{font_size: 16.0}
+                        }
+                        text: "Create account"
+                    }
+
+                    // Homeserver selection area
+                    <View> {
+                        width: 250, height: Fit
+                        flow: Down
+                        spacing: 5
+
+                        <Label> {
+                            width: Fit, height: Fit
+                            draw_text: {
+                                color: (COLOR_TEXT)
+                                text_style: <REGULAR_TEXT>{font_size: 11}
+                            }
+                            text: "Host account on"
+                        }
+
+                        homeserver_selector = <View> {
+                            width: Fill, height: Fit
+                            flow: Right
+                            align: {x: 0.0, y: 0.5}
+                            padding: {left: 10, right: 10, top: 8, bottom: 8}
+                            spacing: 5
+
+                            show_bg: true
+                            draw_bg: {
+                                color: (COLOR_SECONDARY)
+                            }
+
+                            selected_homeserver = <Label> {
+                                width: Fill, height: Fit
+                                draw_text: {
+                                    color: (COLOR_TEXT)
+                                    text_style: <REGULAR_TEXT>{font_size: 12}
+                                }
+                                text: "matrix.org"
+                            }
+
+                            edit_button = <RobrixIconButton> {
+                                width: Fit, height: Fit
+                                padding: {left: 8, right: 8, top: 4, bottom: 4}
+                                draw_bg: {
+                                    color: (COLOR_ACTIVE_PRIMARY)
+                                }
+                                draw_text: {
+                                    color: (COLOR_PRIMARY)
+                                    text_style: <REGULAR_TEXT>{font_size: 10}
+                                }
+                                text: "Edit"
+                            }
+                        }
+
+                        homeserver_description = <Label> {
+                            width: Fill, height: Fit
+                            draw_text: {
+                                color: (COLOR_TEXT)
+                                text_style: <REGULAR_TEXT>{font_size: 9}
+                            }
+                            text: "Join millions for free on the largest public server"
+                        }
+                    }
+
+                    // Homeserver selection options (initially hidden)
+                    homeserver_options = <View> {
+                        width: 250, height: Fit
+                        flow: Down
+                        spacing: 10
+                        visible: false
+
+                        show_bg: true
+                        draw_bg: {
+                            color: (COLOR_SECONDARY)
+                        }
+                        padding: 10
+
+                        <Label> {
+                            width: Fill, height: Fit
+                            draw_text: {
+                                color: (COLOR_TEXT)
+                                text_style: <REGULAR_TEXT>{font_size: 10}
+                            }
+                            text: "Select a homeserver:"
+                        }
+
+                        matrix_option = <RobrixIconButton> {
+                            width: Fill, height: Fit
+                            padding: {left: 10, right: 10, top: 8, bottom: 8}
+                            draw_bg: {
+                                color: (COLOR_BG_DISABLED)
+                            }
+                            draw_text: {
+                                color: (COLOR_TEXT)
+                                text_style: <REGULAR_TEXT>{font_size: 11}
+                            }
+                            text: "● matrix.org"
+                        }
+
+                        other_option = <RobrixIconButton> {
+                            width: Fill, height: Fit
+                            padding: {left: 10, right: 10, top: 8, bottom: 8}
+                            draw_bg: {
+                                color: (COLOR_SECONDARY)
+                            }
+                            draw_text: {
+                                color: (COLOR_TEXT)
+                                text_style: <REGULAR_TEXT>{font_size: 11}
+                            }
+                            text: "○ Other homeserver"
+                        }
+
+                        custom_homeserver = <View> {
+                            width: Fill, height: Fit
+                            visible: false
+                            
+                            custom_homeserver_input = <RobrixTextInput> {
+                                width: Fill, height: Fit
+                                padding: {top: 5, bottom: 5}
+                                empty_text: "your-server.com"
+                                draw_text: {
+                                    text_style: <REGULAR_TEXT>{font_size: 10}
+                                }
+                            }
+                        }
+                    }
+
+                    // Dynamic registration area
+                    sso_area = <View> {
+                        width: 250, height: Fit
+                        flow: Down
+                        spacing: 10
+                        visible: true
+
+                        sso_button = <MaskableButton> {
+                            width: Fill, height: 40
+                            padding: 10
+                            margin: {top: 10}
+                            align: {x: 0.5, y: 0.5}
+                            draw_bg: {
+                                color: (COLOR_ACTIVE_PRIMARY)
+                                mask: 0.0
+                            }
+                            draw_text: {
+                                color: (COLOR_PRIMARY)
+                                text_style: <REGULAR_TEXT> {}
+                            }
+                            text: "Continue with SSO"
+                        }
+                    }
+
+                    password_area = <View> {
+                        width: 250, height: Fit
+                        flow: Down
+                        spacing: 10
+                        visible: false
+
+                        username_input = <RobrixTextInput> {
+                            width: Fill, height: Fit
+                            flow: Right,
+                            padding: 10,
+                            empty_text: "Username"
+                        }
+
+                        password_input = <RobrixTextInput> {
+                            width: Fill, height: Fit
+                            flow: Right,
+                            padding: 10,
+                            empty_text: "Password"
+                            is_password: true,
+                        }
+
+                        confirm_password_input = <RobrixTextInput> {
+                            width: Fill, height: Fit
+                            flow: Right,
+                            padding: 10,
+                            empty_text: "Confirm Password"
+                            is_password: true,
+                        }
+
+                        registration_token_area = <View> {
+                            width: Fill, height: Fit
+                            flow: Down
+                            spacing: 4
+                            visible: false
+
+                            <Label> {
+                                width: Fill, height: Fit
+                                draw_text: {
+                                    color: (COLOR_TEXT)
+                                    text_style: <REGULAR_TEXT>{font_size: 10}
+                                }
+                                text: "This server requires a registration token from the administrator."
+                            }
+
+                            registration_token_input = <RobrixTextInput> {
+                                width: Fill, height: Fit
+                                padding: 10,
+                                empty_text: "Registration token"
+                            }
+                        }
+
+                        register_button = <MaskableButton> {
+                            width: Fill, height: 40
+                            padding: 10
+                            margin: {top: 5, bottom: 10}
+                            align: {x: 0.5, y: 0.5}
+                            draw_bg: {
+                                color: (COLOR_ACTIVE_PRIMARY)
+                                mask: 0.0
+                            }
+                            draw_text: {
+                                color: (COLOR_PRIMARY)
+                                text_style: <REGULAR_TEXT> {}
+                            }
+                            text: "Register"
+                        }
+                    }
+
+                    <View> {
+                        width: 250,
+                        height: Fit,
+                        flow: Right,
+                        spacing: 0.0,
+                        align: {x: 0.5, y: 0.5}
+
+                        left_line = <LineH> {
+                            draw_bg: { color: (COLOR_DIVIDER) }
+                        }
+
+                        <Label> {
+                            width: Fit, height: Fit
+                            padding: {left: 1, right: 1, top: 0, bottom: 0}
+                            draw_text: {
+                                color: (COLOR_TEXT)
+                                text_style: <REGULAR_TEXT>{}
+                            }
+                            text: "Already have an account?"
+                        }
+
+                        right_line = <LineH> {
+                            draw_bg: { color: (COLOR_DIVIDER) }
+                        }
+                    }
+
+                    login_button = <RobrixIconButton> {
+                        width: Fit, height: Fit
+                        padding: {left: 15, right: 15, top: 10, bottom: 10}
+                        margin: {bottom: 5}
+                        align: {x: 0.5, y: 0.5}
+                        draw_bg: {
+                            color: (COLOR_ACTIVE_PRIMARY)
+                        }
+                        draw_text: {
+                            color: (COLOR_PRIMARY)
+                            text_style: <REGULAR_TEXT> {}
+                        }
+                        text: "Back to Login"
+                    }
+                }
+
+                // Modal for registration status (both password and SSO)
+                status_modal = <Modal> {
+                    content: {
+                        status_modal_inner = <RegisterStatusModal> {}
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[derive(Live, LiveHook, Widget)]
+pub struct RegisterScreen {
+    #[deref] view: View,
+    #[rust] is_homeserver_editing: bool,
+    #[rust] selected_homeserver: String,
+    #[rust] sso_pending: bool,
+    #[rust] sso_redirect_url: Option<String>,
+    #[rust] registration_token_required: bool,
+}
+
+impl RegisterScreen {
+    fn toggle_homeserver_options(&mut self, cx: &mut Cx) {
+        self.is_homeserver_editing = !self.is_homeserver_editing;
+        self.view.view(ids!(homeserver_options)).set_visible(cx, self.is_homeserver_editing);
+        self.redraw(cx);
+    }
+    
+    fn show_warning(&self, message: &str) {
+        use crate::shared::popup_list::{enqueue_popup_notification, PopupItem, PopupKind};
+        enqueue_popup_notification(PopupItem {
+            message: message.to_string(),
+            kind: PopupKind::Warning,
+            auto_dismissal_duration: Some(3.0),
+        });
+    }
+    
+    fn update_button_mask(&self, button: &ButtonRef, cx: &mut Cx, mask: f32) {
+        button.apply_over(cx, live! {
+            draw_bg: { mask: (mask) }
+        });
+    }
+
+    fn set_registration_token_required(&mut self, cx: &mut Cx, required: bool) {
+        self.registration_token_required = required;
+        self.view.view(ids!(registration_token_area)).set_visible(cx, required);
+        if !required {
+            self.view.text_input(ids!(registration_token_input)).set_text(cx, "");
+        }
+        self.redraw(cx);
+    }
+    
+    fn reset_modal_state(&mut self, cx: &mut Cx) {
+        let register_button = self.view.button(ids!(register_button));
+        register_button.set_enabled(cx, true);
+        register_button.reset_hover(cx);
+        self.update_button_mask(&register_button, cx, 0.0);
+        self.redraw(cx);
+    }
+
+    fn update_registration_mode(&mut self, cx: &mut Cx) {
+        let is_matrix_org = self.selected_homeserver == "matrix.org" || self.selected_homeserver.is_empty();
+
+        // Update UI based on homeserver selection
+        self.view.view(ids!(sso_area)).set_visible(cx, is_matrix_org);
+        self.view.view(ids!(password_area)).set_visible(cx, !is_matrix_org);
+
+        // Update description text
+        let desc_label = self.view.label(ids!(homeserver_description));
+        if is_matrix_org {
+            desc_label.set_text(cx, "Join millions for free on the largest public server");
+        } else {
+            desc_label.set_text(cx, "Use your custom Matrix homeserver");
+        }
+
+        self.redraw(cx);
+    }
+
+    /// Reset the registration screen to its initial state
+    /// This should be called when navigating away from the registration screen
+    pub fn reset_screen_state(&mut self, cx: &mut Cx) {
+        // Reset internal state
+        self.is_homeserver_editing = false;
+        self.selected_homeserver = "matrix.org".to_string();
+        self.sso_pending = false;
+        self.sso_redirect_url = None;
+        self.set_registration_token_required(cx, false);
+
+        // Reset homeserver selection UI
+        self.view.view(ids!(homeserver_options)).set_visible(cx, false);
+        self.view.label(ids!(selected_homeserver)).set_text(cx, "matrix.org");
+        self.view.view(ids!(custom_homeserver)).set_visible(cx, false);
+
+        // Reset homeserver option buttons
+        let matrix_option_button = self.view.button(ids!(matrix_option));
+        let other_option_button = self.view.button(ids!(other_option));
+        matrix_option_button.set_text(cx, "● matrix.org");
+        other_option_button.set_text(cx, "○ Other homeserver");
+
+        // Clear input fields
+        self.view.text_input(ids!(username_input)).set_text(cx, "");
+        self.view.text_input(ids!(password_input)).set_text(cx, "");
+        self.view.text_input(ids!(confirm_password_input)).set_text(cx, "");
+        self.view.text_input(ids!(custom_homeserver_input)).set_text(cx, "");
+
+        // Reset button states
+        let register_button = self.view.button(ids!(register_button));
+        register_button.set_enabled(cx, true);
+        register_button.reset_hover(cx);
+        self.update_button_mask(&register_button, cx, 0.0);
+
+        let sso_button = self.view.button(ids!(sso_button));
+        sso_button.set_enabled(cx, true);
+        sso_button.reset_hover(cx);
+        self.update_button_mask(&sso_button, cx, 0.0);
+
+        // Close any open modals
+        self.view.modal(ids!(status_modal)).close(cx);
+
+        // Update registration mode to show correct UI for matrix.org
+        self.update_registration_mode(cx);
+
+        self.redraw(cx);
+    }
+}
+
+impl Widget for RegisterScreen {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        self.view.handle_event(cx, event, scope);
+        self.match_event(cx, event);
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        self.view.draw_walk(cx, scope, walk)
+    }
+}
+
+impl MatchEvent for RegisterScreen {
+    fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions) {
+        let login_button = self.view.button(ids!(login_button));
+        let edit_button = self.view.button(ids!(edit_button));
+        let sso_button = self.view.button(ids!(sso_button));
+        
+        // Initialize selected_homeserver if empty
+        if self.selected_homeserver.is_empty() {
+            self.selected_homeserver = "matrix.org".to_string();
+        }
+
+        if login_button.clicked(actions) {
+            cx.action(RegisterAction::NavigateToLogin);
+        }
+        
+        // Handle Edit button click
+        if edit_button.clicked(actions) {
+            self.toggle_homeserver_options(cx);
+        }
+
+        // Handle SSO button click for matrix.org
+        if sso_button.clicked(actions) && !self.sso_pending {
+            // Mark SSO as pending for this screen
+            self.sso_pending = true;
+            self.update_button_mask(&sso_button, cx, 1.0);
+
+            // Show SSO registration modal immediately
+            let status_label = self.view.label(ids!(status_modal_inner.status));
+            status_label.set_text(cx, "Opening your browser...\n\nPlease complete registration in your browser, then return to Robrix.");
+            let cancel_button = self.view.button(ids!(status_modal_inner.cancel_button));
+            cancel_button.set_text(cx, "Cancel");
+            self.view.modal(ids!(status_modal)).open(cx);
+            self.redraw(cx);
+
+            // Use the same SSO flow as login screen - spawn SSO server with Google provider
+            // This follows Element's implementation where SSO login and registration share the same OAuth flow
+            // The Matrix server will handle whether to create a new account or login existing user
+            submit_async_request(MatrixRequest::SpawnSSOServer{
+                identity_provider_id: "oidc-google".to_string(),
+                brand: "google".to_string(),
+                homeserver_url: String::new(), // Use default matrix.org
+                is_registration: true,
+            });
+        }
+        
+        // Handle homeserver selection buttons
+        let matrix_option_button = self.view.button(ids!(matrix_option));
+        let other_option_button = self.view.button(ids!(other_option));
+        
+        if matrix_option_button.clicked(actions) {
+            self.selected_homeserver = "matrix.org".to_string();
+            self.view.label(ids!(selected_homeserver)).set_text(cx, "matrix.org");
+            self.view.view(ids!(custom_homeserver)).set_visible(cx, false);
+            
+            // Update button styles to show selection
+            matrix_option_button.set_text(cx, "● matrix.org");
+            other_option_button.set_text(cx, "○ Other homeserver");
+            
+            self.is_homeserver_editing = false;
+            self.view.view(ids!(homeserver_options)).set_visible(cx, false);
+            self.update_registration_mode(cx);
+        }
+        
+        if other_option_button.clicked(actions) {
+            self.view.view(ids!(custom_homeserver)).set_visible(cx, true);
+            
+            // Update button styles to show selection
+            matrix_option_button.set_text(cx, "○ matrix.org");
+            other_option_button.set_text(cx, "● Other homeserver");
+        }
+        
+        // Handle custom homeserver input
+        if let Some(text_event) = self.view.text_input(ids!(custom_homeserver_input)).changed(actions) {
+            let trimmed = text_event.trim();
+            if !trimmed.is_empty() {
+                // Basic URL validation - ensure it starts with http:// or https://
+                let is_valid_url = trimmed.starts_with("http://") || trimmed.starts_with("https://") 
+                    || (!trimmed.contains("://") && !trimmed.is_empty()); // Allow domain-only input
+
+                if is_valid_url {
+                    self.selected_homeserver = trimmed.to_string();
+                    self.view.label(ids!(selected_homeserver)).set_text(cx, trimmed);
+                    if trimmed != text_event {
+                        self.view.text_input(ids!(custom_homeserver_input)).set_text(cx, trimmed);
+                    }
+                    self.update_registration_mode(cx);
+                }
+            }
+        }
+        
+        // Handle password-based registration
+        let register_button = self.view.button(ids!(register_button));
+        let username_input = self.view.text_input(ids!(username_input));
+        let password_input = self.view.text_input(ids!(password_input));
+        let confirm_password_input = self.view.text_input(ids!(confirm_password_input));
+        let registration_token_input = self.view.text_input(ids!(registration_token_input));
+
+        if register_button.clicked(actions)
+            || username_input.returned(actions).is_some()
+            || password_input.returned(actions).is_some()
+            || confirm_password_input.returned(actions).is_some()
+            || registration_token_input.returned(actions).is_some()
+        {
+            let username = username_input.text();
+            let password = password_input.text();
+            let confirm_password = confirm_password_input.text();
+            let registration_token = registration_token_input.text();
+
+            if username.is_empty() {
+                self.show_warning("Username is required");
+                return;
+            }
+
+            if password.is_empty() {
+                self.show_warning("Password is required");
+                return;
+            }
+
+            // Check password strength - minimum 8 characters
+            if password.len() < 8 {
+                self.show_warning("Password must be at least 8 characters");
+                return;
+            }
+
+            if password != confirm_password {
+                self.show_warning("Passwords do not match");
+                return;
+            }
+
+            let homeserver = if self.selected_homeserver == "matrix.org" {
+                None
+            } else {
+                Some(self.selected_homeserver.clone())
+            };
+
+            // Disable register button to prevent duplicate submissions
+            register_button.set_enabled(cx, false);
+            self.update_button_mask(&register_button, cx, 1.0);
+
+            // Show registration status modal with appropriate text for password registration
+            let status_label = self.view.label(ids!(status_modal_inner.status));
+            status_label.set_text(cx, "Registering account, please wait...");
+            let title_label = self.view.label(ids!(status_modal_inner.title));
+            title_label.set_text(cx, "Registration Status");
+            let cancel_button = self.view.button(ids!(status_modal_inner.cancel_button));
+            cancel_button.set_text(cx, "Cancel");
+            self.view.modal(ids!(status_modal)).open(cx);
+            self.redraw(cx);
+
+            // Submit registration request
+            submit_async_request(MatrixRequest::Register(RegisterRequest {
+                username,
+                password,
+                homeserver,
+                registration_token: {
+                    let token = registration_token.trim();
+                    if token.is_empty() {
+                        None
+                    } else {
+                        Some(token.to_string())
+                    }
+                },
+            }));
+
+            cx.action(RegisterAction::RegistrationSubmitted);
+        }
+
+        // Handle modal closing for both success and failure in one place
+        for action in actions {
+            // Handle RegisterStatusModal close action
+            if let Some(RegisterStatusModalAction::Close { was_internal }) = action.downcast_ref::<RegisterStatusModalAction>() {
+                if *was_internal {
+                    self.view.modal(ids!(status_modal)).close(cx);
+                }
+                if self.sso_pending {
+                    // SSO flow canceled/dismissed - re-enable SSO button so user can retry
+                    if let Some(sso_redirect_url) = &self.sso_redirect_url {
+                        let request_id = id!(REGISTER_SSO_CANCEL_BUTTON);
+                        let request = HttpRequest::new(format!("{}/?login_token=", sso_redirect_url), HttpMethod::GET);
+                        cx.http_request(request_id, request);
+                    }
+                    self.sso_pending = false;
+                    self.sso_redirect_url = None;
+                    self.update_button_mask(&sso_button, cx, 0.0);
+                } else {
+                    // Password registration - reset register button
+                    self.reset_modal_state(cx);
+                }
+                self.redraw(cx);
+            }
+
+            // Handle SSO completion from login flow
+            // SSO success ultimately goes through the login flow, so we listen for LoginSuccess
+            if self.sso_pending {
+                if let Some(LoginAction::LoginSuccess) = action.downcast_ref::<LoginAction>() {
+                    // SSO registration successful
+                    self.view.modal(ids!(status_modal)).close(cx);
+                    self.sso_pending = false;
+                    self.update_button_mask(&sso_button, cx, 0.0);
+                    cx.action(RegisterAction::RegistrationSuccess);
+                    self.redraw(cx);
+                }
+            }
+            
+            // Handle RegisterAction for SSO (now directly sent from sliding_sync.rs)
+            match action.downcast_ref::<RegisterAction>() {
+                Some(RegisterAction::SsoRegistrationPending(pending)) => {
+                    // Update pending state (modal already shown when button clicked)
+                    if !*pending {
+                        // SSO ended
+                        self.sso_pending = false;
+                        self.sso_redirect_url = None;
+                        self.update_button_mask(&sso_button, cx, 0.0);
+                        self.view.modal(ids!(status_modal)).close(cx);
+                    }
+                    self.redraw(cx);
+                }
+                Some(RegisterAction::SsoRegistrationStatus { status }) => {
+                    // Update SSO status in modal (only if our modal is already open)
+                    if self.sso_pending {
+                        let status_label = self.view.label(ids!(status_modal_inner.status));
+                        status_label.set_text(cx, status);
+                        let cancel_button = self.view.button(ids!(status_modal_inner.cancel_button));
+                        cancel_button.set_text(cx, "Cancel");
+                        self.redraw(cx);
+                    }
+                }
+                Some(RegisterAction::RegistrationTokenRequired) => {
+                    if !self.registration_token_required {
+                        self.set_registration_token_required(cx, true);
+                        self.view.text_input(ids!(registration_token_input)).set_key_focus(cx);
+                    }
+                }
+                Some(RegisterAction::SsoSetRedirectUrl(url)) => {
+                    self.sso_redirect_url = Some(url.to_string());
+                }
+                _ => {}
+            }
+
+            if let Some(reg_action) = action.downcast_ref::<RegisterAction>() {
+                match reg_action {
+                    RegisterAction::RegistrationSuccess => {
+                        // Close modal and let app.rs handle screen transition
+                        self.view.modal(ids!(status_modal)).close(cx);
+                        if self.sso_pending {
+                            self.sso_pending = false;
+                            self.sso_redirect_url = None;
+                            self.update_button_mask(&sso_button, cx, 0.0);
+                        }
+                        self.redraw(cx);
+                    }
+                    RegisterAction::RegistrationFailure(error) => {
+                        // Show error and reset buttons
+                        if self.sso_pending {
+                            self.show_warning(error);
+                            self.sso_pending = false;
+                            self.sso_redirect_url = None;
+                            self.update_button_mask(&sso_button, cx, 0.0);
+                        }
+                        self.view.modal(ids!(status_modal)).close(cx);
+                        self.reset_modal_state(cx);
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+}
+
+/// Actions for the registration screen.
+/// 
+/// These actions handle both password-based and SSO registration flows.
+/// SSO actions are completely independent from LoginAction to ensure
+/// no interference between login and register screens.
+#[derive(Clone, DefaultNone, Debug)]
+pub enum RegisterAction {
+    /// User requested to go back to the login screen
+    NavigateToLogin,
+    /// Password registration was submitted (internal use)
+    RegistrationSubmitted,
+    /// Registration completed successfully (both password and SSO)
+    RegistrationSuccess,
+    /// Registration failed with error message (both password and SSO)
+    RegistrationFailure(String),
+    /// SSO registration state changed
+    /// - `true`: SSO flow started, button should be disabled
+    /// - `false`: SSO flow ended, button should be re-enabled
+    SsoRegistrationPending(bool),
+    /// SSO registration progress update (e.g., "Opening browser...")
+    SsoRegistrationStatus { status: String },
+    /// Set the SSO redirect URL for cancellation
+    SsoSetRedirectUrl(Url),
+    /// Password registration flow needs a server-provided token
+    RegistrationTokenRequired,
+    None,
+}
+
+impl RegisterScreenRef {
+    pub fn reset_screen_state(&self, cx: &mut Cx) {
+        if let Some(mut inner) = self.borrow_mut() {
+            inner.reset_screen_state(cx);
+        }
+    }
+}
diff --git a/src/register/register_status_modal.rs b/src/register/register_status_modal.rs
new file mode 100644
index 00000000..dfeeefb8
--- /dev/null
+++ b/src/register/register_status_modal.rs
@@ -0,0 +1,132 @@
+use makepad_widgets::*;
+
+live_design! {
+    use link::theme::*;
+    use link::widgets::*;
+
+    use crate::shared::styles::*;
+    use crate::shared::icon_button::RobrixIconButton;
+
+    // A modal dialog that displays registration progress
+    // Note: Matrix SDK's register function has a built-in 60s timeout
+    pub RegisterStatusModal = {{RegisterStatusModal}} {
+        width: Fit,
+        height: Fit,
+        align: {x: 0.5}
+
+        <RoundedView> {
+            // Same width as LoginStatusModal for consistency
+            width: ((320+250)/2),
+            height: Fit,
+            flow: Down,
+            align: {x: 0.5}
+            padding: 25,
+            spacing: 10,
+
+            show_bg: true
+            draw_bg: {
+                color: #CCC
+                border_radius: 3.0
+            }
+
+            <View> {
+                width: Fill,
+                height: Fit,
+                flow: Right
+                padding: {top: 0, bottom: 10}
+                align: {x: 0.5, y: 0.0}
+
+                title = <Label> {
+                    text: "Registration Status"
+                    draw_text: {
+                        text_style: <TITLE_TEXT>{font_size: 13},
+                        color: #000
+                    }
+                }
+            }
+
+            status = <Label> {
+                width: Fill
+                margin: {top: 5, bottom: 5}
+                draw_text: {
+                    text_style: <REGULAR_TEXT>{
+                        font_size: 11.5,
+                    },
+                    color: #000
+                    wrap: Word
+                },
+                text: "Registering account, please wait..."
+            }
+
+            <View> {
+                width: Fill,
+                height: Fit,
+                flow: Right
+                align: {x: 1.0}
+                margin: {top: 10}
+
+                cancel_button = <RobrixIconButton> {
+                    align: {x: 0.5, y: 0.5}
+                    width: Fit, height: Fit
+                    padding: 12
+                    draw_bg: {
+                        color: (COLOR_ACTIVE_PRIMARY)
+                    }
+                    draw_text: {
+                        color: (COLOR_PRIMARY)
+                        text_style: <REGULAR_TEXT> {}
+                    }
+                    text: "Cancel"
+                }
+            }
+        }
+    }
+}
+
+#[derive(Live, LiveHook, Widget)]
+pub struct RegisterStatusModal {
+    #[deref] view: View,
+}
+
+
+impl Widget for RegisterStatusModal {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        self.view.handle_event(cx, event, scope);
+        self.match_event(cx, event);
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        self.view.draw_walk(cx, scope, walk)
+    }
+}
+
+impl MatchEvent for RegisterStatusModal {
+    fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions) {
+        // Check if modal was dismissed (ESC key or click outside)
+        let modal_dismissed = actions
+            .iter()
+            .any(|a| matches!(a.downcast_ref(), Some(ModalAction::Dismissed)));
+
+        // Check if Abort button was clicked
+        let abort_clicked = self.view.button(ids!(cancel_button)).clicked(actions);
+
+        if abort_clicked || modal_dismissed {
+            // Send action to close the modal with appropriate was_internal flag
+            // Note: This doesn't actually cancel the registration request (still running in background)
+            cx.action(RegisterStatusModalAction::Close {
+                was_internal: abort_clicked 
+            });
+        }
+    }
+}
+
+#[derive(Clone, DefaultNone, Debug)]
+pub enum RegisterStatusModalAction {
+    /// The modal requested to be closed
+    Close {
+        /// Whether the modal was closed by clicking an internal button (Abort)
+        /// or being dismissed externally (ESC or click outside)
+        was_internal: bool,
+    },
+    None,
+}
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 978eb6c5..9b68f93d 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -20,7 +20,7 @@ use matrix_sdk_ui::{
     RoomListService, Timeline, room_list_service::{RoomListItem, RoomListLoadingState, SyncIndicator, filters}, spaces::SpaceService, sync_service::{self, SyncService}, timeline::{EventTimelineItem, LatestEventValue, RoomExt, TimelineDetails, TimelineEventItemId, TimelineItem}
 };
 use robius_open::Uri;
-use ruma::{events::tag::Tags, OwnedRoomOrAliasId};
+use ruma::{OwnedRoomOrAliasId, api::client::uiaa::{AuthData, AuthType, Dummy, RegistrationToken, UiaaInfo}, events::tag::Tags};
 use tokio::{
     runtime::Handle,
     sync::{mpsc::{Sender, UnboundedReceiver, UnboundedSender}, watch, Notify}, task::JoinHandle, time::error::Elapsed,
@@ -34,7 +34,7 @@ use crate::{
     }, login::login_screen::LoginAction, logout::{logout_confirm_modal::LogoutAction, logout_state_machine::{LogoutConfig, is_logout_in_progress, logout_with_state_machine}}, media_cache::{MediaCacheEntry, MediaCacheEntryRef}, persistence::{self, ClientSessionPersisted, load_app_state}, profile::{
         user_profile::{AvatarState, UserProfile},
         user_profile_cache::{UserProfileUpdate, enqueue_user_profile_update},
-    }, room::{FetchedRoomAvatar, FetchedRoomPreview, RoomPreviewAction}, shared::{
+    }, register::register_screen::RegisterAction, room::{FetchedRoomAvatar, FetchedRoomPreview, RoomPreviewAction}, shared::{
         html_or_plaintext::MatrixLinkPillState,
         jump_to_bottom_button::UnreadMessageCount,
         popup_list::{PopupItem, PopupKind, enqueue_popup_notification}
@@ -80,6 +80,34 @@ impl From<LoginByPassword> for Cli {
     }
 }
 
+fn next_supported_uia_stage(uiaa_info: &UiaaInfo) -> Option<AuthType> {
+    fn is_stage_supported(stage: &AuthType) -> bool {
+        matches!(stage, AuthType::Dummy | AuthType::RegistrationToken)
+    }
+
+    fn stage_completed(uiaa_info: &UiaaInfo, stage: &AuthType) -> bool {
+        uiaa_info.completed.iter().any(|completed| completed == stage)
+    }
+
+    for flow in &uiaa_info.flows {
+        if flow.stages.iter().all(is_stage_supported) {
+            for stage in &flow.stages {
+                if !stage_completed(uiaa_info, stage) {
+                    return Some(stage.clone());
+                }
+            }
+        }
+    }
+    None
+}
+
+#[derive(Debug)]
+enum RegisterFlowError {
+    TokenRequired,
+    TokenInvalid,
+    UnsupportedUia,
+    Other(String),
+}
 
 /// Build a new client.
 async fn build_client(
@@ -201,6 +229,130 @@ async fn login(
     }
 }
 
+/// Registers a new user on the given Matrix homeserver using the given username and password.
+///
+/// This function handles the Matrix User-Interactive Authentication (UIA) flow automatically:
+/// 1. First attempt: Send registration without auth to discover what authentication is required
+/// 2. If server returns 401 with UIA info:
+///    - Check what auth types are supported (dummy, registration_token)
+///    - Automatically handle supported types (dummy + registration_token)
+///    - Fail gracefully for unsupported types
+/// 3. Upon success, returns the registered client and session information
+///
+/// Supported UIA types:
+/// - `m.login.dummy`: Simple acknowledgment, handled automatically
+/// - `m.login.registration_token`: Requires pre-shared token from user (obtained out-of-band)
+/// - Others (captcha, email, etc.): Not supported
+async fn register_user(register_request: RegisterRequest) -> std::result::Result<(Client, ClientSessionPersisted), RegisterFlowError> {
+    // Create a Cli struct from the register request
+    let cli = Cli {
+        user_id: register_request.username.clone(),
+        password: register_request.password.clone(),
+        homeserver: register_request.homeserver,
+        ..Default::default()
+    };
+
+    let (client, client_session) = build_client(&cli, app_data_dir())
+        .await
+        .map_err(|e| RegisterFlowError::Other(e.to_string()))?;
+
+    use matrix_sdk::ruma::api::client::account::register::v3::Request as RegisterRequest;
+
+    let mut req = RegisterRequest::new();
+    req.username = Some(cli.user_id.as_str().into());
+    req.password = Some(cli.password.as_str().into());
+    req.initial_device_display_name = Some("robrix-register".into());
+
+    let sanitized_registration_token = register_request
+        .registration_token
+        .as_deref()
+        .map(|token| token.trim())
+        .filter(|token| !token.is_empty())
+        .map(|token| token.to_string());
+
+    // Attempt initial registration
+    let register_result = client.matrix_auth().register(req.clone()).await;
+
+    // Handle registration result
+    match register_result {
+        Ok(_) => {
+            // Registration succeeded without UIA (e.g., open registration)
+            log!("Registration succeeded without UIA");
+        }
+        Err(e) => {
+            // Check if it's a UIA error that we can handle
+            if let Some(mut uiaa_info) = e.as_uiaa_response().cloned() {
+                loop {
+                    let Some(next_stage) = next_supported_uia_stage(&uiaa_info) else {
+                        return Err(RegisterFlowError::UnsupportedUia);
+                    };
+
+                    match next_stage {
+                        AuthType::RegistrationToken => {
+                            let Some(token) = sanitized_registration_token.as_ref() else {
+                                Cx::post_action(RegisterAction::RegistrationTokenRequired);
+                                return Err(RegisterFlowError::TokenRequired);
+                            };
+                            let mut auth_data = RegistrationToken::new(token.clone());
+                            auth_data.session = uiaa_info.session.clone();
+                            req.auth = Some(AuthData::RegistrationToken(auth_data));
+                        }
+                        AuthType::Dummy => {
+                            let mut dummy = Dummy::new();
+                            dummy.session = uiaa_info.session.clone();
+                            req.auth = Some(AuthData::Dummy(dummy));
+                        }
+                        _ => {
+                            return Err(RegisterFlowError::UnsupportedUia);
+                        }
+                    }
+
+                    match client.matrix_auth().register(req.clone()).await {
+                        Ok(_) => break,
+                        Err(err) => {
+                            // Best-effort: SDK doesn't expose a typed invalid-token error yet.
+                            // Update when a structured variant is available.
+                            if err.to_string().contains("Invalid registration token") {
+                                return Err(RegisterFlowError::TokenInvalid);
+                            }
+                            if let Some(next_info) = err.as_uiaa_response().cloned() {
+                                uiaa_info = next_info;
+                                continue;
+                            } else {
+                                return Err(RegisterFlowError::Other(err.to_string()));
+                            }
+                        }
+                    }
+                }
+            } else {
+                // Other registration errors
+                return Err(RegisterFlowError::Other(e.to_string()));
+            }
+        }
+    }
+
+    // Check if the client is logged in after registration
+    // The Matrix SDK automatically logs in the user upon successful registration
+    // This check confirms that the registration was successful and the session is established
+    if client.matrix_auth().logged_in() {
+        log!("Registration successful for user: {}", cli.user_id);
+        let status = format!("Registered as {}.\n → Loading rooms...", cli.user_id);
+        enqueue_rooms_list_update(RoomsListUpdate::Status { status });
+
+        // Session persistence is deferred: after registration we post LoginBySSOSuccess,
+        // which saves the session (avoids double-saving here).
+        Ok((client, client_session))
+    } else {
+        let err_msg = "Registration completed but user is not logged in".to_string();
+        enqueue_popup_notification(PopupItem {
+            message: err_msg.clone(),
+            kind: PopupKind::Error,
+            auto_dismissal_duration: None
+        });
+        Err(RegisterFlowError::Other(err_msg))
+    }
+}
+
 
 /// Which direction to paginate in.
 ///
@@ -275,6 +427,8 @@ pub type OnLinkPreviewFetchedFn = fn(
 pub enum MatrixRequest {
     /// Request from the login screen to log in with the given credentials.
     Login(LoginRequest),
+    /// Request from the register screen to create a new account with the given credentials.
+    Register(RegisterRequest),
     /// Request to logout.
     Logout{
         is_desktop: bool,
@@ -408,6 +562,8 @@ pub enum MatrixRequest {
         brand: String,
         homeserver_url: String,
         identity_provider_id: String,
+        /// Whether this SSO request is for registration (true) or login (false)
+        is_registration: bool,
     },
     /// Subscribe to typing notices for the given room.
     ///
@@ -497,7 +653,6 @@ pub enum LoginRequest{
     LoginBySSOSuccess(Client, ClientSessionPersisted),
     LoginByCli,
     HomeserverLoginTypesQuery(String),
-
 }
 /// Information needed to log in to a Matrix homeserver.
 pub struct LoginByPassword {
@@ -506,6 +661,15 @@ pub struct LoginByPassword {
     pub homeserver: Option<String>,
 }
 
+/// Information needed to register a new user on a Matrix homeserver.
+pub struct RegisterRequest {
+    pub username: String,
+    pub password: String,
+    pub homeserver: Option<String>,
+    /// Registration token if required by the server (configured in server's config)
+    pub registration_token: Option<String>,
+}
+
 
 /// The entry point for the worker task that runs Matrix-related operations.
 ///
@@ -530,6 +694,60 @@ async fn matrix_worker_task(
                 }
             }
 
+            MatrixRequest::Register(register_request) => {
+                // Handle registration in a spawned task
+                let rt = Handle::current();
+                rt.spawn(async move {
+                    match register_user(register_request).await {
+                        Ok((client, client_session)) => {
+                            // Send RegistrationSuccess action to close the registration modal
+                            Cx::post_action(RegisterAction::RegistrationSuccess);
+                            
+                            // After successful registration, we need to initialize all the global state
+                            // (CLIENT, SLIDING_SYNC, room lists, etc.) which is handled by the main login flow.
+                            // 
+                            // We use LoginBySSOSuccess (not LoginByPassword) because:
+                            // 1. Registration already authenticated us - we have a valid client and session
+                            // 2. We don't need to login again (which LoginByPassword would do)
+                            // 3. LoginBySSOSuccess simply passes through the already-authenticated client
+                            //    without making any network requests - it only saves the session locally
+                            // 
+                            // The name is misleading - it's really "UseAuthenticatedClient" that works for
+                            // any pre-authenticated client (SSO, registration, restored session, etc.)
+                            let login_req = LoginRequest::LoginBySSOSuccess(client, client_session);
+                            submit_async_request(MatrixRequest::Login(login_req));
+                        }
+                        Err(e) => {
+                            let (error_msg, popup_kind) = match e {
+                                RegisterFlowError::TokenRequired => (
+                                    String::from("Registration token required. Please enter your token and try again."),
+                                    PopupKind::Warning,
+                                ),
+                                RegisterFlowError::TokenInvalid => (
+                                    String::from("Invalid registration token. Please check the token and try again."),
+                                    PopupKind::Error,
+                                ),
+                                RegisterFlowError::UnsupportedUia => (
+                                    String::from("This server requires verification steps that are not yet supported. Please use the web client to register."),
+                                    PopupKind::Error,
+                                ),
+                                RegisterFlowError::Other(msg) => (
+                                    format!("Registration failed: {msg}"),
+                                    PopupKind::Error,
+                                ),
+                            };
+                            error!("{error_msg}");
+                            enqueue_popup_notification(PopupItem {
+                                message: error_msg.clone(),
+                                kind: popup_kind,
+                                auto_dismissal_duration: None,
+                            });
+                            Cx::post_action(RegisterAction::RegistrationFailure(error_msg));
+                        }
+                    }
+                });
+            }
+
             MatrixRequest::Logout { is_desktop } => {
                 log!("Received MatrixRequest::Logout, is_desktop={}", is_desktop);
                 let _logout_task = Handle::current().spawn(async move {
@@ -1101,8 +1319,8 @@ async fn matrix_worker_task(
                 });
                 subscribers_pinned_events.insert(room_id, subscribe_pinned_events_task);
             }
-            MatrixRequest::SpawnSSOServer { brand, homeserver_url, identity_provider_id} => {
-                spawn_sso_server(brand, homeserver_url, identity_provider_id, login_sender.clone()).await;
+            MatrixRequest::SpawnSSOServer { brand, homeserver_url, identity_provider_id, is_registration } => {
+                spawn_sso_server(brand, homeserver_url, identity_provider_id, is_registration, login_sender.clone()).await;
             }
             MatrixRequest::ResolveRoomAlias(room_alias) => {
                 let Some(client) = get_client() else { continue };
@@ -3200,14 +3418,23 @@ async fn spawn_sso_server(
     brand: String,
     homeserver_url: String,
     identity_provider_id: String,
+    is_registration: bool,
     login_sender: Sender<LoginRequest>,
 ) {
-    Cx::post_action(LoginAction::SsoPending(true));
-    // Post a status update to inform the user that we're waiting for the client to be built.
-    Cx::post_action(LoginAction::Status {
-        title: "Initializing client...".into(),
-        status: "Please wait while Matrix builds and configures the client object for login.".into(),
-    });
+    // Post different actions based on whether it's registration or login
+    if is_registration {
+        Cx::post_action(RegisterAction::SsoRegistrationPending(true));
+        Cx::post_action(RegisterAction::SsoRegistrationStatus {
+            status: "Please wait while Matrix builds and configures the client object for registration.".into(),
+        });
+    } else {
+        Cx::post_action(LoginAction::SsoPending(true));
+        // Post a status update to inform the user that we're waiting for the client to be built.
+        Cx::post_action(LoginAction::Status {
+            title: "Initializing client...".into(),
+            status: "Please wait while Matrix builds and configures the client object for login.".into(),
+        });
+    }
 
     // Wait for the notification that the client has been built
     DEFAULT_SSO_CLIENT_NOTIFIER.notified().await;
@@ -3246,44 +3473,72 @@ async fn spawn_sso_server(
         }
 
         let Some((client, client_session)) = client_and_session else {
-            Cx::post_action(LoginAction::LoginFailure(
-                if let Some(err) = build_client_error {
-                    format!("Could not create client object. Please try to login again.\n\nError: {err}")
-                } else {
-                    String::from("Could not create client object. Please try to login again.")
-                }
-            ));
+            if is_registration {
+                Cx::post_action(RegisterAction::RegistrationFailure(
+                    if let Some(err) = build_client_error {
+                        format!("Could not create client object. Please try to register again.\n\nError: {err}")
+                    } else {
+                        String::from("Could not create client object. Please try to register again.")
+                    }
+                ));
+            } else {
+                Cx::post_action(LoginAction::LoginFailure(
+                    if let Some(err) = build_client_error {
+                        format!("Could not create client object. Please try to login again.\n\nError: {err}")
+                    } else {
+                        String::from("Could not create client object. Please try to login again.")
+                    }
+                ));
+            }
             // This ensures that the called to `DEFAULT_SSO_CLIENT_NOTIFIER.notified()`
             // at the top of this function will not block upon the next login attempt.
             DEFAULT_SSO_CLIENT_NOTIFIER.notify_one();
-            Cx::post_action(LoginAction::SsoPending(false));
+            if is_registration {
+                Cx::post_action(RegisterAction::SsoRegistrationPending(false));
+            } else {
+                Cx::post_action(LoginAction::SsoPending(false));
+            }
             return;
         };
 
         let mut is_logged_in = false;
-        Cx::post_action(LoginAction::Status {
-            title: "Opening your browser...".into(),
-            status: "Please finish logging in using your browser, and then come back to Robrix.".into(),
-        });
+        if is_registration {
+            Cx::post_action(RegisterAction::SsoRegistrationStatus {
+                status: "Please finish registration using your browser, and then come back to Robrix.".into(),
+            });
+        } else {
+            Cx::post_action(LoginAction::Status {
+                title: "Opening your browser...".into(),
+                status: "Please finish logging in using your browser, and then come back to Robrix.".into(),
+            });
+        }
+        let is_registration_for_sso = is_registration;
         match client
             .matrix_auth()
-            .login_sso(|sso_url: String| async move {
-                let url = Url::parse(&sso_url)?;
-                for (key, value) in url.query_pairs() {
-                    if key == "redirectUrl" {
-                        let redirect_url = Url::parse(&value)?;
-                        Cx::post_action(LoginAction::SsoSetRedirectUrl(redirect_url));
-                        break
+            .login_sso(move |sso_url: String| {
+                let is_registration = is_registration_for_sso;
+                async move {
+                    let url = Url::parse(&sso_url)?;
+                    for (key, value) in url.query_pairs() {
+                        if key == "redirectUrl" {
+                            let redirect_url = Url::parse(&value)?;
+                            if is_registration {
+                                Cx::post_action(RegisterAction::SsoSetRedirectUrl(redirect_url));
+                            } else {
+                                Cx::post_action(LoginAction::SsoSetRedirectUrl(redirect_url));
+                            }
+                            break
+                        }
                     }
+                    Uri::new(&sso_url).open().map_err(|err| {
+                        Error::UnknownError(
+                            Box::new(io::Error::other(
+                                format!("Unable to open SSO login url. Error: {:?}", err),
+                            ))
+                            .into(),
+                        )
+                    })
                 }
-                Uri::new(&sso_url).open().map_err(|err| {
-                    Error::UnknownError(
-                        Box::new(io::Error::other(
-                            format!("Unable to open SSO login url. Error: {:?}", err),
-                        ))
-                        .into(),
-                    )
-                })
             })
             .identity_provider_id(&identity_provider_id)
             .initial_device_display_name(&format!("robrix-sso-{brand}"))
@@ -3300,9 +3555,15 @@ async fn spawn_sso_server(
                 if !is_logged_in {
                     if let Err(e) = login_sender.send(LoginRequest::LoginBySSOSuccess(client, client_session)).await {
                         error!("Error sending login request to login_sender: {e:?}");
-                        Cx::post_action(LoginAction::LoginFailure(String::from(
-                            "BUG: failed to send login request to matrix worker thread."
-                        )));
+                        if is_registration {
+                            Cx::post_action(RegisterAction::RegistrationFailure(String::from(
+                                "BUG: failed to send login request to matrix worker thread."
+                            )));
+                        } else {
+                            Cx::post_action(LoginAction::LoginFailure(String::from(
+                                "BUG: failed to send login request to matrix worker thread."
+                            )));
+                        }
                     }
                     enqueue_rooms_list_update(RoomsListUpdate::Status {
                         status: format!(
@@ -3315,7 +3576,11 @@ async fn spawn_sso_server(
             Err(e) => {
                 if !is_logged_in {
                     error!("SSO Login failed: {e:?}");
-                    Cx::post_action(LoginAction::LoginFailure(format!("SSO login failed: {e}")));
+                    if is_registration {
+                        Cx::post_action(RegisterAction::RegistrationFailure(format!("SSO registration failed: {e}")));
+                    } else {
+                        Cx::post_action(LoginAction::LoginFailure(format!("SSO login failed: {e}")));
+                    }
                 }
             }
         }
@@ -3323,7 +3588,11 @@ async fn spawn_sso_server(
         // This ensures that the called to `DEFAULT_SSO_CLIENT_NOTIFIER.notified()`
         // at the top of this function will not block upon the next login attempt.
         DEFAULT_SSO_CLIENT_NOTIFIER.notify_one();
-        Cx::post_action(LoginAction::SsoPending(false));
+        if is_registration {
+            Cx::post_action(RegisterAction::SsoRegistrationPending(false));
+        } else {
+            Cx::post_action(LoginAction::SsoPending(false));
+        }
     });
 }