diff --git a/moxin-backend/src/backend_impls/chat_ui.rs b/moxin-backend/src/backend_impls/chat_ui.rs
index 1cac73cb..411ca05d 100644
--- a/moxin-backend/src/backend_impls/chat_ui.rs
+++ b/moxin-backend/src/backend_impls/chat_ui.rs
@@ -316,22 +316,15 @@ fn create_wasi(
     file: &DownloadedFile,
     load_model: &LoadModelOptions,
 ) -> wasmedge_sdk::WasmEdgeResult<WasiModule> {
-    let ctx_size = if load_model.n_ctx > 0 {
-        Some(load_model.n_ctx.to_string())
-    } else {
-        None
-    };
+    let ctx_size = Some(format!("{}", file.context_size));
 
     let n_gpu_layers = match load_model.gpu_layers {
         moxin_protocol::protocol::GPULayers::Specific(n) => Some(n.to_string()),
         moxin_protocol::protocol::GPULayers::Max => None,
     };
 
-    let batch_size = if load_model.n_batch > 0 {
-        Some(load_model.n_batch.to_string())
-    } else {
-        None
-    };
+    // Set n_batch to a fixed value of 128.
+    let batch_size = Some(format!("128"));
 
     let mut prompt_template = load_model.prompt_template.clone();
     if prompt_template.is_none() && !file.prompt_template.is_empty() {
diff --git a/moxin-backend/src/backend_impls/mod.rs b/moxin-backend/src/backend_impls/mod.rs
index 0dd9d8c3..d91f0653 100644
--- a/moxin-backend/src/backend_impls/mod.rs
+++ b/moxin-backend/src/backend_impls/mod.rs
@@ -136,8 +136,6 @@ fn test_chat() {
             prompt_template: None,
             gpu_layers: moxin_protocol::protocol::GPULayers::Max,
             use_mlock: false,
-            n_batch: 512,
-            n_ctx: 512,
             rope_freq_scale: 0.0,
             rope_freq_base: 0.0,
             context_overflow_policy: moxin_protocol::protocol::ContextOverflowPolicy::StopAtLimit,
@@ -211,8 +209,6 @@ fn test_chat_stop() {
             prompt_template: None,
             gpu_layers: moxin_protocol::protocol::GPULayers::Max,
             use_mlock: false,
-            n_batch: 512,
-            n_ctx: 512,
             rope_freq_scale: 0.0,
             rope_freq_base: 0.0,
             context_overflow_policy: moxin_protocol::protocol::ContextOverflowPolicy::StopAtLimit,
diff --git a/moxin-protocol/src/protocol.rs b/moxin-protocol/src/protocol.rs
index 9b250a58..694ef96c 100644
--- a/moxin-protocol/src/protocol.rs
+++ b/moxin-protocol/src/protocol.rs
@@ -28,8 +28,6 @@ pub struct LoadModelOptions {
     pub prompt_template: Option<String>,
     pub gpu_layers: GPULayers,
     pub use_mlock: bool,
-    pub n_batch: u32,
-    pub n_ctx: u32,
     pub rope_freq_scale: f32,
     pub rope_freq_base: f32,
 
diff --git a/src/app.rs b/src/app.rs
index 47e00ced..82b1c061 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -335,7 +335,7 @@ impl MatchEvent for App {
                     .ui
                     .chat_history_card_options(id!(chat_history_card_options));
                 // TODO: Would be cool to listen for this action inside of the widget itself.
-                chat_history_card_options.selected(cx, chat_id, cords);
+                let _ = chat_history_card_options.selected(cx, chat_id, cords);
             }
         }
     }
diff --git a/src/chat/chat_history_card.rs b/src/chat/chat_history_card.rs
index 1fdfdf39..f63ec5a5 100644
--- a/src/chat/chat_history_card.rs
+++ b/src/chat/chat_history_card.rs
@@ -355,7 +355,7 @@ impl ChatHistoryCard {
         &mut self,
         cx: &mut Cx,
         actions: &Actions,
-        scope: &mut Scope,
+        _scope: &mut Scope,
     ) {
         for action in actions {
             if let ChatHistoryCardAction::ActivateTitleEdition(chat_id) =
diff --git a/src/chat/chat_panel.rs b/src/chat/chat_panel.rs
index 37c62fe1..6ec0a8fa 100644
--- a/src/chat/chat_panel.rs
+++ b/src/chat/chat_panel.rs
@@ -264,6 +264,7 @@ live_design! {
             padding: {left: 25, right: 25, bottom: 20},
 
             no_downloaded_model = <View> {
+                visible: false,
                 width: Fill,
                 height: Fill,
 
@@ -317,6 +318,7 @@ live_design! {
             }
 
             no_model = <View> {
+                visible: false,
                 width: Fill,
                 height: Fill,
 
@@ -424,13 +426,25 @@ enum State {
     Unknown,
     NoModelsAvailable,
     NoModelSelected,
-    ModelSelectedWithEmptyChat,
+    ModelSelectedWithEmptyChat {
+        is_loading: bool,
+    },
     ModelSelectedWithChat {
+        is_loading: bool,
         sticked_to_bottom: bool,
         is_streaming: bool,
     },
 }
 
+enum PromptInputMode {
+    Enabled,
+    Disabled,
+}
+enum PromptInputButton {
+    Send,
+    Stop,
+}
+
 #[derive(Live, LiveHook, Widget)]
 pub struct ChatPanel {
     #[deref]
@@ -454,6 +468,7 @@ impl Widget for ChatPanel {
                 State::ModelSelectedWithChat {
                     is_streaming: true,
                     sticked_to_bottom,
+                    ..
                 } => {
                     if sticked_to_bottom {
                         self.scroll_messages_to_bottom(cx);
@@ -551,7 +566,7 @@ impl WidgetMatchEvent for ChatPanel {
                 is_streaming: false,
                 ..
             }
-            | State::ModelSelectedWithEmptyChat => {
+            | State::ModelSelectedWithEmptyChat { .. } => {
                 self.handle_prompt_input_actions(cx, actions, scope);
             }
             State::ModelSelectedWithChat {
@@ -579,142 +594,119 @@ impl WidgetMatchEvent for ChatPanel {
 impl ChatPanel {
     fn update_state(&mut self, scope: &mut Scope) {
         let store = scope.data.get_mut::<Store>().unwrap();
+        //let loader = &store.chats.model_loader;
 
         self.state = if store.downloads.downloaded_files.is_empty() {
             State::NoModelsAvailable
         } else if store.chats.loaded_model.is_none() {
             State::NoModelSelected
         } else {
-            store
-                .chats
-                .get_current_chat()
-                .map_or(State::ModelSelectedWithEmptyChat, |chat| {
+            let is_loading = store.chats.get_currently_loading_model().is_some();
+
+            store.chats.get_current_chat().map_or(
+                State::ModelSelectedWithEmptyChat { is_loading },
+                |chat| {
                     if chat.borrow().messages.is_empty() {
-                        State::ModelSelectedWithEmptyChat
+                        State::ModelSelectedWithEmptyChat { is_loading }
                     } else {
                         State::ModelSelectedWithChat {
+                            is_loading,
                             sticked_to_bottom: self.portal_list_end_reached
                                 || !matches!(self.state, State::ModelSelectedWithChat { .. }),
                             is_streaming: chat.borrow().is_streaming,
                         }
                     }
-                })
+                },
+            )
         };
     }
 
     fn update_prompt_input(&mut self, cx: &mut Cx) {
         match self.state {
-            State::ModelSelectedWithEmptyChat
+            State::ModelSelectedWithEmptyChat { is_loading: true }
             | State::ModelSelectedWithChat {
+                is_loading: true, ..
+            } => {
+                self.activate_prompt_input(cx, PromptInputMode::Disabled, PromptInputButton::Send);
+            }
+            State::ModelSelectedWithEmptyChat { is_loading: false }
+            | State::ModelSelectedWithChat {
+                is_loading: false,
                 is_streaming: false,
                 ..
             } => {
-                self.enable_or_disable_prompt_buttons(cx);
-                self.show_prompt_send_button(cx);
+                self.activate_prompt_input(cx, PromptInputMode::Enabled, PromptInputButton::Send);
             }
             State::ModelSelectedWithChat {
                 is_streaming: true, ..
             } => {
-                let prompt_input = self.text_input(id!(main_prompt_input.prompt));
-                prompt_input.apply_over(
-                    cx,
-                    live! {
-                        draw_text: { prompt_enabled: 0.0 }
-                    },
-                );
-                self.show_prompt_input_stop_button(cx);
+                self.activate_prompt_input(cx, PromptInputMode::Disabled, PromptInputButton::Stop);
+            }
+            _ => {
+                // Input prompts should not be visible in other conditions
             }
-            _ => {}
         }
     }
 
-    fn enable_or_disable_prompt_buttons(&mut self, cx: &mut Cx) {
+    fn activate_prompt_input(
+        &mut self,
+        cx: &mut Cx,
+        mode: PromptInputMode,
+        button: PromptInputButton,
+    ) {
         let prompt_input = self.text_input(id!(main_prompt_input.prompt));
-        let enable = if !prompt_input.text().is_empty() {
-            1.0
-        } else {
-            0.0
-        };
 
-        prompt_input.apply_over(
-            cx,
-            live! {
-                draw_text: { prompt_enabled: (enable) }
-            },
-        );
-    }
-
-    fn show_prompt_send_button(&mut self, cx: &mut Cx) {
-        self.button(id!(main_prompt_input.prompt_send_button))
-            .set_visible(true);
-        self.button(id!(main_prompt_input.prompt_stop_button))
-            .set_visible(false);
+        let enabled = match mode {
+            PromptInputMode::Enabled => !prompt_input.text().is_empty(),
+            PromptInputMode::Disabled => false,
+        };
 
-        let prompt_input = self.text_input(id!(main_prompt_input.prompt));
-        if !prompt_input.text().is_empty() {
-            self.enable_prompt_buttons(cx);
+        let (button_color, prompt_enabled) = if enabled {
+            (vec3(0.0, 0.0, 0.0), 1.0)
         } else {
-            self.disable_prompt_buttons(cx);
-        }
-    }
-
-    fn show_prompt_input_stop_button(&mut self, cx: &mut Cx) {
-        self.button(id!(main_prompt_input.prompt_send_button))
-            .set_visible(false);
-        self.button(id!(main_prompt_input.prompt_stop_button))
-            .set_visible(true);
-
-        self.enable_prompt_buttons(cx);
-    }
-
-    fn enable_prompt_buttons(&mut self, cx: &mut Cx) {
-        let enabled_color = vec3(0.0, 0.0, 0.0);
-        let send_button = self.button(id!(main_prompt_input.prompt_send_button));
-        send_button.set_enabled(true);
-        send_button.apply_over(
-            cx,
-            live! {
-                draw_bg: {
-                    color: (enabled_color)
-                }
-            },
-        );
+            // The color code is #D0D5DD
+            (vec3(0.816, 0.835, 0.867), 0.0)
+        };
 
-        let stop_button = self.button(id!(main_prompt_input.prompt_stop_button));
-        stop_button.set_enabled(true);
-        stop_button.apply_over(
+        prompt_input.apply_over(
             cx,
             live! {
-                draw_bg: {
-                    color: (enabled_color)
-                }
+                draw_text: { prompt_enabled: (prompt_enabled) }
             },
         );
-    }
 
-    fn disable_prompt_buttons(&mut self, cx: &mut Cx) {
-        let disabled_color = vec3(0.816, 0.835, 0.867); // #D0D5DD
         let send_button = self.button(id!(main_prompt_input.prompt_send_button));
-        send_button.set_enabled(true);
-        send_button.apply_over(
-            cx,
-            live! {
-                draw_bg: {
-                    color: (disabled_color)
-                }
-            },
-        );
-
         let stop_button = self.button(id!(main_prompt_input.prompt_stop_button));
-        stop_button.set_enabled(false);
-        stop_button.apply_over(
-            cx,
-            live! {
-                draw_bg: {
-                    color: (disabled_color)
-                }
-            },
-        );
+        match button {
+            PromptInputButton::Send => {
+                // The send button is enabled or not based on the prompt input
+                send_button.set_visible(true);
+                send_button.set_enabled(enabled);
+                send_button.apply_over(
+                    cx,
+                    live! {
+                        draw_bg: {
+                            color: (button_color)
+                        }
+                    },
+                );
+                stop_button.set_visible(false);
+            }
+            PromptInputButton::Stop => {
+                // The stop button is always enabled, when visible
+                stop_button.set_visible(true);
+                stop_button.set_enabled(true);
+                stop_button.apply_over(
+                    cx,
+                    live! {
+                        draw_bg: {
+                            color: #x000
+                        }
+                    },
+                );
+                send_button.set_visible(false);
+            }
+        }
     }
 
     fn scroll_messages_to_bottom(&mut self, cx: &mut Cx) {
@@ -737,7 +729,7 @@ impl ChatPanel {
     fn handle_prompt_input_actions(&mut self, cx: &mut Cx, actions: &Actions, scope: &mut Scope) {
         let prompt_input = self.text_input(id!(main_prompt_input.prompt));
         if let Some(_text) = prompt_input.changed(actions) {
-            self.update_prompt_input(cx);
+            self.redraw(cx);
         }
 
         if self
@@ -753,20 +745,32 @@ impl ChatPanel {
     }
 
     fn send_message(&mut self, cx: &mut Cx, scope: &mut Scope, prompt: String) {
+        // Check if we have any text to send
         if prompt.trim().is_empty() {
             return;
         }
 
-        let store = scope.data.get_mut::<Store>().unwrap();
-        store.chats.send_chat_message(prompt.clone());
+        // Let's confirm we're in an appropriate state to send a message
+        self.update_state(scope);
+        if matches!(
+            self.state,
+            State::ModelSelectedWithChat {
+                is_streaming: false,
+                is_loading: false,
+                ..
+            } | State::ModelSelectedWithEmptyChat { is_loading: false }
+        ) {
+            let store = scope.data.get_mut::<Store>().unwrap();
+            store.chats.send_chat_message(prompt.clone());
 
-        let prompt_input = self.text_input(id!(main_prompt_input.prompt));
-        prompt_input.set_text_and_redraw(cx, "");
-        prompt_input.set_cursor(0, 0);
-        self.update_prompt_input(cx);
+            let prompt_input = self.text_input(id!(main_prompt_input.prompt));
+            prompt_input.set_text_and_redraw(cx, "");
+            prompt_input.set_cursor(0, 0);
 
-        // Scroll to the bottom when the message is sent
-        self.scroll_messages_to_bottom(cx);
+            // Scroll to the bottom when the message is sent
+            self.scroll_messages_to_bottom(cx);
+            self.redraw(cx);
+        }
     }
 
     fn update_view(&mut self, cx: &mut Cx2d, scope: &mut Scope) {
@@ -774,7 +778,7 @@ impl ChatPanel {
         self.update_prompt_input(cx);
 
         match self.state {
-            State::ModelSelectedWithEmptyChat => {
+            State::ModelSelectedWithEmptyChat { .. } => {
                 let store = scope.data.get::<Store>().unwrap();
 
                 self.view(id!(empty_conversation))
@@ -809,7 +813,7 @@ impl ChatPanel {
 
                 no_model.set_visible(true);
             }
-            State::ModelSelectedWithEmptyChat => {
+            State::ModelSelectedWithEmptyChat { .. } => {
                 jump_to_bottom.set_visible(false);
                 no_downloaded_model.set_visible(false);
                 no_model.set_visible(false);
diff --git a/src/chat/mod.rs b/src/chat/mod.rs
index b9f63d15..6223dbd8 100644
--- a/src/chat/mod.rs
+++ b/src/chat/mod.rs
@@ -10,6 +10,7 @@ pub mod delete_chat_modal;
 pub mod model_info;
 pub mod model_selector;
 pub mod model_selector_list;
+pub mod model_selector_loading;
 pub mod shared;
 
 use makepad_widgets::Cx;
@@ -25,6 +26,7 @@ pub fn live_design(cx: &mut Cx) {
     model_info::live_design(cx);
     model_selector_list::live_design(cx);
     model_selector::live_design(cx);
+    model_selector_loading::live_design(cx);
     shared::live_design(cx);
     delete_chat_modal::live_design(cx);
     chat_history_card_options::live_design(cx);
diff --git a/src/chat/model_selector.rs b/src/chat/model_selector.rs
index 1083a0d7..1947c845 100644
--- a/src/chat/model_selector.rs
+++ b/src/chat/model_selector.rs
@@ -4,7 +4,10 @@ use crate::{
 };
 use makepad_widgets::*;
 
-use super::model_selector_list::{ModelSelectorAction, ModelSelectorListWidgetExt};
+use super::{
+    model_selector_list::{ModelSelectorAction, ModelSelectorListWidgetExt},
+    model_selector_loading::ModelSelectorLoadingWidgetExt,
+};
 
 live_design! {
     import makepad_widgets::base::*;
@@ -14,13 +17,15 @@ live_design! {
 
     import crate::chat::model_info::ModelInfo;
     import crate::chat::model_selector_list::ModelSelectorList;
+    import crate::chat::model_selector_loading::ModelSelectorLoading;
 
     ModelSelectorButton = <RoundedView> {
         width: Fill,
         height: 54,
+        flow: Overlay,
 
         align: {x: 0.0, y: 0.5},
-        padding: 16,
+        padding: 0,
 
         draw_bg: {
             instance radius: 3.0,
@@ -29,11 +34,17 @@ live_design! {
 
         cursor: Hand,
 
+        loading = <ModelSelectorLoading> {
+            width: Fill,
+            height: Fill,
+        }
+
         choose = <View> {
             width: Fill,
             height: Fit,
 
             align: {x: 0.5, y: 0.5},
+            padding: 16,
 
             label = <Label> {
                 draw_text:{
@@ -49,6 +60,8 @@ live_design! {
             show_bg: false,
             visible: false,
 
+            padding: 16,
+
             label = {
                 draw_text: {
                     text_style: <BOLD_FONT>{font_size: 11},
@@ -139,6 +152,41 @@ impl Widget for ModelSelector {
         self.view.handle_event(cx, event, scope);
         self.widget_match_event(cx, event, scope);
 
+        let store = scope.data.get::<Store>().unwrap();
+
+        if let Hit::FingerDown(fd) =
+            event.hits_with_capture_overload(cx, self.view(id!(button)).area(), true)
+        {
+            if !options_to_display(store) {
+                return;
+            };
+            if fd.tap_count == 1 {
+                self.open = !self.open;
+
+                if self.open {
+                    let list = self.model_selector_list(id!(options.list_container.list));
+                    let height = list.get_height();
+                    if height > MAX_OPTIONS_HEIGHT {
+                        self.options_list_height = Some(MAX_OPTIONS_HEIGHT);
+                    } else {
+                        self.options_list_height = Some(height);
+                    }
+
+                    self.view(id!(options)).apply_over(
+                        cx,
+                        live! {
+                            height: Fit,
+                        },
+                    );
+
+                    self.animator_play(cx, id!(open.show));
+                } else {
+                    self.hide_animation_timer = cx.start_timeout(0.3);
+                    self.animator_play(cx, id!(open.hide));
+                }
+            }
+        }
+
         if self.hide_animation_timer.is_event(event).is_some() {
             // When closing animation is done, hide the wrapper element
             self.view(id!(options)).apply_over(cx, live! { height: 0 });
@@ -170,6 +218,8 @@ impl Widget for ModelSelector {
         let store = scope.data.get::<Store>().unwrap();
         let choose_label = self.label(id!(choose.label));
 
+        self.update_loading_model_state(cx, store);
+
         if !options_to_display(store) {
             choose_label.set_text("No Available Models");
             let color = vec3(0.596, 0.635, 0.702);
@@ -257,40 +307,69 @@ impl ModelSelector {
         self.open = false;
         self.view(id!(options)).apply_over(cx, live! { height: 0 });
         self.animator_cut(cx, id!(open.hide));
+        self.redraw(cx);
     }
 
-    fn update_selected_model_info(&mut self, cx: &mut Cx, store: &Store) {
-        let Some(downloaded_file) = store.get_loaded_downloaded_file() else {
-            return;
-        };
+    fn update_loading_model_state(&mut self, cx: &mut Cx, store: &Store) {
+        if store.chats.get_currently_loading_model().is_some() {
+            self.model_selector_loading(id!(loading))
+                .show_and_animate(cx);
+        } else {
+            self.model_selector_loading(id!(loading)).hide();
+        }
+    }
 
+    fn update_selected_model_info(&mut self, cx: &mut Cx, store: &Store) {
         self.view(id!(choose)).apply_over(
             cx,
             live! {
                 visible: false
             },
         );
-        let filename = downloaded_file.file.name;
 
-        let architecture = downloaded_file.model.architecture;
-        let architecture_visible = !architecture.trim().is_empty();
+        if let Some(file) = &store.chats.get_currently_loading_model() {
+            // When a model is being loaded, show the "loading state"
+            let caption = format!("Loading {}", file.name);
+            self.view(id!(selected)).apply_over(
+                cx,
+                live! {
+                    visible: true
+                    label = { text: (caption) }
+                    architecture_tag = { visible: false }
+                    params_size_tag = { visible: false }
+                    file_size_tag = { visible: false }
+                },
+            );
+        } else {
+            let Some(downloaded_file) = store.get_loaded_downloaded_file() else {
+                error!("Error displaying current loaded model");
+                return;
+            };
 
-        let param_size = downloaded_file.model.size;
-        let param_size_visible = !param_size.trim().is_empty();
+            // When a model is loaded, show the model info
+            let filename = downloaded_file.file.name;
 
-        let size = format_model_size(&downloaded_file.file.size).unwrap_or("".to_string());
-        let size_visible = !size.trim().is_empty();
+            let architecture = downloaded_file.model.architecture;
+            let architecture_visible = !architecture.trim().is_empty();
+
+            let param_size = downloaded_file.model.size;
+            let param_size_visible = !param_size.trim().is_empty();
+
+            let size = format_model_size(&downloaded_file.file.size).unwrap_or("".to_string());
+            let size_visible = !size.trim().is_empty();
+
+            self.view(id!(selected)).apply_over(
+                cx,
+                live! {
+                    visible: true
+                    label = { text: (filename) }
+                    architecture_tag = { visible: (architecture_visible), caption = { text: (architecture) }}
+                    params_size_tag = { visible: (param_size_visible), caption = { text: (param_size) }}
+                    file_size_tag = { visible: (size_visible), caption = { text: (size) }}
+                },
+            );
+        }
 
-        self.view(id!(selected)).apply_over(
-            cx,
-            live! {
-                visible: true
-                label = { text: (filename) }
-                architecture_tag = { visible: (architecture_visible), caption = { text: (architecture) }}
-                params_size_tag = { visible: (param_size_visible), caption = { text: (param_size) }}
-                file_size_tag = { visible: (size_visible), caption = { text: (size) }}
-            },
-        );
         self.redraw(cx);
     }
 
@@ -327,4 +406,5 @@ fn options_to_display(store: &Store) -> bool {
 
 fn no_active_model(store: &Store) -> bool {
     store.get_loaded_downloaded_file().is_none()
+        && store.chats.get_currently_loading_model().is_none()
 }
diff --git a/src/chat/model_selector_loading.rs b/src/chat/model_selector_loading.rs
new file mode 100644
index 00000000..55d1902d
--- /dev/null
+++ b/src/chat/model_selector_loading.rs
@@ -0,0 +1,131 @@
+use makepad_widgets::*;
+
+live_design! {
+    import makepad_widgets::base::*;
+    import makepad_widgets::theme_desktop_dark::*;
+    import makepad_draw::shader::std::*;
+
+    import crate::shared::styles::*;
+    import crate::shared::widgets::*;
+    import crate::landing::model_card::ModelCard;
+
+    ANIMATION_SPEED = 1.5;
+
+    Bar = <RoundedView> {
+        width: Fill,
+        height: 8,
+        show_bg: true,
+        draw_bg: {
+            instance radius: 1.0,
+            instance dither: 0.9
+
+            fn get_color(self) -> vec4 {
+                return mix(
+                    #F3FFA2,
+                    #E3FBFF,
+                    self.pos.x + self.dither
+                )
+            }
+
+            fn pixel(self) -> vec4 {
+                let sdf = Sdf2d::viewport(self.pos * self.rect_size)
+                sdf.box(
+                    self.inset.x + self.border_width,
+                    self.inset.y + self.border_width,
+                    self.rect_size.x - (self.inset.x + self.inset.z + self.border_width * 2.0),
+                    self.rect_size.y - (self.inset.y + self.inset.w + self.border_width * 2.0),
+                    max(1.0, self.radius)
+                )
+                sdf.fill_keep(self.get_color())
+                if self.border_width > 0.0 {
+                    sdf.stroke(self.get_border_color(), self.border_width)
+                }
+                return sdf.result;
+            }
+        }
+    }
+
+    ModelSelectorLoading = {{ModelSelectorLoading}} {
+        width: Fill,
+        height: Fill,
+        align: {x: 0, y: 1},
+
+        line = <Bar> {}
+
+        animator: {
+            line = {
+                default: restart,
+                restart = {
+                    redraw: true,
+                    from: {all: Forward {duration: (ANIMATION_SPEED)}}
+                    apply: {line = { draw_bg: {dither: 0.6} }}
+                }
+                run = {
+                    redraw: true,
+                    from: {all: Forward {duration: (ANIMATION_SPEED)}}
+                    apply: {line = { draw_bg: {dither: 0.0} }}
+                }
+            }
+        }
+    }
+}
+
+#[derive(Live, LiveHook, Widget)]
+pub struct ModelSelectorLoading {
+    #[deref]
+    view: View,
+
+    #[animator]
+    animator: Animator,
+
+    #[rust]
+    timer: Timer,
+}
+
+impl Widget for ModelSelectorLoading {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        if self.timer.is_event(event).is_some() {
+            self.update_animation(cx);
+        }
+        if self.animator_handle_event(cx, event).must_redraw() {
+            self.redraw(cx);
+        }
+
+        self.view.handle_event(cx, event, scope);
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        self.view.draw_walk(cx, scope, walk)
+    }
+}
+
+impl ModelSelectorLoading {
+    pub fn update_animation(&mut self, cx: &mut Cx) {
+        self.visible = true;
+        if self.animator_in_state(cx, id!(line.restart)) {
+            self.animator_play(cx, id!(line.run));
+        } else {
+            self.animator_play(cx, id!(line.restart));
+        }
+        self.timer = cx.start_timeout(1.5);
+    }
+}
+
+impl ModelSelectorLoadingRef {
+    pub fn show_and_animate(&mut self, cx: &mut Cx) {
+        let Some(mut inner) = self.borrow_mut() else {
+            return;
+        };
+        if inner.timer.is_empty() {
+            inner.timer = cx.start_timeout(0.2);
+        }
+    }
+
+    pub fn hide(&mut self) {
+        let Some(mut inner) = self.borrow_mut() else {
+            return;
+        };
+        inner.visible = false;
+        inner.timer = Timer::default();
+    }
+}
diff --git a/src/data/chats/mod.rs b/src/data/chats/mod.rs
index cb642202..6bc1f9f6 100644
--- a/src/data/chats/mod.rs
+++ b/src/data/chats/mod.rs
@@ -1,19 +1,24 @@
 pub mod chat;
+pub mod model_loader;
 
 use anyhow::{Context, Result};
 use chat::{Chat, ChatID};
+use model_loader::ModelLoader;
 use moxin_backend::Backend;
-use moxin_protocol::protocol::{Command, LoadModelResponse};
-use moxin_protocol::{data::*, protocol::LoadModelOptions};
+use moxin_protocol::data::*;
+use moxin_protocol::protocol::Command;
 use std::fs;
-use std::{cell::RefCell, path::PathBuf, rc::Rc, sync::mpsc::channel};
+use std::sync::mpsc::channel;
+use std::{cell::RefCell, path::PathBuf, rc::Rc};
 
 use super::filesystem::setup_chats_folder;
 
 pub struct Chats {
     pub backend: Rc<Backend>,
     pub saved_chats: Vec<RefCell<Chat>>,
+
     pub loaded_model: Option<File>,
+    pub model_loader: Option<ModelLoader>,
 
     current_chat_id: Option<ChatID>,
     chats_dir: PathBuf,
@@ -26,6 +31,7 @@ impl Chats {
             saved_chats: Vec::new(),
             current_chat_id: None,
             loaded_model: None,
+            model_loader: None,
             chats_dir: setup_chats_folder(),
         }
     }
@@ -51,43 +57,32 @@ impl Chats {
             .map(|c| c.borrow().id)
     }
 
-    pub fn load_model(&mut self, file: &File) -> Result<()> {
-        let (tx, rx) = channel();
-        let cmd = Command::LoadModel(
-            file.id.clone(),
-            LoadModelOptions {
-                prompt_template: None,
-                gpu_layers: moxin_protocol::protocol::GPULayers::Max,
-                use_mlock: false,
-                n_batch: 512,
-                n_ctx: 512,
-                rope_freq_scale: 0.0,
-                rope_freq_base: 0.0,
-                context_overflow_policy:
-                    moxin_protocol::protocol::ContextOverflowPolicy::StopAtLimit,
-            },
-            tx,
-        );
-
-        self.backend.as_ref().command_sender.send(cmd).unwrap();
-
-        if let Ok(response) = rx.recv() {
-            match response {
-                Ok(LoadModelResponse::Completed(_)) => {
-                    self.loaded_model = Some(file.clone());
-                    Ok(())
-                }
-                Ok(_) => {
-                    eprintln!("Error loading model: Unexpected response");
-                    Err(anyhow::anyhow!("Error loading model: Unexpected response"))
-                }
-                Err(err) => {
-                    eprintln!("Error loading model: {:?}", err);
-                    Err(err)
-                }
+    pub fn load_model(&mut self, file: &File) {
+        if let Some(loader) = &self.model_loader {
+            if !loader.complete {
+                return;
+            }
+        }
+
+        let loader = ModelLoader::new(file.clone());
+        loader.load_model(self.backend.as_ref());
+        self.model_loader = Some(loader);
+    }
+
+    pub fn get_currently_loading_model(&self) -> Option<&File> {
+        self.model_loader.as_ref().filter(|loader| !loader.complete).map(|loader| &loader.file)
+    }
+
+    pub fn update_load_model(&mut self) {
+        let loader = self.model_loader.as_mut();
+        if let Some(loader) = loader {
+            if loader.check_load_response().is_ok() {
+                self.loaded_model = Some(loader.file.clone());
+            }
+
+            if loader.complete {
+                self.model_loader = None;
             }
-        } else {
-            Err(anyhow::anyhow!("Error loading model"))
         }
     }
 
diff --git a/src/data/chats/model_loader.rs b/src/data/chats/model_loader.rs
new file mode 100644
index 00000000..98e723d4
--- /dev/null
+++ b/src/data/chats/model_loader.rs
@@ -0,0 +1,88 @@
+use std::{sync::mpsc::{channel, Receiver, Sender}, thread};
+use anyhow::Result;
+use makepad_widgets::SignalToUI;
+use moxin_backend::Backend;
+use moxin_protocol::{data::File, protocol::{Command, LoadModelOptions, LoadModelResponse}};
+
+pub struct ModelLoader {
+    pub complete: bool,
+    pub file: File,
+    load_sender: Sender<Result<()>>,
+    load_receiver: Receiver<Result<()>>,
+}
+
+impl ModelLoader {
+    pub fn new(file: File) -> Self {
+        let (tx, rx) = channel();
+        Self {
+            complete: false,
+            file,
+            load_sender: tx,
+            load_receiver: rx,
+        }
+    }
+
+    pub fn load_model(&self, backend: &Backend) {
+        let (tx, rx) = channel();
+        let cmd = Command::LoadModel(
+            self.file.id.clone(),
+            LoadModelOptions {
+                prompt_template: None,
+                gpu_layers: moxin_protocol::protocol::GPULayers::Max,
+                use_mlock: false,
+                rope_freq_scale: 0.0,
+                rope_freq_base: 0.0,
+                context_overflow_policy:
+                    moxin_protocol::protocol::ContextOverflowPolicy::StopAtLimit,
+            },
+            tx,
+        );
+
+        let load_model_tx = self.load_sender.clone();
+
+        backend.command_sender.send(cmd).unwrap();
+
+        thread::spawn(move || {
+            if let Ok(response) = rx.recv() {
+                match response {
+                    Ok(LoadModelResponse::Completed(_)) => {
+                        load_model_tx.send(Ok(())).unwrap();
+                    }
+                    Ok(_) => {
+                        eprintln!("Error loading model: Unexpected response");
+                        load_model_tx.send(
+                            Err(anyhow::anyhow!("Error loading model: Unexpected response"))
+                        ).unwrap();
+                    }
+                    Err(err) => {
+                        eprintln!("Error loading model: {:?}", err);
+                        load_model_tx.send(Err(err)).unwrap();
+                    }
+                }
+            } else {
+                load_model_tx.send(
+                    Err(anyhow::anyhow!("Error loading model"))
+                ).unwrap();
+            }
+
+            SignalToUI::set_ui_signal();
+        });
+    }
+
+    pub fn check_load_response(&mut self) -> Result<()> {
+        for msg in self.load_receiver.try_iter() {
+            match msg {
+                Ok(_) => {
+                    self.complete = true;
+                    return Ok(())
+                }
+                Err(err) => {
+                    self.complete = true;
+                    return Err(err.into())
+                }
+            }
+        };
+
+        Ok(())
+    }
+}
\ No newline at end of file
diff --git a/src/data/store.rs b/src/data/store.rs
index 70e4680f..bbecd0e4 100644
--- a/src/data/store.rs
+++ b/src/data/store.rs
@@ -88,7 +88,13 @@ impl Store {
     }
 
     pub fn load_model(&mut self, file: &File) {
-        if self.chats.load_model(file).is_ok() {
+        self.chats.load_model(file);
+    }
+
+    fn update_load_model(&mut self) {
+        self.chats.update_load_model();
+
+        if let Some(file) = &self.chats.loaded_model {
             self.preferences.set_current_chat_model(file.id.clone());
 
             // If there is no chat, create an empty one
@@ -222,6 +228,7 @@ impl Store {
         self.update_downloads();
         self.update_chat_messages();
         self.update_search_results();
+        self.update_load_model();
     }
 
     fn update_search_results(&mut self) {