From 4592661a1bda0aaa6396dfcfd59d1d3d0302a244 Mon Sep 17 00:00:00 2001
From: Milan Stastny <milan@acheta.games>
Date: Sat, 20 Apr 2024 09:56:14 +0200
Subject: [PATCH] Work in progress move to async-channel

---
 .idea/runConfigurations/Run.xml               |   4 +-
 Cargo.toml                                    |   2 +-
 src/main.rs                                   |   9 --
 src/models/engine_data.rs                     |   2 +
 src/models/mod.rs                             |  14 ++-
 src/models/plugin_data.rs                     |   1 +
 src/models/project_data.rs                    |  67 +++++------
 src/ui/authentication.rs                      |  12 +-
 src/ui/widgets/download_manager/asset.rs      |  90 +++++++++-----
 src/ui/widgets/download_manager/docker.rs     |  27 +++--
 src/ui/widgets/download_manager/epic_file.rs  |  69 +++++++----
 src/ui/widgets/download_manager/mod.rs        |  29 ++---
 .../logged_in/engines/docker_download.rs      |  30 ++---
 .../logged_in/engines/epic_download.rs        | 113 ++++++++++--------
 src/ui/widgets/logged_in/engines/mod.rs       |  45 +++----
 .../widgets/logged_in/library/actions/mod.rs  |  23 ++--
 .../widgets/logged_in/library/image_stack.rs  |  48 ++++----
 src/ui/widgets/logged_in/library/mod.rs       |  23 ++--
 .../widgets/logged_in/library/sidebar/mod.rs  |  39 +++---
 src/ui/widgets/logged_in/logs.rs              |  12 +-
 src/ui/widgets/logged_in/plugins.rs           |  14 ++-
 src/ui/widgets/logged_in/projects/mod.rs      |  44 ++++---
 src/window.rs                                 |  18 +--
 23 files changed, 411 insertions(+), 324 deletions(-)

diff --git a/.idea/runConfigurations/Run.xml b/.idea/runConfigurations/Run.xml
index 998f402..05c8d74 100644
--- a/.idea/runConfigurations/Run.xml
+++ b/.idea/runConfigurations/Run.xml
@@ -11,7 +11,9 @@
     <option name="INTERPRETER_OPTIONS" value="" />
     <option name="EXECUTE_IN_TERMINAL" value="false" />
     <option name="EXECUTE_SCRIPT_FILE" value="true" />
-    <envs />
+    <envs>
+      <env name="RUST_LOG" value="debug" />
+    </envs>
     <method v="2">
       <option name="RunConfigurationTask" enabled="true" run_configuration_name="Build" run_configuration_type="ShConfigurationType" />
       <option name="RunConfigurationTask" enabled="true" run_configuration_name="Install" run_configuration_type="ShConfigurationType" />
diff --git a/Cargo.toml b/Cargo.toml
index 31429e5..1ef850c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,7 +36,7 @@ serde_json = "1"
 sha-1 = "0.10"
 threadpool = "1.8"
 tokio = { version = "1", features = ["rt-multi-thread"] }
-version-compare = "0.1"
+version-compare = "0.2"
 zip = "0.6"
 
 [target.'cfg(target_os = "windows")'.build-dependencies]
diff --git a/src/main.rs b/src/main.rs
index 574eec0..eb1eb89 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -22,15 +22,6 @@ lazy_static::lazy_static! {
     static ref RUNNING: Arc<std::sync::RwLock<bool>> = Arc::new(std::sync::RwLock::new(true));
 }
 
-fn runtime() -> &'static tokio::runtime::Runtime {
-    static RUNTIME: std::sync::OnceLock<tokio::runtime::Runtime> = std::sync::OnceLock::new();
-    RUNTIME.get_or_init(|| {
-        tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .expect("Setting up tokio runtime needs to succeed.")
-    })
-}
 fn main() {
     env_logger::Builder::from_env(Env::default().default_filter_or("epic_asset_manager:info"))
         .format(|buf, record| {
diff --git a/src/models/engine_data.rs b/src/models/engine_data.rs
index f0cd2e5..087bea1 100644
--- a/src/models/engine_data.rs
+++ b/src/models/engine_data.rs
@@ -1,5 +1,6 @@
 use glib::ObjectExt;
 use gtk4::{glib, prelude::*, subclass::prelude::*};
+use log::debug;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::io::Read;
@@ -261,6 +262,7 @@ impl EngineData {
         let engine = self.clone();
         glib::spawn_future_local(async move {
             while let Ok(response) = receiver.recv().await {
+                debug!("engine_data: {:?}", &response);
                 engine.update(response);
             }
         });
diff --git a/src/models/mod.rs b/src/models/mod.rs
index 48b40bb..65cd884 100644
--- a/src/models/mod.rs
+++ b/src/models/mod.rs
@@ -9,7 +9,7 @@ pub mod project_data;
 use crate::config::APP_ID;
 use egs_api::EpicGames;
 use gtk4::gio;
-use gtk4::glib::{MainContext, Priority, Receiver, Sender, UserDirectory};
+use gtk4::glib::UserDirectory;
 use gtk4::prelude::*;
 use log::{debug, error, info, warn};
 use std::cell::RefCell;
@@ -23,8 +23,8 @@ pub struct Model {
     pub epic_games: RefCell<EpicGames>,
     #[cfg(target_os = "linux")]
     pub secret_service: Option<SecretService<'static>>,
-    pub sender: Sender<crate::ui::messages::Msg>,
-    pub receiver: RefCell<Option<Receiver<crate::ui::messages::Msg>>>,
+    pub sender: async_channel::Sender<crate::ui::messages::Msg>,
+    pub receiver: RefCell<Option<async_channel::Receiver<crate::ui::messages::Msg>>>,
     pub settings: gio::Settings,
     #[cfg(target_os = "linux")]
     pub dclient: RefCell<Option<ghregistry::Client>>,
@@ -38,7 +38,7 @@ impl Default for Model {
 
 impl Model {
     pub fn new() -> Self {
-        let (sender, receiver) = MainContext::channel(Priority::default());
+        let (sender, receiver) = async_channel::bounded(1);
         let mut obj = Self {
             epic_games: RefCell::new(EpicGames::new()),
             #[cfg(target_os = "linux")]
@@ -145,7 +145,9 @@ impl Model {
                         Ok(auth) => {
                             if auth {
                                 sender
-                                    .send(crate::ui::messages::Msg::DockerClient(docker_client))
+                                    .send_blocking(crate::ui::messages::Msg::DockerClient(
+                                        docker_client,
+                                    ))
                                     .unwrap();
                                 info!("Docker Authenticated");
                             }
@@ -157,7 +159,7 @@ impl Model {
                     Err(e) => {
                         error!("Failed authentication {:?}", e);
                         sender
-                            .send(crate::ui::messages::Msg::GithubAuthFailed)
+                            .send_blocking(crate::ui::messages::Msg::GithubAuthFailed)
                             .unwrap();
                     }
                 };
diff --git a/src/models/plugin_data.rs b/src/models/plugin_data.rs
index d591143..5cd6555 100644
--- a/src/models/plugin_data.rs
+++ b/src/models/plugin_data.rs
@@ -254,6 +254,7 @@ impl PluginData {
         let project = self.clone();
         glib::spawn_future_local(async move {
             while let Ok(response) = receiver.recv().await {
+                debug!("plugin_data: {:?}", &response);
                 project.update(response);
             }
         });
diff --git a/src/models/project_data.rs b/src/models/project_data.rs
index c0cd74c..485c824 100644
--- a/src/models/project_data.rs
+++ b/src/models/project_data.rs
@@ -1,14 +1,14 @@
-use glib::ObjectExt;
-use gtk4::gdk::Texture;
-use gtk4::glib::clone;
-use gtk4::{self, glib, subclass::prelude::*};
-use log::{error, info};
-use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::io::Read;
 use std::path::PathBuf;
 use std::thread;
 
+use glib::ObjectExt;
+use gtk4::gdk::Texture;
+use gtk4::{self, glib, subclass::prelude::*};
+use log::{debug, error, info};
+use serde::{Deserialize, Serialize};
+
 #[derive(Default, Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "PascalCase")]
 pub struct Uproject {
@@ -34,16 +34,18 @@ pub struct Uproject {
 
 #[derive(Debug, Clone)]
 pub enum Msg {
-    Thumbnail(gtk4::gdk::Texture),
+    Thumbnail(Texture),
 }
 
 // Implementation sub-module of the GObject
 mod imp {
-    use super::*;
+    use std::cell::RefCell;
+
     use glib::ToValue;
     use gtk4::gdk::Texture;
-    use gtk4::glib::{ParamSpec, ParamSpecObject, ParamSpecString, Priority};
-    use std::cell::RefCell;
+    use gtk4::glib::{ParamSpec, ParamSpecObject, ParamSpecString};
+
+    use super::*;
 
     // The actual data structure that stores our values. This is not accessible
     // directly from the outside.
@@ -52,10 +54,10 @@ mod imp {
         guid: RefCell<Option<String>>,
         path: RefCell<Option<String>>,
         name: RefCell<Option<String>>,
-        pub uproject: RefCell<Option<super::Uproject>>,
+        pub uproject: RefCell<Option<Uproject>>,
         thumbnail: RefCell<Option<Texture>>,
-        pub sender: gtk4::glib::Sender<super::Msg>,
-        pub receiver: RefCell<Option<gtk4::glib::Receiver<super::Msg>>>,
+        pub sender: async_channel::Sender<Msg>,
+        pub receiver: RefCell<Option<async_channel::Receiver<Msg>>>,
     }
 
     // Basic declaration of our type for the GObject type system
@@ -66,7 +68,7 @@ mod imp {
         type ParentType = glib::Object;
 
         fn new() -> Self {
-            let (sender, receiver) = gtk4::glib::MainContext::channel(Priority::default());
+            let (sender, receiver) = async_channel::bounded(1);
             Self {
                 guid: RefCell::new(None),
                 path: RefCell::new(None),
@@ -91,10 +93,10 @@ mod imp {
             self.obj().setup_messaging();
         }
 
-        fn signals() -> &'static [gtk4::glib::subclass::Signal] {
-            static SIGNALS: once_cell::sync::Lazy<Vec<gtk4::glib::subclass::Signal>> =
+        fn signals() -> &'static [glib::subclass::Signal] {
+            static SIGNALS: once_cell::sync::Lazy<Vec<glib::subclass::Signal>> =
                 once_cell::sync::Lazy::new(|| {
-                    vec![gtk4::glib::subclass::Signal::builder("finished")
+                    vec![glib::subclass::Signal::builder("finished")
                         .flags(glib::SignalFlags::ACTION)
                         .build()]
                 });
@@ -201,13 +203,10 @@ impl ProjectData {
         if let Ok(mut file) = std::fs::File::open(p) {
             let mut contents = String::new();
             if file.read_to_string(&mut contents).is_ok() {
-                return match serde_json::from_str::<Uproject>(&contents) {
-                    Ok(uproject) => uproject,
-                    Err(e) => {
-                        error!("Unable to parse uproject {path}: {e}");
-                        Uproject::default()
-                    }
-                };
+                return serde_json::from_str::<Uproject>(&contents).unwrap_or_else(|e| {
+                    error!("Unable to parse uproject {path}: {e}");
+                    Uproject::default()
+                });
             }
         }
         Uproject::default()
@@ -221,13 +220,13 @@ impl ProjectData {
     pub fn setup_messaging(&self) {
         let self_ = self.imp();
         let receiver = self_.receiver.borrow_mut().take().unwrap();
-        receiver.attach(
-            None,
-            clone!(@weak self as project => @default-panic, move |msg| {
-                project.update(msg);
-                glib::ControlFlow::Continue
-            }),
-        );
+        let project = self.clone();
+        glib::spawn_future_local(async move {
+            while let Ok(response) = receiver.recv().await {
+                debug!("project_data: {:?}", &response);
+                project.update(response);
+            }
+        });
     }
 
     pub fn update(&self, msg: Msg) {
@@ -239,7 +238,7 @@ impl ProjectData {
         self.emit_by_name::<()>("finished", &[]);
     }
 
-    pub fn load_thumbnail(path: &str, sender: &gtk4::glib::Sender<Msg>) {
+    pub fn load_thumbnail(path: &str, sender: &async_channel::Sender<Msg>) {
         let mut pathbuf = match PathBuf::from(&path).parent() {
             None => return,
             Some(p) => p.to_path_buf(),
@@ -247,8 +246,8 @@ impl ProjectData {
         pathbuf.push("Saved");
         pathbuf.push("AutoScreenshot.png");
         if pathbuf.exists() {
-            match gtk4::gdk::Texture::from_file(&gtk4::gio::File::for_path(pathbuf.as_path())) {
-                Ok(t) => sender.send(Msg::Thumbnail(t)).unwrap(),
+            match Texture::from_file(&gtk4::gio::File::for_path(pathbuf.as_path())) {
+                Ok(t) => sender.send_blocking(Msg::Thumbnail(t)).unwrap(),
                 Err(e) => {
                     error!("Unable to load file to texture: {}", e);
                 }
diff --git a/src/ui/authentication.rs b/src/ui/authentication.rs
index 398eac4..b0363c8 100644
--- a/src/ui/authentication.rs
+++ b/src/ui/authentication.rs
@@ -23,11 +23,11 @@ impl EpicAssetManagerWindow {
                 .block_on(eg.auth_code(None, Some(s)))
             {
                 sender
-                    .send(crate::ui::messages::Msg::LoginOk(eg.user_details()))
+                    .send_blocking(crate::ui::messages::Msg::LoginOk(eg.user_details()))
                     .unwrap();
             } else {
                 sender
-                    .send(crate::ui::messages::Msg::LoginFailed(
+                    .send_blocking(crate::ui::messages::Msg::LoginFailed(
                         "Unable to authenticate with auth code".to_string(),
                     ))
                     .unwrap();
@@ -97,11 +97,11 @@ impl EpicAssetManagerWindow {
                 .block_on(eg.login())
             {
                 sender
-                    .send(crate::ui::messages::Msg::LoginOk(eg.user_details()))
+                    .send_blocking(crate::ui::messages::Msg::LoginOk(eg.user_details()))
                     .unwrap();
             } else {
                 sender
-                    .send(crate::ui::messages::Msg::LoginFailed(
+                    .send_blocking(crate::ui::messages::Msg::LoginFailed(
                         "Relogin request failed".to_string(),
                     ))
                     .unwrap();
@@ -125,7 +125,9 @@ impl EpicAssetManagerWindow {
                 .build()
                 .unwrap()
                 .block_on(eg.logout());
-            sender.send(crate::ui::messages::Msg::Logout).unwrap();
+            sender
+                .send_blocking(crate::ui::messages::Msg::Logout)
+                .unwrap();
         });
     }
 }
diff --git a/src/ui/widgets/download_manager/asset.rs b/src/ui/widgets/download_manager/asset.rs
index e631657..ed14e99 100644
--- a/src/ui/widgets/download_manager/asset.rs
+++ b/src/ui/widgets/download_manager/asset.rs
@@ -3,7 +3,6 @@ use crate::ui::widgets::download_manager::Msg::CancelChunk;
 use crate::ui::widgets::download_manager::{Msg, PostDownloadAction, ThreadMessages};
 use glib::clone;
 use gtk4::glib;
-use gtk4::glib::{Priority, Sender};
 use gtk4::subclass::prelude::*;
 use gtk4::{self, prelude::*};
 use log::{debug, error, info, warn};
@@ -46,7 +45,7 @@ pub trait Asset {
         &self,
         _release_id: String,
         _asset: egs_api::api::types::asset_info::AssetInfo,
-        _sender: Sender<(
+        _sender: async_channel::Sender<(
             String,
             Vec<egs_api::api::types::download_manifest::DownloadManifest>,
         )>,
@@ -207,17 +206,23 @@ impl Asset for super::EpicDownloadManager {
             }),
         );
 
-        let (sender, receiver) = glib::MainContext::channel(Priority::default());
+        let (sender, receiver) = async_channel::bounded::<(
+            String,
+            Vec<egs_api::api::types::download_manifest::DownloadManifest>,
+        )>(1);
 
-        receiver.attach(
-            None,
-            clone!(@weak self as download_manager => @default-panic, move |(id, manifest)| {
+        let download_manager = self.clone();
+        glib::spawn_future_local(async move {
+            while let Ok(response) = receiver.recv().await {
                 let self_ = download_manager.imp();
                 let sender = self_.sender.clone();
-                sender.send(super::Msg::StartAssetDownload(id, manifest)).unwrap();
-                glib::ControlFlow::Continue
-            }),
-        );
+                debug!("Got download manifest for {}", response.0);
+                sender
+                    .send(super::Msg::StartAssetDownload(response.0, response.1))
+                    .await
+                    .unwrap();
+            }
+        });
 
         self.download_asset_manifest(release_id, asset, sender);
     }
@@ -225,7 +230,7 @@ impl Asset for super::EpicDownloadManager {
         &self,
         release_id: String,
         asset: egs_api::api::types::asset_info::AssetInfo,
-        sender: Sender<(
+        sender: async_channel::Sender<(
             String,
             Vec<egs_api::api::types::download_manifest::DownloadManifest>,
         )>,
@@ -262,7 +267,7 @@ impl Asset for super::EpicDownloadManager {
                             .unwrap()
                             .block_on(eg.asset_download_manifests(manifest));
                         debug!("Got asset download manifests for {}", id);
-                        sender.send((id, d)).unwrap();
+                        sender.send_blocking((id, d)).unwrap();
                         // TODO cache download manifest
                     };
                 }
@@ -419,8 +424,9 @@ impl Asset for super::EpicDownloadManager {
                     let mut p = target.clone();
                     let g = chunk.guid.clone();
                     p.push(format!("{g}.chunk"));
+                    // TODO: Possible threading issue, move the send to thread
                     sender
-                        .send(Msg::RedownloadChunk(Url::parse("unix:/").unwrap(), p, g))
+                        .send_blocking(Msg::RedownloadChunk(Url::parse("unix:/").unwrap(), p, g))
                         .unwrap();
                 }
                 Some(files) => {
@@ -440,7 +446,7 @@ impl Asset for super::EpicDownloadManager {
             None => {
                 // Unable to get chunk urls
                 sender
-                    .send(Msg::PerformChunkDownload(link.clone(), p, g.to_string()))
+                    .send_blocking(Msg::PerformChunkDownload(link.clone(), p, g.to_string()))
                     .unwrap();
             }
             Some(v) => {
@@ -449,7 +455,7 @@ impl Asset for super::EpicDownloadManager {
                     // No other URL available, redownloading
                     //TODO: This has the potential to loop forever
                     sender
-                        .send(Msg::PerformChunkDownload(
+                        .send_blocking(Msg::PerformChunkDownload(
                             link.clone(),
                             p.clone(),
                             g.to_string(),
@@ -463,13 +469,17 @@ impl Asset for super::EpicDownloadManager {
                     None => {
                         // Unable to get random URL, retrying the same one
                         sender
-                            .send(Msg::PerformChunkDownload(link.clone(), p, g.to_string()))
+                            .send_blocking(Msg::PerformChunkDownload(
+                                link.clone(),
+                                p,
+                                g.to_string(),
+                            ))
                             .unwrap();
                     }
                     Some(u) => {
                         // Using new url to redownload the chunk
                         sender
-                            .send(Msg::PerformChunkDownload(u.clone(), p, g.to_string()))
+                            .send_blocking(Msg::PerformChunkDownload(u.clone(), p, g.to_string()))
                             .unwrap();
                     }
                 }
@@ -508,7 +518,7 @@ impl Asset for super::EpicDownloadManager {
                 Err(e) => {
                     error!("Failed to start chunk download, trying again later: {}", e);
                     sender
-                        .send(Msg::RedownloadChunk(link.clone(), p.clone(), g.clone()))
+                        .send_blocking(Msg::RedownloadChunk(link.clone(), p.clone(), g.clone()))
                         .unwrap();
                     return;
                 }
@@ -531,7 +541,11 @@ impl Asset for super::EpicDownloadManager {
                             downloaded += size as u128;
                             std::io::Write::write_all(&mut file, &buffer[0..size]).unwrap();
                             sender
-                                .send(Msg::ChunkDownloadProgress(g.clone(), size as u128, false))
+                                .send_blocking(Msg::ChunkDownloadProgress(
+                                    g.clone(),
+                                    size as u128,
+                                    false,
+                                ))
                                 .unwrap();
                         } else {
                             break;
@@ -544,7 +558,7 @@ impl Asset for super::EpicDownloadManager {
                 }
             }
             sender
-                .send(Msg::ChunkDownloadProgress(g.clone(), downloaded, true))
+                .send_blocking(Msg::ChunkDownloadProgress(g.clone(), downloaded, true))
                 .unwrap();
         });
     }
@@ -636,7 +650,10 @@ impl Asset for super::EpicDownloadManager {
 
         item.add_downloaded_size(progress);
         self.emit_by_name::<()>("tick", &[]);
-        self_.sender.send(Msg::FileExtracted(asset_id)).unwrap();
+        self_
+            .sender
+            .send_blocking(Msg::FileExtracted(asset_id))
+            .unwrap();
     }
 
     fn pause_asset_download(&self, asset: String) {
@@ -694,7 +711,7 @@ impl Asset for super::EpicDownloadManager {
                     for (url, path) in values {
                         self_
                             .sender
-                            .send(Msg::RedownloadChunk(
+                            .send_blocking(Msg::RedownloadChunk(
                                 url.clone(),
                                 path.clone(),
                                 guid.clone(),
@@ -737,7 +754,7 @@ impl Asset for super::EpicDownloadManager {
                             for (url, path) in values {
                                 self_
                                     .sender
-                                    .send(CancelChunk(url, path, guid.clone()))
+                                    .send_blocking(CancelChunk(url, path, guid.clone()))
                                     .unwrap();
                             }
                         }
@@ -748,16 +765,22 @@ impl Asset for super::EpicDownloadManager {
     }
 }
 
-fn process_thread_message(link: &Url, p: &Path, g: &str, sender: &Sender<Msg>, m: &ThreadMessages) {
+fn process_thread_message(
+    link: &Url,
+    p: &Path,
+    g: &str,
+    sender: &async_channel::Sender<Msg>,
+    m: &ThreadMessages,
+) {
     match m {
         ThreadMessages::Cancel => {
             sender
-                .send(CancelChunk(link.clone(), p.to_path_buf(), g.to_string()))
+                .send_blocking(CancelChunk(link.clone(), p.to_path_buf(), g.to_string()))
                 .unwrap();
         }
         ThreadMessages::Pause => {
             sender
-                .send(Msg::PauseChunk(
+                .send_blocking(Msg::PauseChunk(
                     link.clone(),
                     p.to_path_buf(),
                     g.to_string(),
@@ -822,7 +845,7 @@ fn initiate_file_download(
     r_id: &str,
     r_name: &str,
     f_name: &str,
-    sender: &Sender<Msg>,
+    sender: &async_channel::Sender<Msg>,
     m: egs_api::api::types::download_manifest::FileManifestList,
     full_path: &Path,
 ) {
@@ -853,7 +876,7 @@ fn initiate_file_download(
                 }))
             {
                 sender
-                    .send(Msg::FileAlreadyDownloaded(
+                    .send_blocking(Msg::FileAlreadyDownloaded(
                         r_id.to_string(),
                         m.size(),
                         full_path.to_str().unwrap().to_string(),
@@ -863,7 +886,7 @@ fn initiate_file_download(
             } else {
                 warn!("Hashes do not match, downloading again: {:?}", full_path);
                 sender
-                    .send(Msg::PerformAssetDownload(
+                    .send_blocking(Msg::PerformAssetDownload(
                         r_id.to_string(),
                         r_name.to_string(),
                         f_name.to_string(),
@@ -875,7 +898,7 @@ fn initiate_file_download(
         // File does not exist perform download
         Err(_) => {
             sender
-                .send(Msg::PerformAssetDownload(
+                .send_blocking(Msg::PerformAssetDownload(
                     r_id.to_string(),
                     r_name.to_string(),
                     f_name.to_string(),
@@ -913,7 +936,7 @@ impl AssetPriv for super::EpicDownloadManager {
                         cache_path.as_path(),
                     )) {
                         Ok(t) => sender
-                            .send(Msg::ProcessItemThumbnail(id.clone(), t))
+                            .send_blocking(Msg::ProcessItemThumbnail(id.clone(), t))
                             .unwrap(),
                         Err(e) => {
                             error!("Unable to load file to texture: {}", e);
@@ -1006,7 +1029,10 @@ impl AssetPriv for super::EpicDownloadManager {
                     {
                         copy_files(&vault.clone(), targets, &finished.name);
                         sender
-                            .send(Msg::FinalizeFileDownload(file_c.to_string(), f_c.clone()))
+                            .send_blocking(Msg::FinalizeFileDownload(
+                                file_c.to_string(),
+                                f_c.clone(),
+                            ))
                             .unwrap();
                     } else {
                         error!("Failed to validate hash on: {:?}", vault);
diff --git a/src/ui/widgets/download_manager/docker.rs b/src/ui/widgets/download_manager/docker.rs
index 3615197..d2f1e3b 100644
--- a/src/ui/widgets/download_manager/docker.rs
+++ b/src/ui/widgets/download_manager/docker.rs
@@ -3,7 +3,6 @@ use crate::ui::widgets::download_manager::{download_item, DownloadStatus, Msg, T
 use crate::ui::widgets::logged_in::refresh::Refresh;
 use glib::clone;
 use gtk4::glib;
-use gtk4::glib::Sender;
 use gtk4::subclass::prelude::*;
 use gtk4::{self, prelude::*};
 use log::{debug, error, warn};
@@ -133,17 +132,17 @@ impl Docker for crate::ui::widgets::download_manager::EpicDownloadManager {
                             Some(tx),
                             target.as_path(),
                         ) {
-                            Ok(_) => s.send(crate::ui::widgets::download_manager::Msg::DockerBlobFinished(v, d)).unwrap(),
+                            Ok(_) => s.send_blocking(crate::ui::widgets::download_manager::Msg::DockerBlobFinished(v, d)).unwrap(),
                             Err(e) => {
                                 match &e {
                                     ghregistry::errors::Error::IO(err) => {
                                         error!("Failed blob download because: {:?}", err);
-                                        s.send(crate::ui::widgets::download_manager::Msg::IOError(err.to_string())).unwrap();
+                                        s.send_blocking(crate::ui::widgets::download_manager::Msg::IOError(err.to_string())).unwrap();
                                     },
                                     ghregistry::errors::Error::Sender(_e) => {}
                                     _ => {
                                         error!("Failed blob download because: {:?}", e);
-                                        s.send(crate::ui::widgets::download_manager::Msg::DockerBlobFailed(v, (d, size))).unwrap();
+                                        s.send_blocking(crate::ui::widgets::download_manager::Msg::DockerBlobFailed(v, (d, size))).unwrap();
                                     }
                                 }
                             }
@@ -161,7 +160,7 @@ impl Docker for crate::ui::widgets::download_manager::EpicDownloadManager {
                             return;
                         }
                         sender
-                            .send(
+                            .send_blocking(
                                 crate::ui::widgets::download_manager::Msg::DockerDownloadProgress(
                                     ver.clone(),
                                     progress,
@@ -253,7 +252,7 @@ impl Docker for crate::ui::widgets::download_manager::EpicDownloadManager {
                         Ok(manifest) => match manifest.layers_digests(None) {
                             Ok(digests) => {
                                 sender
-                                    .send(crate::ui::widgets::download_manager::Msg::PerformDockerEngineDownload(
+                                    .send_blocking(crate::ui::widgets::download_manager::Msg::PerformDockerEngineDownload(
                                         v,
                                         manifest.download_size().unwrap_or(0),
                                         digests,
@@ -371,7 +370,7 @@ impl Docker for crate::ui::widgets::download_manager::EpicDownloadManager {
                             "home/ue4/UnrealEngine/",
                         ) {
                             Ok(_) => {
-                                sender.send(
+                                sender.send_blocking(
                                     crate::ui::widgets::download_manager::Msg::DockerExtractionFinished(
                                         v,
                                     ),
@@ -453,7 +452,7 @@ impl Docker for crate::ui::widgets::download_manager::EpicDownloadManager {
                     for digest in values {
                         self_
                             .sender
-                            .send(DockerCanceled(version.clone(), digest))
+                            .send_blocking(DockerCanceled(version.clone(), digest))
                             .unwrap();
                     }
                 }
@@ -477,7 +476,7 @@ impl Docker for crate::ui::widgets::download_manager::EpicDownloadManager {
             for digest in values {
                 self_
                     .sender
-                    .send(DockerBlobFailed(version.clone(), digest))
+                    .send_blocking(DockerBlobFailed(version.clone(), digest))
                     .unwrap();
             }
         }
@@ -488,15 +487,19 @@ impl Docker for crate::ui::widgets::download_manager::EpicDownloadManager {
 fn process_docker_thread_message(
     version: String,
     digest: (String, u64),
-    sender: &Sender<crate::ui::widgets::download_manager::Msg>,
+    sender: &async_channel::Sender<crate::ui::widgets::download_manager::Msg>,
     m: &crate::ui::widgets::download_manager::ThreadMessages,
 ) {
     match m {
         ThreadMessages::Cancel => {
-            sender.send(Msg::DockerCanceled(version, digest)).unwrap();
+            sender
+                .send_blocking(Msg::DockerCanceled(version, digest))
+                .unwrap();
         }
         ThreadMessages::Pause => {
-            sender.send(Msg::DockerPaused(version, digest)).unwrap();
+            sender
+                .send_blocking(Msg::DockerPaused(version, digest))
+                .unwrap();
         }
     }
 }
diff --git a/src/ui/widgets/download_manager/epic_file.rs b/src/ui/widgets/download_manager/epic_file.rs
index d68945f..59d1f79 100644
--- a/src/ui/widgets/download_manager/epic_file.rs
+++ b/src/ui/widgets/download_manager/epic_file.rs
@@ -3,8 +3,7 @@ use crate::ui::widgets::logged_in::engines::epic_download::Blob;
 use crate::ui::widgets::logged_in::refresh::Refresh;
 use glib::clone;
 use gtk4::glib;
-use gtk4::glib::{MainContext, ObjectExt};
-use gtk4::glib::{Priority, Sender};
+use gtk4::glib::ObjectExt;
 use gtk4::prelude::WidgetExt;
 use gtk4::subclass::prelude::ObjectSubclassIsExt;
 use gtk4::{self, prelude::*};
@@ -173,20 +172,27 @@ impl EpicFile for crate::ui::widgets::download_manager::EpicDownloadManager {
 
     fn start_version_file_download(&self, version: &str) {
         let self_ = self.imp();
-        let (sender, receiver) = MainContext::channel(Priority::default());
+        let (sender, receiver) = async_channel::bounded(1);
 
         let vers = version.to_string();
-        receiver.attach(
-            None,
-            clone!(@weak self as dm => @default-panic, move |v| {
+        let dm = self.clone();
+        glib::spawn_future_local(async move {
+            while let Ok(response) = receiver.recv().await {
                 let self_ = dm.imp();
                 let s = self_.sender.clone();
-                if let Some(ver) = filter_versions(v, &vers) {
-                    s.send(Msg::EpicDownloadStart(ver.name, ver.url, ver.size)).unwrap();
+                debug!(
+                    "start_version_file_download received response: {:?}",
+                    &response
+                );
+                if let Some(ver) = filter_versions(response, &vers) {
+                    s.send_blocking(Msg::EpicDownloadStart(ver.name, ver.url, ver.size))
+                        .unwrap();
                 }
-                glib::ControlFlow::Break
-            }),
-        );
+
+                // TODO: This used to break
+            }
+        });
+
         if let Some(window) = self_.window.get() {
             let win_ = window.imp();
             let logged_in = win_.logged_in_stack.imp();
@@ -322,7 +328,7 @@ impl EpicFile for crate::ui::widgets::download_manager::EpicDownloadManager {
 fn extract(
     target: &std::path::Path,
     mut archive: ZipArchive<File>,
-    sender: &Sender<Msg>,
+    sender: &async_channel::Sender<Msg>,
     ver: String,
     recv: &Receiver<ThreadMessages>,
 ) {
@@ -337,14 +343,18 @@ fn extract(
         let outpath = if let Some(path) = file.enclosed_name() {
             path.to_owned()
         } else {
-            sender.send(Msg::EpicFileExtracted(ver.clone())).unwrap();
+            sender
+                .send_blocking(Msg::EpicFileExtracted(ver.clone()))
+                .unwrap();
             continue;
         };
         file_target.push(&outpath);
         if file_target.exists() {
             let metadata = fs::metadata(file_target.as_path()).expect("unable to read metadata");
             if metadata.size() == file.size() {
-                sender.send(Msg::EpicFileExtracted(ver.clone())).unwrap();
+                sender
+                    .send_blocking(Msg::EpicFileExtracted(ver.clone()))
+                    .unwrap();
                 continue;
             }
         }
@@ -374,7 +384,10 @@ fn extract(
                         if size > 0 {
                             outfile.write_all(&buffer[0..size]).unwrap();
                             sender
-                                .send(Msg::EpicFileExtractionProgress(ver.clone(), size as u64))
+                                .send_blocking(Msg::EpicFileExtractionProgress(
+                                    ver.clone(),
+                                    size as u64,
+                                ))
                                 .unwrap();
                         } else {
                             break;
@@ -401,15 +414,17 @@ fn extract(
                 }
             }
         }
-        sender.send(Msg::EpicFileExtracted(ver.clone())).unwrap();
+        sender
+            .send_blocking(Msg::EpicFileExtracted(ver.clone()))
+            .unwrap();
     }
-    sender.send(Msg::EpicFileFinished(ver)).unwrap();
+    sender.send_blocking(Msg::EpicFileFinished(ver)).unwrap();
 }
 
 fn run(
     size: u64,
     recv: &Receiver<ThreadMessages>,
-    sender: &Sender<Msg>,
+    sender: &async_channel::Sender<Msg>,
     link: &Url,
     ver: String,
     p: &mut PathBuf,
@@ -435,9 +450,9 @@ fn run(
         if metadata.size() == size {
             debug!("Already downloaded {}", p.to_str().unwrap_or_default());
             sender
-                .send(Msg::EpicDownloadProgress(ver.clone(), size))
+                .send_blocking(Msg::EpicDownloadProgress(ver.clone(), size))
                 .unwrap();
-            sender.send(Msg::EpicFileFinished(ver)).unwrap();
+            sender.send_blocking(Msg::EpicFileFinished(ver)).unwrap();
             return;
         };
 
@@ -487,7 +502,7 @@ fn run(
                 if size > 0 {
                     file.write_all(&buffer[0..size]).unwrap();
                     sender
-                        .send(Msg::EpicDownloadProgress(ver.clone(), size as u64))
+                        .send_blocking(Msg::EpicDownloadProgress(ver.clone(), size as u64))
                         .unwrap();
                 } else {
                     break;
@@ -499,20 +514,24 @@ fn run(
             }
         }
     }
-    sender.send(Msg::EpicFileFinished(ver)).unwrap();
+    sender.send_blocking(Msg::EpicFileFinished(ver)).unwrap();
 }
 
 fn filter_versions(versions: Vec<Blob>, version: &str) -> Option<Blob> {
     versions.into_iter().find(|ver| ver.name.eq(version))
 }
 
-fn process_epic_thread_message(version: String, sender: &Sender<Msg>, m: &ThreadMessages) {
+fn process_epic_thread_message(
+    version: String,
+    sender: &async_channel::Sender<Msg>,
+    m: &ThreadMessages,
+) {
     match m {
         ThreadMessages::Cancel => {
-            sender.send(Msg::EpicCanceled(version)).unwrap();
+            sender.send_blocking(Msg::EpicCanceled(version)).unwrap();
         }
         ThreadMessages::Pause => {
-            sender.send(Msg::EpicPaused(version)).unwrap();
+            sender.send_blocking(Msg::EpicPaused(version)).unwrap();
         }
     }
 }
diff --git a/src/ui/widgets/download_manager/mod.rs b/src/ui/widgets/download_manager/mod.rs
index b74821c..fdeeafc 100644
--- a/src/ui/widgets/download_manager/mod.rs
+++ b/src/ui/widgets/download_manager/mod.rs
@@ -82,7 +82,7 @@ pub mod imp {
     use super::*;
     use crate::window::EpicAssetManagerWindow;
     use gtk4::gio;
-    use gtk4::glib::{ParamSpec, ParamSpecBoolean, Priority};
+    use gtk4::glib::{ParamSpec, ParamSpecBoolean};
     use once_cell::sync::OnceCell;
     use std::cell::RefCell;
     use std::collections::HashMap;
@@ -98,8 +98,8 @@ pub mod imp {
         pub thumbnail_pool: ThreadPool,
         pub image_pool: ThreadPool,
         pub file_pool: ThreadPool,
-        pub sender: gtk4::glib::Sender<super::Msg>,
-        pub receiver: RefCell<Option<gtk4::glib::Receiver<super::Msg>>>,
+        pub sender: async_channel::Sender<Msg>,
+        pub receiver: RefCell<Option<async_channel::Receiver<Msg>>>,
         pub download_items: RefCell<
             HashMap<String, crate::ui::widgets::download_manager::download_item::EpicDownloadItem>,
         >,
@@ -123,7 +123,7 @@ pub mod imp {
         type ParentType = gtk4::Box;
 
         fn new() -> Self {
-            let (sender, receiver) = gtk4::glib::MainContext::channel(Priority::default());
+            let (sender, receiver) = async_channel::bounded(1);
             Self {
                 actions: gio::SimpleActionGroup::new(),
                 settings: gio::Settings::new(crate::config::APP_ID),
@@ -251,11 +251,12 @@ impl EpicDownloadManager {
     pub fn setup_messaging(&self) {
         let self_ = self.imp();
         let receiver = self_.receiver.borrow_mut().take().unwrap();
-        receiver.attach(
-            None,
-            clone!(@weak self as download_manager => @default-panic, move |msg| {
-                download_manager.update(msg);
-                glib::ControlFlow::Continue
+        glib::spawn_future_local(
+            clone!(@weak self as download_manager => @default-panic, async move {
+                while let Ok(response) = receiver.recv().await {
+                    debug!("download_manager: {:?}", &response);
+                    download_manager.update(response);
+                }
             }),
         );
     }
@@ -431,7 +432,7 @@ impl EpicDownloadManager {
         }
         self_
             .sender
-            .send(Msg::FileExtracted(file_details.asset))
+            .send_blocking(Msg::FileExtracted(file_details.asset))
             .unwrap();
     }
 
@@ -453,7 +454,7 @@ impl EpicDownloadManager {
         &self,
         image: egs_api::api::types::asset_info::KeyImage,
         asset: egs_api::api::types::asset_info::AssetInfo,
-        sender: gtk4::glib::Sender<crate::ui::messages::Msg>,
+        sender: async_channel::Sender<crate::ui::messages::Msg>,
     ) {
         let self_ = self.imp();
         let cache_dir = self_.settings.string("cache-directory").to_string();
@@ -482,7 +483,7 @@ impl EpicDownloadManager {
                         }
                     }
                     sender
-                        .send(crate::ui::messages::Msg::ProcessAssetInfo(asset))
+                        .send_blocking(crate::ui::messages::Msg::ProcessAssetInfo(asset))
                         .unwrap();
                 }
             };
@@ -514,7 +515,7 @@ impl EpicDownloadManager {
         &self,
         image: egs_api::api::types::asset_info::KeyImage,
         asset: String,
-        sender: gtk4::glib::Sender<crate::ui::widgets::logged_in::library::image_stack::Msg>,
+        sender: async_channel::Sender<crate::ui::widgets::logged_in::library::image_stack::Msg>,
     ) {
         let self_ = self.imp();
         let cache_dir = self_.settings.string("cache-directory").to_string();
@@ -545,7 +546,7 @@ impl EpicDownloadManager {
                         }
                     }
                     sender
-                        .send(
+                        .send_blocking(
                             crate::ui::widgets::logged_in::library::image_stack::Msg::LoadImage(
                                 asset, img,
                             ),
diff --git a/src/ui/widgets/logged_in/engines/docker_download.rs b/src/ui/widgets/logged_in/engines/docker_download.rs
index 97a47e1..2290aa3 100644
--- a/src/ui/widgets/logged_in/engines/docker_download.rs
+++ b/src/ui/widgets/logged_in/engines/docker_download.rs
@@ -20,7 +20,7 @@ pub enum Msg {
 pub mod imp {
     use super::*;
     use crate::window::EpicAssetManagerWindow;
-    use gtk4::glib::{ParamSpec, ParamSpecString, Priority};
+    use gtk4::glib::{ParamSpec, ParamSpecString};
     use once_cell::sync::OnceCell;
     use std::cell::RefCell;
 
@@ -40,8 +40,8 @@ pub mod imp {
         pub download_manager: OnceCell<crate::ui::widgets::download_manager::EpicDownloadManager>,
         pub actions: gio::SimpleActionGroup,
         pub docker_versions: RefCell<Option<HashMap<String, Vec<String>>>>,
-        pub sender: gtk4::glib::Sender<super::Msg>,
-        pub receiver: RefCell<Option<gtk4::glib::Receiver<super::Msg>>>,
+        pub sender: async_channel::Sender<Msg>,
+        pub receiver: RefCell<Option<async_channel::Receiver<Msg>>>,
         pub settings: gio::Settings,
         selected: RefCell<Option<String>>,
         download_size: RefCell<Option<String>>,
@@ -54,7 +54,7 @@ pub mod imp {
         type ParentType = gtk4::Box;
 
         fn new() -> Self {
-            let (sender, receiver) = gtk4::glib::MainContext::channel(Priority::default());
+            let (sender, receiver) = async_channel::bounded(1);
             Self {
                 details: TemplateChild::default(),
                 details_revealer: TemplateChild::default(),
@@ -225,13 +225,13 @@ impl DockerEngineDownload {
     pub fn setup_messaging(&self) {
         let self_ = self.imp();
         let receiver = self_.receiver.borrow_mut().take().unwrap();
-        receiver.attach(
-            None,
-            clone!(@weak self as docker => @default-panic, move |msg| {
-                docker.update(msg);
-                glib::ControlFlow::Continue
-            }),
-        );
+        let docker = self.clone();
+        glib::spawn_future_local(async move {
+            while let Ok(response) = receiver.recv().await {
+                debug!("docker download message: {:?}", &response);
+                docker.update(response);
+            }
+        });
     }
 
     fn type_selected(&self, check: &gtk4::CheckButton, combo: &gtk4::ComboBoxText) {
@@ -298,12 +298,14 @@ impl DockerEngineDownload {
                                     Err(e) => {
                                         error!("Failed to get tags: {e:?}");
                                         sender
-                                            .send(Msg::Error(format!("Failed to get tags: {e:?}")))
+                                            .send_blocking(Msg::Error(format!(
+                                                "Failed to get tags: {e:?}"
+                                            )))
                                             .unwrap();
                                     }
                                 }
 
-                                sender.send(Msg::EngineVersions(result)).unwrap();
+                                sender.send_blocking(Msg::EngineVersions(result)).unwrap();
                             });
                         },
                     );
@@ -513,7 +515,7 @@ impl DockerEngineDownload {
                     match client.get_manifest("epicgames/unreal-engine", &version) {
                         Ok(manifest) => match manifest.download_size() {
                             Ok(size) => {
-                                sender.send(Msg::ManifestSize(size)).unwrap();
+                                sender.send_blocking(Msg::ManifestSize(size)).unwrap();
                             }
                             Err(e) => {
                                 error!("Unable to get manifest size: {:?}", e);
diff --git a/src/ui/widgets/logged_in/engines/epic_download.rs b/src/ui/widgets/logged_in/engines/epic_download.rs
index 53fba1e..23d2643 100644
--- a/src/ui/widgets/logged_in/engines/epic_download.rs
+++ b/src/ui/widgets/logged_in/engines/epic_download.rs
@@ -1,19 +1,20 @@
-use crate::gio::glib::Sender;
-use crate::tools::epic_web::EpicWeb;
-use crate::ui::widgets::download_manager::epic_file::EpicFile;
-use gtk4::glib::{clone, MainContext, Priority};
+use std::collections::HashMap;
+use std::thread;
+
+use gtk4::glib::clone;
 use gtk4::subclass::prelude::*;
 use gtk4::{self, gio, prelude::*};
 use gtk4::{glib, CompositeTemplate};
 use gtk_macros::{action, get_action};
-use log::error;
+use log::{debug, error};
 use regex::Regex;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::thread;
 use tokio::runtime::Builder;
 use version_compare::Cmp;
 
+use crate::tools::epic_web::EpicWeb;
+use crate::ui::widgets::download_manager::epic_file::EpicFile;
+
 #[derive(Debug, Clone)]
 pub enum Msg {
     EULAValid(bool),
@@ -36,13 +37,15 @@ pub struct Blob {
 }
 
 pub mod imp {
-    use super::*;
-    use crate::window::EpicAssetManagerWindow;
-    use gtk4::glib::Priority;
-    use once_cell::sync::OnceCell;
     use std::cell::RefCell;
     use std::collections::HashMap;
 
+    use once_cell::sync::OnceCell;
+
+    use crate::window::EpicAssetManagerWindow;
+
+    use super::*;
+
     #[derive(Debug, CompositeTemplate)]
     #[template(resource = "/io/github/achetagames/epic_asset_manager/epic_download.ui")]
     pub struct EpicEngineDownload {
@@ -68,8 +71,8 @@ pub mod imp {
         pub window: OnceCell<EpicAssetManagerWindow>,
         pub download_manager: OnceCell<crate::ui::widgets::download_manager::EpicDownloadManager>,
         pub actions: gio::SimpleActionGroup,
-        pub sender: gtk4::glib::Sender<super::Msg>,
-        pub receiver: RefCell<Option<gtk4::glib::Receiver<super::Msg>>>,
+        pub sender: async_channel::Sender<Msg>,
+        pub receiver: RefCell<Option<async_channel::Receiver<Msg>>>,
         pub engine_versions: RefCell<Option<HashMap<String, Blob>>>,
     }
 
@@ -80,7 +83,7 @@ pub mod imp {
         type ParentType = gtk4::Box;
 
         fn new() -> Self {
-            let (sender, receiver) = gtk4::glib::MainContext::channel(Priority::default());
+            let (sender, receiver) = async_channel::bounded(1);
             Self {
                 details: TemplateChild::default(),
                 details_revealer: TemplateChild::default(),
@@ -193,13 +196,13 @@ impl EpicEngineDownload {
     pub fn setup_messaging(&self) {
         let self_ = self.imp();
         let receiver = self_.receiver.borrow_mut().take().unwrap();
-        receiver.attach(
-            None,
-            clone!(@weak self as docker => @default-panic, move |msg| {
-                docker.update(msg);
-                glib::ControlFlow::Continue
-            }),
-        );
+        let epic = self.clone();
+        glib::spawn_future_local(async move {
+            while let Ok(response) = receiver.recv().await {
+                debug!("epic_download: {:?}", &response);
+                epic.update(response);
+            }
+        });
     }
 
     pub fn setup_widgets(&self) {
@@ -285,15 +288,18 @@ impl EpicEngineDownload {
         if let Some(window) = self_.window.get() {
             let win_ = window.imp();
             let mut eg = win_.model.borrow().epic_games.borrow().clone();
-            let (sender, receiver) = gtk4::glib::MainContext::channel(Priority::default());
-
-            receiver.attach(
-                None,
-                clone!(@weak self as sidebar => @default-panic, move |code: String| {
-                    open_browser(&code, "https%3A%2F%2Fwww.unrealengine.com%2Feulacheck%2Funreal");
-                    glib::ControlFlow::Break
-                }),
-            );
+            let (sender, receiver) = async_channel::bounded::<String>(1);
+
+            glib::spawn_future_local(async move {
+                while let Ok(response) = receiver.recv().await {
+                    debug!("Opening browser with code: {response}");
+                    open_browser(
+                        &response,
+                        "https%3A%2F%2Fwww.unrealengine.com%2Feulacheck%2Funreal",
+                    );
+                    // TODO: This used to break
+                }
+            });
 
             thread::spawn(move || {
                 if let Some(token) = Builder::new_current_thread()
@@ -302,7 +308,7 @@ impl EpicEngineDownload {
                     .unwrap()
                     .block_on(eg.game_token())
                 {
-                    sender.send(token.code).unwrap();
+                    sender.send_blocking(token.code).unwrap();
                 }
             });
         }
@@ -313,15 +319,14 @@ impl EpicEngineDownload {
         if let Some(window) = self_.window.get() {
             let win_ = window.imp();
             let mut eg = win_.model.borrow().epic_games.borrow().clone();
-            let (sender, receiver) = gtk4::glib::MainContext::channel(Priority::default());
+            let (sender, receiver) = async_channel::bounded::<String>(1);
 
-            receiver.attach(
-                None,
-                clone!(@weak self as sidebar => @default-panic, move |code: String| {
-                    open_browser(&code, "https%3A%2F%2Fwww.unrealengine.com%2Flinux");
-                    glib::ControlFlow::Break
-                }),
-            );
+            glib::spawn_future_local(async move {
+                while let Ok(response) = receiver.recv().await {
+                    debug!("Opening browser with code: {response}");
+                    open_browser(&response, "https%3A%2F%2Fwww.unrealengine.com%2Flinux");
+                }
+            });
 
             thread::spawn(move || {
                 if let Some(token) = Builder::new_current_thread()
@@ -330,7 +335,7 @@ impl EpicEngineDownload {
                     .unwrap()
                     .block_on(eg.game_token())
                 {
-                    sender.send(token.code).unwrap();
+                    sender.send_blocking(token.code).unwrap();
                 }
             });
         }
@@ -344,17 +349,19 @@ impl EpicEngineDownload {
                     self_.size_row.set_visible(true);
                     self_.versions_row.set_visible(true);
                     self_.eula_stack.set_visible_child_name("valid");
-                    let (sender, receiver) = MainContext::channel(Priority::default());
+                    let (sender, receiver) = async_channel::bounded(1);
 
-                    receiver.attach(
-                        None,
-                        clone!(@weak self as ed => @default-panic, move |v| {
+                    let ed = self.clone();
+                    glib::spawn_future_local(async move {
+                        while let Ok(response) = receiver.recv().await {
                             let self_ = ed.imp();
                             let s = self_.sender.clone();
-                            s.send(Msg::Versions(v)).unwrap();
-                            glib::ControlFlow::Break
-                        }),
-                    );
+                            debug!("Sending versions to download manager");
+                            s.send_blocking(Msg::Versions(response)).unwrap();
+                            // TODO: This used to break
+                        }
+                    });
+
                     self.get_versions(sender);
                 } else {
                     self_.eula_stack.set_visible_child_name("invalid");
@@ -415,7 +422,7 @@ impl EpicEngineDownload {
             let mut eg = win_.model.borrow().epic_games.borrow().clone();
             let sender = self_.sender.clone();
             let Some(id) = eg.user_details().account_id else {
-                sender.send(Msg::EULAValid(false)).unwrap();
+                sender.send_blocking(Msg::EULAValid(false)).unwrap();
                 return;
             };
             thread::spawn(move || {
@@ -427,13 +434,15 @@ impl EpicEngineDownload {
                 {
                     let mut web = EpicWeb::new();
                     web.start_session(token.code);
-                    sender.send(Msg::EULAValid(web.validate_eula(&id))).unwrap();
+                    sender
+                        .send_blocking(Msg::EULAValid(web.validate_eula(&id)))
+                        .unwrap();
                 };
             });
         }
     }
 
-    pub fn get_versions(&self, sender: Sender<Vec<Blob>>) {
+    pub fn get_versions(&self, sender: async_channel::Sender<Vec<Blob>>) {
         let self_ = self.imp();
         if let Some(window) = self_.window.get() {
             let win_ = window.imp();
@@ -450,7 +459,7 @@ impl EpicEngineDownload {
                     if let Ok(versions) = web.run_query::<VersionResponse>(
                         "https://www.unrealengine.com/api/blobs/linux".to_string(),
                     ) {
-                        sender.send(versions.blobs).unwrap();
+                        sender.send_blocking(versions.blobs).unwrap();
                     };
                 }
             });
diff --git a/src/ui/widgets/logged_in/engines/mod.rs b/src/ui/widgets/logged_in/engines/mod.rs
index 6ee94c7..543fa24 100644
--- a/src/ui/widgets/logged_in/engines/mod.rs
+++ b/src/ui/widgets/logged_in/engines/mod.rs
@@ -1,17 +1,20 @@
-use crate::ui::widgets::logged_in::refresh::Refresh;
+use std::collections::HashMap;
+use std::ffi::OsString;
+use std::path::PathBuf;
+use std::str::FromStr;
+
 use adw::gtk;
-use engine::EpicEngine;
 use gtk4::glib::clone;
 use gtk4::subclass::prelude::*;
 use gtk4::{self, gio, prelude::*};
 use gtk4::{glib, CompositeTemplate};
 use log::{debug, error, warn};
-use std::collections::HashMap;
-use std::ffi::OsString;
-use std::path::PathBuf;
-use std::str::FromStr;
 use version_compare::Cmp;
 
+use engine::EpicEngine;
+
+use crate::ui::widgets::logged_in::refresh::Refresh;
+
 mod docker_download;
 pub mod engine;
 pub mod engine_detail;
@@ -19,6 +22,7 @@ mod engines_side;
 pub mod epic_download;
 mod install;
 
+#[derive(Debug, Clone)]
 pub enum Msg {
     AddEngine {
         guid: String,
@@ -63,7 +67,7 @@ impl UnrealEngine {
 pub mod imp {
     use std::cell::RefCell;
 
-    use gtk4::glib::{ParamSpec, ParamSpecBoolean, ParamSpecString, Priority};
+    use gtk4::glib::{ParamSpec, ParamSpecBoolean, ParamSpecString};
     use once_cell::sync::OnceCell;
     use threadpool::ThreadPool;
 
@@ -86,8 +90,8 @@ pub mod imp {
         pub actions: gtk4::gio::SimpleActionGroup,
         pub engines: RefCell<HashMap<String, super::UnrealEngine>>,
         pub settings: gio::Settings,
-        pub sender: gtk4::glib::Sender<super::Msg>,
-        pub receiver: RefCell<Option<gtk4::glib::Receiver<super::Msg>>>,
+        pub sender: async_channel::Sender<Msg>,
+        pub receiver: RefCell<Option<async_channel::Receiver<Msg>>>,
     }
 
     #[glib::object_subclass]
@@ -97,7 +101,7 @@ pub mod imp {
         type ParentType = gtk4::Box;
 
         fn new() -> Self {
-            let (sender, receiver) = gtk4::glib::MainContext::channel(Priority::default());
+            let (sender, receiver) = async_channel::bounded(1);
             Self {
                 window: OnceCell::new(),
                 download_manager: OnceCell::new(),
@@ -190,13 +194,14 @@ impl EpicEnginesBox {
     pub fn setup_messaging(&self) {
         let self_ = self.imp();
         let receiver = self_.receiver.borrow_mut().take().unwrap();
-        receiver.attach(
-            None,
-            clone!(@weak self as engines => @default-panic, move |msg| {
-                engines.update(msg);
-                glib::ControlFlow::Continue
-            }),
-        );
+
+        let engines = self.clone();
+        glib::spawn_future_local(async move {
+            while let Ok(response) = receiver.recv().await {
+                debug!("engine Got message: {:?}", &response);
+                engines.update(response);
+            }
+        });
     }
 
     fn update(&self, msg: Msg) {
@@ -449,7 +454,7 @@ impl EpicEnginesBox {
                 if let Some(version) =
                     crate::models::engine_data::EngineData::read_engine_version(&path)
                 {
-                    s.send(Msg::AddEngine {
+                    s.send_blocking(Msg::AddEngine {
                         guid,
                         path,
                         version,
@@ -483,7 +488,7 @@ impl EpicEnginesBox {
                                             p.to_str().unwrap(),
                                         )
                                     {
-                                        s.send(Msg::AddEngine {
+                                        s.send_blocking(Msg::AddEngine {
                                             guid: p.to_str().unwrap().to_string(),
                                             path: p.to_str().unwrap().to_string(),
                                             version,
@@ -495,7 +500,7 @@ impl EpicEnginesBox {
                         }
                     }
                     Some(version) => {
-                        s.send(Msg::AddEngine {
+                        s.send_blocking(Msg::AddEngine {
                             guid: dir.to_string(),
                             path: dir.to_string(),
                             version,
diff --git a/src/ui/widgets/logged_in/library/actions/mod.rs b/src/ui/widgets/logged_in/library/actions/mod.rs
index 193c77a..c016009 100644
--- a/src/ui/widgets/logged_in/library/actions/mod.rs
+++ b/src/ui/widgets/logged_in/library/actions/mod.rs
@@ -9,11 +9,12 @@ use crate::tools::or::Or;
 use crate::ui::widgets::download_manager::asset::Asset;
 use adw::prelude::ExpanderRowExt;
 use egs_api::api::types::asset_info::AssetInfo;
-use gtk4::glib::{clone, Priority};
+use gtk4::glib::clone;
 use gtk4::subclass::prelude::*;
 use gtk4::{self, gio, prelude::*, SizeGroupMode};
 use gtk4::{glib, CompositeTemplate};
 use gtk_macros::action;
+use log::debug;
 
 pub enum Action {
     Local,
@@ -516,18 +517,18 @@ impl EpicAssetActions {
                             self.add_detail("Release Note", &gtk4::Label::new(Some(note)));
                         }
                     }
-                    let (sender, receiver) = glib::MainContext::channel::<(
+                    let (sender, receiver) = async_channel::bounded::<(
                         String,
                         Vec<egs_api::api::types::download_manifest::DownloadManifest>,
-                    )>(Priority::default());
-
-                    receiver.attach(
-                        None,
-                        clone!(@weak self as asset_actions => @default-panic, move |(id, manifest)| {
-                            asset_actions.process_download_manifest(&id, manifest);
-                            glib::ControlFlow::Continue
-                        }),
-                    );
+                    )>(1);
+
+                    let asset_actions = self.clone();
+                    glib::spawn_future_local(async move {
+                        while let Ok(response) = receiver.recv().await {
+                            debug!("download_manifest: {:?}", &response);
+                            asset_actions.process_download_manifest(&response.0, response.1);
+                        }
+                    });
 
                     if let Some(dm) = self_.download_manager.get() {
                         dm.download_asset_manifest(id.to_string(), asset_info.clone(), sender);
diff --git a/src/ui/widgets/logged_in/library/image_stack.rs b/src/ui/widgets/logged_in/library/image_stack.rs
index c8fba0a..dccffec 100644
--- a/src/ui/widgets/logged_in/library/image_stack.rs
+++ b/src/ui/widgets/logged_in/library/image_stack.rs
@@ -1,24 +1,27 @@
+use std::cmp::Ordering;
+use std::ffi::OsStr;
+use std::path::Path;
+use std::path::PathBuf;
+
 use adw::gdk::Texture;
-use gtk4::glib::{clone, MainContext, Receiver, Sender};
+use gtk4::glib::clone;
 use gtk4::subclass::prelude::*;
 use gtk4::{self, gio, prelude::*};
 use gtk4::{glib, CompositeTemplate};
 use gtk_macros::{action, get_action};
 use log::{debug, error};
-use std::cmp::Ordering;
-use std::ffi::OsStr;
-use std::path::Path;
-use std::path::PathBuf;
 
 pub mod imp {
-    use super::*;
-    use crate::ui::widgets::download_manager::EpicDownloadManager;
+    use std::cell::RefCell;
+
     use gtk4::gio;
-    use gtk4::glib::Priority;
     use once_cell::sync::OnceCell;
-    use std::cell::RefCell;
     use threadpool::ThreadPool;
 
+    use crate::ui::widgets::download_manager::EpicDownloadManager;
+
+    use super::*;
+
     #[derive(Debug, CompositeTemplate)]
     #[template(resource = "/io/github/achetagames/epic_asset_manager/image_stack.ui")]
     pub struct EpicImageOverlay {
@@ -30,8 +33,8 @@ pub mod imp {
         pub settings: gio::Settings,
         pub actions: gio::SimpleActionGroup,
         pub download_manager: OnceCell<EpicDownloadManager>,
-        pub sender: Sender<super::Msg>,
-        pub receiver: RefCell<Option<Receiver<super::Msg>>>,
+        pub sender: async_channel::Sender<super::Msg>,
+        pub receiver: RefCell<Option<async_channel::Receiver<super::Msg>>>,
         asset: RefCell<Option<String>>,
     }
 
@@ -42,7 +45,7 @@ pub mod imp {
         type ParentType = gtk4::Box;
 
         fn new() -> Self {
-            let (sender, receiver) = MainContext::channel(Priority::default());
+            let (sender, receiver) = async_channel::bounded(1);
             Self {
                 image_load_pool: ThreadPool::with_name("Image Load Pool".to_string(), 5),
                 stack: TemplateChild::default(),
@@ -153,13 +156,14 @@ impl EpicImageOverlay {
 
     pub fn setup_receiver(&self) {
         let self_ = self.imp();
-        self_.receiver.borrow_mut().take().unwrap().attach(
-            None,
-            clone!(@weak self as img => @default-panic, move |msg| {
-                img.update(msg);
-                glib::ControlFlow::Continue
-            }),
-        );
+        let receiver = self_.receiver.borrow_mut().take().unwrap();
+        let img = self.clone();
+        glib::spawn_future_local(async move {
+            while let Ok(response) = receiver.recv().await {
+                debug!("image_stack: {:?}", &response);
+                img.update(response);
+            }
+        });
     }
 
     pub fn update(&self, msg: Msg) {
@@ -281,14 +285,16 @@ impl EpicImageOverlay {
         self_.image_load_pool.execute(move || {
             if cache_path.as_path().exists() {
                 match Texture::from_file(&gio::File::for_path(cache_path.as_path())) {
-                    Ok(t) => sender.send(Msg::ImageLoaded(t)).unwrap(),
+                    Ok(t) => sender.send_blocking(Msg::ImageLoaded(t)).unwrap(),
                     Err(e) => {
                         error!("Unable to load file to texture: {}", e);
                     }
                 };
             } else {
                 debug!("Need to download image");
-                sender.send(Msg::DownloadImage(asset, img.clone())).unwrap();
+                sender
+                    .send_blocking(Msg::DownloadImage(asset, img.clone()))
+                    .unwrap();
             };
         });
     }
diff --git a/src/ui/widgets/logged_in/library/mod.rs b/src/ui/widgets/logged_in/library/mod.rs
index 29a16d7..1936455 100644
--- a/src/ui/widgets/logged_in/library/mod.rs
+++ b/src/ui/widgets/logged_in/library/mod.rs
@@ -622,7 +622,7 @@ impl EpicLibraryBox {
             let win_ = window.imp();
             let sender = win_.model.borrow().sender.clone();
             sender
-                .send(crate::ui::messages::Msg::EndAssetProcessing)
+                .send_blocking(crate::ui::messages::Msg::EndAssetProcessing)
                 .unwrap();
             let mut assets = self_.loaded_assets.borrow_mut();
             let mut asset_products = self_.asset_product_names.borrow_mut();
@@ -697,7 +697,7 @@ impl EpicLibraryBox {
             match asset.thumbnail() {
                 None => {
                     sender
-                        .send(crate::ui::messages::Msg::ProcessAssetThumbnail(
+                        .send_blocking(crate::ui::messages::Msg::ProcessAssetThumbnail(
                             asset.clone(),
                             None,
                         ))
@@ -721,7 +721,7 @@ impl EpicLibraryBox {
                                 cache_path.as_path(),
                             )) {
                                 Ok(t) => sender
-                                    .send(crate::ui::messages::Msg::ProcessAssetThumbnail(
+                                    .send_blocking(crate::ui::messages::Msg::ProcessAssetThumbnail(
                                         asset.clone(),
                                         Some(t),
                                     ))
@@ -735,7 +735,10 @@ impl EpicLibraryBox {
                             };
                         } else {
                             sender
-                                .send(crate::ui::messages::Msg::DownloadImage(t, asset.clone()))
+                                .send_blocking(crate::ui::messages::Msg::DownloadImage(
+                                    t,
+                                    asset.clone(),
+                                ))
                                 .unwrap();
                         }
                     });
@@ -782,12 +785,14 @@ impl EpicLibraryBox {
 
                             if asset_file.exists() {
                                 sender
-                                    .send(crate::ui::messages::Msg::StartAssetProcessing)
+                                    .send_blocking(crate::ui::messages::Msg::StartAssetProcessing)
                                     .unwrap();
                                 if let Ok(f) = std::fs::File::open(asset_file.as_path()) {
                                     if let Ok(asset) = serde_json::from_reader(f) {
                                         sender
-                                            .send(crate::ui::messages::Msg::ProcessAssetInfo(asset))
+                                            .send_blocking(
+                                                crate::ui::messages::Msg::ProcessAssetInfo(asset),
+                                            )
                                             .unwrap();
                                     }
                                 };
@@ -825,10 +830,10 @@ impl EpicLibraryBox {
                 });
                 for asset in assets {
                     sender
-                        .send(crate::ui::messages::Msg::StartAssetProcessing)
+                        .send_blocking(crate::ui::messages::Msg::StartAssetProcessing)
                         .unwrap();
                     sender
-                        .send(crate::ui::messages::Msg::ProcessEpicAsset(asset))
+                        .send_blocking(crate::ui::messages::Msg::ProcessEpicAsset(asset))
                         .unwrap();
                 }
             });
@@ -895,7 +900,7 @@ impl EpicLibraryBox {
                             .unwrap();
                     }
                     sender
-                        .send(crate::ui::messages::Msg::ProcessAssetInfo(asset))
+                        .send_blocking(crate::ui::messages::Msg::ProcessAssetInfo(asset))
                         .unwrap();
                 }
             });
diff --git a/src/ui/widgets/logged_in/library/sidebar/mod.rs b/src/ui/widgets/logged_in/library/sidebar/mod.rs
index 455ef15..a629837 100644
--- a/src/ui/widgets/logged_in/library/sidebar/mod.rs
+++ b/src/ui/widgets/logged_in/library/sidebar/mod.rs
@@ -1,24 +1,29 @@
-use crate::ui::widgets::logged_in::library::sidebar::categories::EpicSidebarCategories;
-use gtk4::glib::{clone, Priority};
+use std::thread;
+
+use gtk4::glib::clone;
 use gtk4::subclass::prelude::*;
 use gtk4::{self, gio, prelude::*};
 use gtk4::{glib, CompositeTemplate};
 use gtk_macros::action;
-use log::{error, warn};
-use std::thread;
+use log::{debug, error, warn};
 use tokio::runtime::Builder;
 
+use crate::ui::widgets::logged_in::library::sidebar::categories::EpicSidebarCategories;
+
 pub mod button;
 pub mod categories;
 mod category;
 
 pub mod imp {
-    use super::*;
-    use crate::ui::widgets::download_manager::EpicDownloadManager;
-    use crate::window::EpicAssetManagerWindow;
+    use std::cell::RefCell;
+
     use gtk4::glib::{ParamSpec, ParamSpecBoolean};
     use once_cell::sync::OnceCell;
-    use std::cell::RefCell;
+
+    use crate::ui::widgets::download_manager::EpicDownloadManager;
+    use crate::window::EpicAssetManagerWindow;
+
+    use super::*;
 
     #[derive(Debug, CompositeTemplate)]
     #[template(resource = "/io/github/achetagames/epic_asset_manager/sidebar.ui")]
@@ -197,15 +202,15 @@ impl EpicSidebar {
         if let Some(window) = self_.window.get() {
             let win_ = window.imp();
             let mut eg = win_.model.borrow().epic_games.borrow().clone();
-            let (sender, receiver) = gtk4::glib::MainContext::channel(Priority::default());
+            let (sender, receiver) = async_channel::bounded::<String>(1);
 
-            receiver.attach(
-                None,
-                clone!(@weak self as sidebar => @default-panic, move |code:String| {
-                    open_browser(&code);
-                    glib::ControlFlow::Break
-                }),
-            );
+            glib::spawn_future_local(async move {
+                while let Ok(response) = receiver.recv().await {
+                    open_browser(&response);
+                    // TODO: This used to break
+                    debug!("Marketplace opened");
+                }
+            });
 
             thread::spawn(move || {
                 match Builder::new_current_thread()
@@ -216,7 +221,7 @@ impl EpicSidebar {
                 {
                     None => {}
                     Some(token) => {
-                        sender.send(token.code).unwrap();
+                        sender.send_blocking(token.code).unwrap();
                     }
                 }
             });
diff --git a/src/ui/widgets/logged_in/logs.rs b/src/ui/widgets/logged_in/logs.rs
index 756059e..286beac 100644
--- a/src/ui/widgets/logged_in/logs.rs
+++ b/src/ui/widgets/logged_in/logs.rs
@@ -1,5 +1,6 @@
 use gtk4::glib::clone;
 use gtk4::{self, glib, prelude::*, subclass::prelude::*, CompositeTemplate, CustomSorter};
+use log::debug;
 use std::cmp::Ordering;
 use std::path::Path;
 use std::{iter::Peekable, str::Chars};
@@ -114,7 +115,7 @@ impl EpicLogs {
         let logs = self.clone();
         glib::spawn_future_local(async move {
             while let Ok(response) = receiver.recv().await {
-                log::info!("Got log");
+                debug!("logs: {:?}", &response);
                 logs.update(response);
             }
         });
@@ -315,12 +316,9 @@ impl EpicLogs {
                         }
                     };
                     let metadata = std::fs::metadata(p.as_path()).expect("unable to read metadata");
-                    log::info!("Found logs in: {}", p.to_str().unwrap_or_default());
 
-                    crate::runtime().spawn(clone!(@strong sender => async move {
-                        log::info!("Sending message");
-                        sender
-                        .send(Msg::AddLog(
+                    sender
+                        .send_blocking(Msg::AddLog(
                             p.to_str().unwrap_or_default().to_string(),
                             metadata.modified().map_or_else(
                                 |_| p.to_str().unwrap_or_default().to_string(),
@@ -331,9 +329,7 @@ impl EpicLogs {
                             ),
                             crash,
                         ))
-                        .await
                         .unwrap();
-                    }));
                 }
             }
         }
diff --git a/src/ui/widgets/logged_in/plugins.rs b/src/ui/widgets/logged_in/plugins.rs
index 7e87eb8..96517cf 100644
--- a/src/ui/widgets/logged_in/plugins.rs
+++ b/src/ui/widgets/logged_in/plugins.rs
@@ -6,20 +6,22 @@ pub enum Msg {
 }
 
 pub mod imp {
-    use super::*;
+    use std::cell::RefCell;
+
     use gtk4::gio::ListStore;
-    use gtk4::glib::{Object, Priority};
+    use gtk4::glib::Object;
     use once_cell::sync::OnceCell;
-    use std::cell::RefCell;
     use threadpool::ThreadPool;
 
+    use super::*;
+
     #[derive(Debug, CompositeTemplate)]
     #[template(resource = "/io/github/achetagames/epic_asset_manager/plugins.ui")]
     pub struct EpicPlugins {
         pub window: OnceCell<crate::window::EpicAssetManagerWindow>,
         pub model: ListStore,
-        pub sender: gtk4::glib::Sender<super::Msg>,
-        pub receiver: RefCell<Option<gtk4::glib::Receiver<super::Msg>>>,
+        pub sender: async_channel::Sender<Msg>,
+        pub receiver: RefCell<Option<async_channel::Receiver<Msg>>>,
         pub pending: std::sync::RwLock<Vec<Object>>,
         pub load_pool: ThreadPool,
     }
@@ -31,7 +33,7 @@ pub mod imp {
         type ParentType = gtk4::Box;
 
         fn new() -> Self {
-            let (sender, receiver) = gtk4::glib::MainContext::channel(Priority::default());
+            let (sender, receiver) = async_channel::bounded(1);
             Self {
                 window: OnceCell::new(),
                 model: gtk4::gio::ListStore::new::<crate::models::log_data::LogData>(),
diff --git a/src/ui/widgets/logged_in/projects/mod.rs b/src/ui/widgets/logged_in/projects/mod.rs
index d743e7f..24979f4 100644
--- a/src/ui/widgets/logged_in/projects/mod.rs
+++ b/src/ui/widgets/logged_in/projects/mod.rs
@@ -1,26 +1,32 @@
-use crate::ui::widgets::logged_in::refresh::Refresh;
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
+
 use adw::gtk;
 use gtk4::{self, glib, glib::clone, prelude::*, subclass::prelude::*, CompositeTemplate};
 use log::{debug, info};
+
 use project::EpicProject;
-use std::path::{Path, PathBuf};
-use std::str::FromStr;
+
+use crate::ui::widgets::logged_in::refresh::Refresh;
 
 mod project;
 mod project_detail;
 
+#[derive(Debug, Clone)]
 pub enum Msg {
     AddProject { uproject_file: PathBuf },
 }
 
 pub mod imp {
-    use super::*;
-    use gtk4::glib::{ParamSpec, ParamSpecBoolean, ParamSpecString, Priority};
-    use once_cell::sync::OnceCell;
     use std::cell::RefCell;
     use std::collections::BTreeMap;
+
+    use gtk4::glib::{ParamSpec, ParamSpecBoolean, ParamSpecString};
+    use once_cell::sync::OnceCell;
     use threadpool::ThreadPool;
 
+    use super::*;
+
     #[derive(Debug, CompositeTemplate)]
     #[template(resource = "/io/github/achetagames/epic_asset_manager/projects.ui")]
     pub struct EpicProjectsBox {
@@ -39,8 +45,8 @@ pub mod imp {
         selected: RefCell<Option<String>>,
         pub selected_uproject: RefCell<Option<crate::models::project_data::Uproject>>,
         pub actions: gtk4::gio::SimpleActionGroup,
-        pub sender: gtk4::glib::Sender<super::Msg>,
-        pub receiver: RefCell<Option<gtk4::glib::Receiver<super::Msg>>>,
+        pub sender: async_channel::Sender<Msg>,
+        pub receiver: RefCell<Option<async_channel::Receiver<Msg>>>,
         pub file_pool: ThreadPool,
     }
 
@@ -51,7 +57,7 @@ pub mod imp {
         type ParentType = gtk4::Box;
 
         fn new() -> Self {
-            let (sender, receiver) = gtk4::glib::MainContext::channel(Priority::default());
+            let (sender, receiver) = async_channel::bounded(1);
             Self {
                 window: OnceCell::new(),
                 download_manager: OnceCell::new(),
@@ -145,13 +151,13 @@ impl EpicProjectsBox {
     pub fn setup_messaging(&self) {
         let self_ = self.imp();
         let receiver = self_.receiver.borrow_mut().take().unwrap();
-        receiver.attach(
-            None,
-            clone!(@weak self as projects => @default-panic, move |msg| {
-                projects.update(msg);
-                glib::ControlFlow::Continue
-            }),
-        );
+        let projects = self.clone();
+        glib::spawn_future_local(async move {
+            while let Ok(response) = receiver.recv().await {
+                debug!("projects Received message: {:?}", &response);
+                projects.update(response);
+            }
+        });
     }
 
     fn update(&self, msg: Msg) {
@@ -342,7 +348,7 @@ impl EpicProjectsBox {
         self.refresh_state_changed();
     }
 
-    fn check_path_for_uproject(path: &Path, sender: &gtk4::glib::Sender<Msg>) {
+    fn check_path_for_uproject(path: &Path, sender: &async_channel::Sender<Msg>) {
         if let Ok(rd) = path.read_dir() {
             for d in rd {
                 match d {
@@ -354,7 +360,9 @@ impl EpicProjectsBox {
                                     Self::check_path_for_uproject(&p, &sender.clone());
                                 },
                                 |uproject_file| {
-                                    sender.send(Msg::AddProject { uproject_file }).unwrap();
+                                    sender
+                                        .send_blocking(Msg::AddProject { uproject_file })
+                                        .unwrap();
                                 },
                             );
                         } else {
diff --git a/src/window.rs b/src/window.rs
index dce260e..5edb54f 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -235,21 +235,21 @@ impl EpicAssetManagerWindow {
 
     pub fn setup_receiver(&self) {
         let self_ = self.imp();
-        self_
+        let receiver = self_
             .model
             .borrow()
             .deref()
             .receiver
             .borrow_mut()
             .take()
-            .unwrap()
-            .attach(
-                None,
-                clone!(@weak self as window => @default-panic, move |msg| {
-                    window.update(msg);
-                    glib::ControlFlow::Continue
-                }),
-            );
+            .unwrap();
+        let window = self.clone();
+        glib::spawn_future_local(async move {
+            while let Ok(response) = receiver.recv().await {
+                debug!("window received {:?}", &response);
+                window.update(response);
+            }
+        });
     }
 
     pub fn setup_actions(&self) {