13 files changed, 905 insertions, 552 deletions
diff --git a/src/apis/modrinth.rs b/src/apis/modrinth.rs
index 525cc0d..9a22633 100644
--- a/src/apis/modrinth.rs
+++ b/src/apis/modrinth.rs
@@ -127,10 +127,13 @@ pub enum GameVersionType {
    release,
    snapshot,
    alpha,
-    beta
+    beta,
 }
-async fn get(api: &str, path: &str) -> Result<Option<Vec<u8>>, Box<dyn std::error::Error>> {
+async fn get(
+    api: &str,
+    path: &str,
+) -> Result<Option<Vec<u8>>, Box<dyn std::error::Error>> {
    let url = format!(r#"{}{}"#, api, path);
    let client = Client::builder()
@@ -170,7 +173,7 @@ pub async fn projects(api: &str, ids: Vec<String>) -> Vec<Project> {
 pub async fn versions(api: &str, id: String, list: List) -> Vec<Version> {
    let url = format!(
        r#"project/{}/version?loaders=["{}"]&game_versions=["{}"]"#,
-        id, list.modloader.to_string(), list.mc_version
+        id, list.modloader, list.mc_version
    );
    let data = get(api, &url).await.unwrap();
@@ -182,7 +185,10 @@ pub async fn versions(api: &str, id: String, list: List) -> Vec<Version> {
 }
 ///Get version with the version ids
-pub async fn get_raw_versions(api: &str, versions: Vec<String>) -> Vec<Version> {
+pub async fn get_raw_versions(
+    api: &str,
+    versions: Vec<String>,
+) -> Vec<Version> {
    let url = format!(r#"versions?ids=["{}"]"#, versions.join(r#"",""#));
    let data = get(api, &url).await.unwrap().unwrap();
@@ -208,7 +214,10 @@ pub fn extract_current_version(versions: Vec<Version>) -> MLE<String> {
 }
 pub async fn get_game_versions() -> Vec<GameVersion> {
-    let data = get("https://api.modrinth.com/v2/", "tag/game_version").await.unwrap().unwrap();
+    let data = get("https://api.modrinth.com/v2/", "tag/game_version")
+        .await
+        .unwrap()
+        .unwrap();
    serde_json::from_slice(&data).unwrap()
 }
diff --git a/src/cache.rs b/src/cache.rs
index c928670..8df4d2f 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -31,7 +31,7 @@ pub fn get_cached_versions(path: &str) -> HashMap<String, String> {
 /// Panics if .
 pub fn copy_cached_version(version_path: &str, download_path: &str) {
    let versplit: Vec<&str> = version_path.split('/').collect();
-    let download = format!("{}/{}", download_path, versplit[versplit.len() - 1]);
+    let download =
-    // println!("{:#?}", download);
+        format!("{}/{}", download_path, versplit[versplit.len() - 1]);
    copy(version_path, download).unwrap();
 }
diff --git a/src/commands/download.rs b/src/commands/download.rs
index ebfb4eb..a7cf744 100644
--- a/src/commands/download.rs
+++ b/src/commands/download.rs
@@ -1,26 +1,48 @@
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use crate::{config::Cfg, List};
 use crate::{
    db::userlist_get_all_current_versions_with_mods,
    error::{ErrorType, MLError, MLE},
    files::{
-        clean_list_dir, delete_version, disable_version, download_versions, get_downloaded_versions,
+        clean_list_dir, delete_version, disable_version, download_versions,
+        get_downloaded_versions,
    },
    modrinth::get_raw_versions,
 };
+use crate::{PROGRESS_CHARS, STYLE_BAR_POS};
-pub async fn download(config: Cfg, liststack: Vec<List>, clean: bool, delete_old: bool) -> MLE<()> {
+pub async fn download(
+    config: &Cfg,
+    liststack: Vec<List>,
+    clean: bool,
+    delete_old: bool,
+) -> MLE<()> {
+    let mp = MultiProgress::new();
+    let download_p =
+        mp.add(ProgressBar::new(liststack.len().try_into().unwrap()));
+    download_p.set_style(
+        ProgressStyle::with_template(STYLE_BAR_POS)
+            .unwrap()
+            .progress_chars(PROGRESS_CHARS),
+    );
    for current_list in liststack {
-        println!("Downloading current versions of mods in {}", current_list.id);
+        download_p.set_message(format!("Download in {}", current_list.id));
-        let downloaded_versions = get_downloaded_versions(current_list.clone())?;
-        // println!("To download: {:#?}", downloaded_versions);
+        let downloaded_versions =
-        let current_version_ids = match userlist_get_all_current_versions_with_mods(
+            get_downloaded_versions(current_list.clone())?;
-            config.clone(),
+        let current_version_ids =
-            String::from(&current_list.id),
+            match userlist_get_all_current_versions_with_mods(
-        ) {
+                config,
-            Ok(i) => Ok(i),
+                String::from(&current_list.id),
-            Err(e) => Err(MLError::new(ErrorType::DBError, e.to_string().as_str())),
+            ) {
-        }?;
+                Ok(i) => Ok(i),
+                Err(e) => Err(MLError::new(
+                    ErrorType::DBError,
+                    e.to_string().as_str(),
+                )),
+            }?;
        let mut to_download: Vec<String> = vec![];
        //(mod_id, version_id)
@@ -39,7 +61,10 @@ pub async fn download(config: Cfg, liststack: Vec<List>, clean: bool, delete_old
                    .ok_or("SOMETHING_HAS_REALLY_GONE_WRONG")
                    .unwrap();
                if &current_version != downloaded_version {
-                    to_disable.push((mod_id.clone(), String::from(downloaded_version)));
+                    to_disable.push((
+                        mod_id.clone(),
+                        String::from(downloaded_version),
+                    ));
                    to_download.push(current_version);
                }
            }
@@ -54,23 +79,57 @@ pub async fn download(config: Cfg, liststack: Vec<List>, clean: bool, delete_old
                current_list.clone(),
                config.clone(),
                get_raw_versions(&config.apis.modrinth, to_download).await,
+                &mp,
+                &download_p,
            )
            .await?;
        } else {
-            println!("There are no new versions to download");
+            download_p.println(format!(
+                "There are no new versions to download for {}",
+                current_list.id
+            ));
        }
        if !to_disable.is_empty() {
+            let d_p = mp.insert_before(
+                &download_p,
+                ProgressBar::new(to_disable.len().try_into().unwrap()),
+            );
+            d_p.set_style(
+                ProgressStyle::with_template(STYLE_BAR_POS)
+                    .unwrap()
+                    .progress_chars(PROGRESS_CHARS),
+            );
            for ver in to_disable {
                if delete_old {
-                    println!("Deleting version {} for mod {}", ver.1, ver.0);
+                    d_p.set_message(format!("Delete version {}", ver.1));
-                    delete_version(current_list.clone(), ver.1)?;
+                    d_p.inc(1);
+                    delete_version(&current_list, ver.1)?;
                } else {
-                    disable_version(config.clone(), current_list.clone(), ver.1, ver.0)?;
+                    d_p.set_message(format!("Disable version {}", ver.1));
+                    d_p.inc(1);
+                    disable_version(
+                        config,
+                        current_list.clone(),
+                        ver.1,
+                        ver.0,
+                    )?;
                };
            }
+            let del_msg = if delete_old {
+                "Deleted all old versions"
+            } else {
+                "Disabled all old versions"
+            };
+            d_p.finish_with_message(del_msg);
        }
+        download_p.inc(1);
    }
+    download_p.finish_with_message("Downloaded all lists");
    Ok(())
 }
diff --git a/src/commands/io.rs b/src/commands/io.rs
index dd294bc..8e44b2b 100644
--- a/src/commands/io.rs
+++ b/src/commands/io.rs
@@ -1,12 +1,16 @@
+use indicatif::{ProgressBar, ProgressStyle};
 use serde::{Deserialize, Serialize};
 use std::fs::File;
 use std::io::prelude::*;
 use crate::{
    config::Cfg,
-    db::{lists_get, lists_get_all_ids, lists_insert, userlist_get_set_version, userlist_get_all_ids, userlist_get_current_version},
+    db::{
+        lists_get, lists_get_all_ids, lists_insert, userlist_get_all_ids,
+        userlist_get_current_version, userlist_get_set_version,
+    },
    error::MLE,
-    mod_add, IDSelector, List, Modloader, AddMod,
+    mod_add, AddMod, IDSelector, List, Modloader, STYLE_OPERATION,
 };
 #[derive(Debug, Serialize, Deserialize)]
@@ -17,14 +21,14 @@ struct Export {
 #[derive(Debug, Serialize, Deserialize)]
 struct ExportVersion {
    version: String,
-    set: bool
+    set: bool,
 }
 impl ExportVersion {
-    fn from(config: Cfg, list_id: &str, mod_id: &str) -> MLE<Self> {
+    fn from(config: &Cfg, list_id: &str, mod_id: &str) -> MLE<Self> {
        Ok(Self {
-            version: userlist_get_current_version(config.clone(), list_id, mod_id)?,
+            version: userlist_get_current_version(config, list_id, mod_id)?,
-            set: userlist_get_set_version(config.clone(), list_id, mod_id)?
+            set: userlist_get_set_version(config, list_id, mod_id)?,
        })
    }
 }
@@ -39,18 +43,18 @@ struct ExportList {
 }
 impl ExportList {
-    pub fn from(config: Cfg, list_id: String, download: bool) -> MLE<Self> {
+    pub fn from(config: &Cfg, list_id: &str, download: bool) -> MLE<Self> {
-        let list = lists_get(config.clone(), String::from(&list_id))?;
+        let list = lists_get(config, list_id)?;
        let mut dl_folder = None;
        if download {
            dl_folder = Some(list.download_folder)
        };
-        let mods = userlist_get_all_ids(config.clone(), &list_id)?;
+        let mods = userlist_get_all_ids(config, list_id)?;
        let mut versions = vec![];
        for m in mods {
-            versions.push(ExportVersion::from(config.clone(), &list_id, &m)?)
+            versions.push(ExportVersion::from(config, list_id, &m)?)
        }
        Ok(Self {
@@ -63,29 +67,46 @@ impl ExportList {
    }
 }
-pub fn export(config: Cfg, list: Option<String>) -> MLE<()> {
+pub fn export(config: &Cfg, list: Option<String>) -> MLE<()> {
+    let progress = ProgressBar::new_spinner();
+    progress.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
    let mut list_ids: Vec<String> = vec![];
    if list.is_none() {
-        list_ids = lists_get_all_ids(config.clone())?;
+        list_ids = lists_get_all_ids(config)?;
    } else {
-        list_ids.push(lists_get(config.clone(), list.unwrap())?.id);
+        list_ids.push(lists_get(config, &list.unwrap())?.id);
    }
    let mut lists: Vec<ExportList> = vec![];
    for list_id in list_ids {
-        lists.push(ExportList::from(config.clone(), list_id, true)?);
+        progress.set_message(format!("Export {}", list_id));
+        //TODO download option/ new download on import
+        lists.push(ExportList::from(config, &list_id, true)?);
    }
    let toml = toml::to_string(&Export { lists })?;
-    let filestr = dirs::home_dir().unwrap().join("mlexport.toml");
+    let filestr = dirs::home_dir()
+        .unwrap()
+        .join("mlexport.toml")
+        .into_os_string()
+        .into_string()
+        .unwrap();
-    let mut file = File::create(filestr.into_os_string().into_string().unwrap().as_str())?;
+    progress.set_message("Create file");
+    let mut file = File::create(&filestr)?;
    file.write_all(toml.as_bytes())?;
+    progress.finish_with_message(format!("Exported to {}", filestr));
    Ok(())
 }
-pub async fn import(config: Cfg, file_str: String, direct_download: bool) -> MLE<()> {
+pub async fn import(
+    config: &Cfg,
+    file_str: &str,
+    direct_download: bool,
+) -> MLE<()> {
    let mut file = File::open(file_str)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
@@ -99,18 +120,21 @@ pub async fn import(config: Cfg, file_str: String, direct_download: bool) -> MLE
            download_folder: exportlist.download_folder.ok_or("NO_DL").unwrap(),
        };
        lists_insert(
-            config.clone(),
+            config,
-            list.id.clone(),
+            &list.id,
-            list.mc_version.clone(),
+            &list.mc_version,
-            list.modloader.clone(),
+            &list.modloader,
-            String::from(&list.download_folder),
+            &list.download_folder,
        )?;
        let mut ver_ids = vec![];
        for id in exportlist.versions {
-            ver_ids.push(AddMod { id: IDSelector::VersionID(id.version), set_version: id.set} );
+            ver_ids.push(AddMod {
+                id: IDSelector::VersionID(id.version),
+                set_version: id.set,
+            });
        }
-        mod_add(config.clone(), ver_ids, list, direct_download).await?;
+        mod_add(config, ver_ids, list, direct_download).await?;
    }
    Ok(())
 }
diff --git a/src/commands/list.rs b/src/commands/list.rs
index 4aa4306..3665446 100644
--- a/src/commands/list.rs
+++ b/src/commands/list.rs
@@ -1,11 +1,13 @@
+use indicatif::{ProgressBar, ProgressStyle};
 use crate::{
    config::Cfg,
    db::{
-        config_change_current_list, config_get_current_list, lists_get, lists_insert, lists_remove,
+        config_change_current_list, config_get_current_list, lists_get,
-        lists_version, lists_get_all_ids,
+        lists_get_all_ids, lists_insert, lists_remove, lists_version,
    },
-    error::{MLE, MLError, ErrorType},
+    error::{ErrorType, MLError, MLE},
-    update, Modloader,
+    update, Modloader, STYLE_OPERATION,
 };
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -16,31 +18,47 @@ pub struct List {
    pub download_folder: String,
 }
-pub fn get_current_list(config: Cfg) -> MLE<List> {
+pub fn get_current_list(config: &Cfg) -> MLE<List> {
-    let id = config_get_current_list(config.clone())?;
+    let id = config_get_current_list(config)?;
-    lists_get(config, id)
+    lists_get(config, &id)
 }
 pub fn list_add(
-    config: Cfg,
+    config: &Cfg,
-    id: String,
+    id: &str,
-    mc_version: String,
+    mc_version: &str,
-    modloader: Modloader,
+    modloader: &Modloader,
-    directory: String,
+    directory: &str,
 ) -> MLE<()> {
-    lists_insert(config, id, mc_version, modloader, directory)
+    let p = ProgressBar::new_spinner();
+    p.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+    p.set_message(format!("Create {}", id));
+    lists_insert(config, id, mc_version, modloader, directory)?;
+    p.finish_with_message(format!("Created {}", id));
+    Ok(())
 }
-pub fn list_change(config: Cfg, id: String) -> MLE<()> {
+pub fn list_change(config: &Cfg, id: &str) -> MLE<()> {
-    if lists_get_all_ids(config.clone())?.into_iter().find(|l| l == &id).is_none() {
+    let p = ProgressBar::new_spinner();
+    p.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+    p.set_message(format!("Change default list to {}", id));
+    if !lists_get_all_ids(config)?.into_iter().any(|l| l == id) {
        return Err(MLError::new(ErrorType::ArgumentError, "List not found"));
    };
-    println!("Change default list to: {}", id);
+    config_change_current_list(config, id)?;
-    config_change_current_list(config, id)
+    p.finish_with_message(format!("Changed default list to {}", id));
+    Ok(())
 }
-pub fn list_remove(config: Cfg, id: String) -> MLE<()> {
+pub fn list_remove(config: &Cfg, id: &str) -> MLE<()> {
-    lists_remove(config, id)
+    let p = ProgressBar::new_spinner();
+    p.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+    p.set_message(format!("Remove {}", id));
+    lists_remove(config, id)?;
+    p.finish_with_message(format!("Removed {}", id));
+    Ok(())
 }
 ///Changing the current lists version and updating it
@@ -50,31 +68,34 @@ pub fn list_remove(config: Cfg, id: String) -> MLE<()> {
 /// * `config` - The current config
 /// * `args` - All args, to extract the new version
 pub async fn list_version(
-    config: Cfg,
+    config: &Cfg,
-    id: String,
+    id: &str,
    mc_version: String,
    download: bool,
    delete: bool,
 ) -> MLE<()> {
-    println!(
+    let p = ProgressBar::new_spinner();
+    p.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+    p.set_message(format!(
        "Change version for list {} to minecraft version: {}",
        id, mc_version
-    );
+    ));
-    lists_version(config.clone(), &id, &mc_version)?;
+    lists_version(config, id, &mc_version)?;
+    p.finish_with_message(format!(
+        "Changed version for list {} to minecraft version: {}",
+        id, mc_version
+    ));
-    println!(
+    let list = lists_get(config, id)?;
-        "\nCheck for updates for new minecraft version in list {}",
-        id
-    );
-    let list = lists_get(config.clone(), id)?;
    update(config, vec![list], true, download, delete).await
 }
-pub fn list_list(config: Cfg) -> MLE<()> {
+pub fn list_list(config: &Cfg) -> MLE<()> {
-    let lists = lists_get_all_ids(config.clone())?;
+    let lists = lists_get_all_ids(config)?;
    for list in lists {
-        let l = lists_get(config.clone(), list)?;
+        let l = lists_get(config, &list)?;
        println!("{}: | {} | {}", l.id, l.mc_version, l.modloader)
    }
    Ok(())
diff --git a/src/commands/modification.rs b/src/commands/modification.rs
index 9a1a651..4488b70 100644
--- a/src/commands/modification.rs
+++ b/src/commands/modification.rs
@@ -1,24 +1,30 @@
-use std::{io::Write, collections::HashMap};
+use std::collections::HashMap;
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use crate::{
    config::Cfg,
    db::{
-        lists_get_all_ids, mods_get_id, mods_insert, mods_remove, userlist_get_all_ids,
+        lists_get_all_ids, mods_get_id, mods_get_info, mods_insert,
-        userlist_get_current_version, userlist_insert, userlist_remove, mods_get_info,
+        mods_remove, userlist_get_all_ids, userlist_get_current_version,
+        userlist_insert, userlist_remove,
    },
    error::{ErrorType, MLError, MLE},
    files::{delete_version, download_versions},
-    modrinth::{extract_current_version, get_raw_versions, project, projects, versions, Version},
+    modrinth::{
-    List,
+        extract_current_version, get_raw_versions, project, projects, versions,
+        Version,
+    },
+    List, PROGRESS_CHARS, STYLE_BAR_POS, STYLE_OPERATION,
 };
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct AddMod {
    pub id: IDSelector,
-    pub set_version: bool
+    pub set_version: bool,
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum IDSelector {
    ModificationID(String),
    VersionID(String),
@@ -36,54 +42,76 @@ pub struct ProjectInfo {
 }
 pub async fn mod_add(
-    config: Cfg,
+    config: &Cfg,
    mods: Vec<AddMod>,
    list: List,
    direct_download: bool,
 ) -> MLE<()> {
-    println!("Add mods to {}", list.id);
+    let mp = MultiProgress::new();
-    println!("  └Add mods:");
    let mut mod_ids: Vec<(String, bool)> = Vec::new();
    let mut ver_ids: Vec<(String, bool)> = Vec::new();
+    let add_p = mp.add(ProgressBar::new(mods.len().try_into().unwrap()));
+    add_p.set_style(
+        ProgressStyle::with_template(STYLE_BAR_POS)
+            .unwrap()
+            .progress_chars(PROGRESS_CHARS),
+    );
+    add_p.set_message("Sort ids");
    //"Sort" project ids from version ids to be able to handle them differently but in a batch
    for m in mods {
+        add_p.inc(1);
        match m.id {
-            IDSelector::ModificationID(pid) => mod_ids.push((pid, m.set_version)),
+            IDSelector::ModificationID(pid) => {
+                mod_ids.push((pid, m.set_version))
+            }
            IDSelector::VersionID(vid) => ver_ids.push((vid, m.set_version)),
        }
    }
+    add_p.set_message("Get infos");
    let mut projectinfo: Vec<ProjectInfo> = Vec::new();
    if !mod_ids.is_empty() {
-        projectinfo.append(&mut get_mod_infos(config.clone(), mod_ids, list.clone()).await?)
+        projectinfo
+            .append(&mut get_mod_infos(config, mod_ids, list.clone()).await?);
    };
    if !ver_ids.is_empty() {
-        projectinfo.append(&mut get_ver_info(config.clone(), ver_ids).await?)
+        projectinfo.append(&mut get_ver_info(config, ver_ids).await?);
    };
    if projectinfo.is_empty() {
        return Err(MLError::new(ErrorType::ArgumentError, "NO_IDS?"));
    };
+    add_p.set_message("Add mods to database");
    let mut downloadstack: Vec<Version> = Vec::new();
    //Adding each mod to the lists and downloadstack
-    if projectinfo.len() == 1 {
+    let project_p = mp.insert_before(
-        println!("  └Insert mod in list {} and save infos", list.id);
+        &add_p,
-    } else {
+        ProgressBar::new(projectinfo.len().try_into().unwrap()),
-        println!("  └Insert mods in list {} and save infos", list.id);
+    );
-    }
+    project_p.set_style(
+        ProgressStyle::with_template(STYLE_BAR_POS)
+            .unwrap()
+            .progress_chars(PROGRESS_CHARS),
+    );
    for project in projectinfo {
+        project_p.set_message(format!("Add {}", project.title));
        let current_version_id = if project.current_version.is_none() {
            String::from("NONE")
        } else {
            project.current_version.clone().unwrap().id
        };
        match userlist_insert(
-            config.clone(),
+            config,
            &list.id,
            &project.mod_id,
            &current_version_id,
@@ -92,7 +120,10 @@ pub async fn mod_add(
            project.set_version,
        ) {
            Err(e) => {
-                let expected_err = format!("SQL: UNIQUE constraint failed: {}.mod_id", list.id);
+                let expected_err = format!(
+                    "SQL: UNIQUE constraint failed: {}.mod_id",
+                    list.id
+                );
                if e.to_string() == expected_err {
                    Err(MLError::new(
                        ErrorType::ModError,
@@ -106,7 +137,7 @@ pub async fn mod_add(
        }?;
        match mods_insert(
-            config.clone(),
+            config,
            &project.mod_id,
            &project.slug,
            &project.title,
@@ -124,18 +155,35 @@ pub async fn mod_add(
        if project.current_version.is_some() {
            downloadstack.push(project.current_version.unwrap())
        };
+        project_p.inc(1);
    }
+    project_p.finish_with_message("Added all mods to the database");
    //Download all the added mods
    if direct_download {
-        download_versions(list.clone(), config.clone(), downloadstack).await?;
+        add_p.set_message("Download mods");
+        download_versions(
+            list.clone(),
+            config.clone(),
+            downloadstack,
+            &mp,
+            &add_p,
+        )
+        .await?;
    };
+    add_p.finish_with_message("Added all mods");
    Ok(())
 }
-async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) -> MLE<Vec<ProjectInfo>> {
+async fn get_mod_infos(
+    config: &Cfg,
+    mod_ids: Vec<(String, bool)>,
+    list: List,
+) -> MLE<Vec<ProjectInfo>> {
    let mut setmap: HashMap<String, bool> = HashMap::new();
    let mut ids = vec![];
@@ -154,8 +202,6 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
        _ => panic!("PANIC"),
    };
    for project in m_projects {
-        println!("\t└{}", project.title);
-        println!("\t  └Get versions");
        let available_versions = versions(
            &config.apis.modrinth,
            String::from(&project.id),
@@ -167,8 +213,8 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
        let current_version: Option<Version>;
        let file: String;
        if !available_versions.is_empty() {
-            let current_id = extract_current_version(available_versions.clone())?;
+            let current_id =
-            println!("\t  └Current version: {}", current_id);
+                extract_current_version(available_versions.clone())?;
            current_version = Some(
                available_versions
@@ -177,19 +223,15 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
                    .find(|v| v.id == current_id)
                    .unwrap(),
            );
-            
            // match primary, if none?
-            let files = current_version
+            let files = current_version.clone().ok_or("").unwrap().files;
-                .clone()
-                .ok_or("")
-                .unwrap()
-                .files;
            file = match files.clone().into_iter().find(|f| f.primary) {
-                    Some(f) => f,
+                Some(f) => f,
-                    None => { files[0].clone() }
+                None => files[0].clone(),
-                }
+            }
-                .url;
+            .url;
            for ver in available_versions {
                available_versions_vec.push(ver.id);
@@ -197,15 +239,14 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
            projectinfo.push(ProjectInfo {
                mod_id: String::from(&project.id),
-                slug: project.slug,
+                slug: project.slug.clone(),
                title: project.title,
                current_version,
                applicable_versions: available_versions_vec,
                download_link: file,
-                set_version: setmap.get(&project.id).unwrap().clone(),
+                set_version: *setmap.get(&project.slug).unwrap(),
            })
        } else {
-            println!("\t  └There's currently no mod version for your specified target");
            current_version = None;
            file = String::from("NONE");
            available_versions_vec.push(String::from("NONE"));
@@ -216,7 +257,7 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
                current_version,
                applicable_versions: available_versions_vec,
                download_link: file,
-                set_version: setmap.get(&project.id).unwrap().clone(),
+                set_version: *setmap.get(&project.id).unwrap(),
            })
        }
    }
@@ -224,8 +265,10 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
    Ok(projectinfo)
 }
-async fn get_ver_info(config: Cfg, ver_ids: Vec<(String, bool)>) -> MLE<Vec<ProjectInfo>> {
+async fn get_ver_info(
+    config: &Cfg,
+    ver_ids: Vec<(String, bool)>,
+) -> MLE<Vec<ProjectInfo>> {
    let mut setmap: HashMap<String, bool> = HashMap::new();
    let mut ids = vec![];
@@ -248,14 +291,15 @@ async fn get_ver_info(config: Cfg, ver_ids: Vec<(String, bool)>) -> MLE<Vec<Proj
    for (i, project) in v_projects.into_iter().enumerate() {
        let version = &v_versions[i];
-        println!("\t└{}({})", project.title, version.id);
-        let file = version
+        let files = version.clone().files;
-            .clone()
-            .files
+        let file = match files.clone().into_iter().find(|f| f.primary) {
-            .into_iter()
+            Some(f) => f,
-            .find(|f| f.primary)
+            None => files[0].clone(),
-            .unwrap()
+        }
-            .url;
+        .url;
        projectinfo.push(ProjectInfo {
            mod_id: String::from(&project.id),
            slug: project.slug,
@@ -263,7 +307,7 @@ async fn get_ver_info(config: Cfg, ver_ids: Vec<(String, bool)>) -> MLE<Vec<Proj
            current_version: Some(version.clone()),
            applicable_versions: vec![String::from(&version.id)],
            download_link: file,
-            set_version: setmap.get(&version.id).unwrap().clone(),
+            set_version: *setmap.get(&version.id).unwrap(),
        })
    }
    Ok(projectinfo)
@@ -275,48 +319,45 @@ async fn get_ver_info(config: Cfg, ver_ids: Vec<(String, bool)>) -> MLE<Vec<Proj
 /// * `config` - config struct
 /// * `id` - name, slug or id of the mod
 /// * `list` - List struct
-pub fn mod_remove(config: Cfg, id: &str, list: List) -> MLE<()> {
+pub fn mod_remove(config: &Cfg, id: &str, list: &List) -> MLE<()> {
+    let progress = ProgressBar::new_spinner();
+    progress.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
    let mod_id = mods_get_id(&config.data, id)?;
-    println!("Remove mod {} from {}", mods_get_info(config.clone(), &mod_id)?.title, list.id);
+    let info = mods_get_info(config, &mod_id)?;
-    let version = userlist_get_current_version(config.clone(), &list.id, &mod_id)?;
-    print!("  └Remove from list");
+    progress.set_message(format!("Remove {} from {}", info.title, list.id));
-    //Force flush of stdout, else print! doesn't print instantly
-    std::io::stdout().flush()?;
-    userlist_remove(config.clone(), &list.id, &mod_id)?;
-    println!(" ✓");
-    print!("  └Delete file");
+    let version = userlist_get_current_version(config, &list.id, &mod_id)?;
-    //Force flush of stdout, else print! doesn't print instantly
-    std::io::stdout().flush()?;
+    userlist_remove(config, &list.id, &mod_id)?;
+    progress.set_message("Delete file");
    match delete_version(list, version) {
        Ok(_) => (),
        Err(err) => {
-            if err.to_string() !=  "User input not accepted: VERSION_NOT_FOUND_IN_FILES" {
+            if err.to_string()
+                != "User input not accepted: VERSION_NOT_FOUND_IN_FILES"
+            {
                return Err(err);
            };
-            ()
+        }
-        },
    };
-    println!(" ✓");
-    print!("  └Clean main db table");
+    progress.set_message("Check main list");
-    //Force flush of stdout, else print! doesn't print instantly
+    let list_ids = lists_get_all_ids(config)?;
-    std::io::stdout().flush()?;
-    let list_ids = lists_get_all_ids(config.clone())?;
    // Remove mod from main list if not used elsewhere
    let mut mod_used = false;
    for id in list_ids {
-        let mods = match userlist_get_all_ids(config.clone(), &id) {
+        let mods = match userlist_get_all_ids(config, &id) {
            Ok(m) => m,
            Err(err) => {
-                if err.to_string() ==  "Database: NO_MODS_USERLIST" {
+                if err.to_string() == "Database: NO_MODS_USERLIST" {
-                    println!(" ✓");
                    return Ok(());
                };
-                return Err(err)
+                return Err(err);
            }
        };
        if mods.contains(&mod_id) {
@@ -326,9 +367,14 @@ pub fn mod_remove(config: Cfg, id: &str, list: List) -> MLE<()> {
    }
    if !mod_used {
-        mods_remove(config, mod_id)?;
+        progress.set_message("Remove from main list");
+        mods_remove(config, &mod_id)?;
    };
-    println!(" ✓");
+    progress.finish_with_message(format!(
+        "Removed {} from {}",
+        info.title, list.id
+    ));
    Ok(())
 }
diff --git a/src/commands/update.rs b/src/commands/update.rs
index d3a282b..c19c02c 100644
--- a/src/commands/update.rs
+++ b/src/commands/update.rs
@@ -1,49 +1,81 @@
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use crate::{
    config::Cfg,
    db::{
        mods_get_info, userlist_change_versions, userlist_get_all_ids,
-        userlist_get_applicable_versions, userlist_get_current_version, userlist_get_set_version,
+        userlist_get_applicable_versions, userlist_get_current_version,
+        userlist_get_set_version,
    },
    error::{ErrorType, MLError, MLE},
-    files::{clean_list_dir, delete_version, disable_version, download_versions},
+    files::{
+        clean_list_dir, delete_version, disable_version, download_versions,
+    },
    modrinth::{extract_current_version, versions, Version},
-    List,
+    List, PROGRESS_CHARS, STYLE_BAR_POS, STYLE_OPERATION,
 };
 pub async fn update(
-    config: Cfg,
+    config: &Cfg,
    liststack: Vec<List>,
    clean: bool,
    direct_download: bool,
    delete_old: bool,
 ) -> MLE<()> {
+    let mp = MultiProgress::new();
+    let update_p =
+        mp.add(ProgressBar::new(liststack.len().try_into().unwrap()));
+    update_p.set_style(
+        ProgressStyle::with_template(STYLE_BAR_POS)
+            .unwrap()
+            .progress_chars(PROGRESS_CHARS),
+    );
    for current_list in liststack {
-        println!("Update mods in {}", current_list.id);
+        update_p.set_message(format!("Update {}", current_list.id));
-        let mods = userlist_get_all_ids(config.clone(), &current_list.id)?;
-        let mut current_versions: Vec<(String, String)> = vec![];
+        let list_p = mp.insert_before(&update_p, ProgressBar::new(2));
+        list_p
+            .set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+        list_p.set_message("Update mods");
+        let mods = userlist_get_all_ids(config, &current_list.id)?;
+        let list_u_p = mp.insert_before(
+            &list_p,
+            ProgressBar::new(mods.len().try_into().unwrap()),
+        );
+        list_u_p.set_style(
+            ProgressStyle::with_template(STYLE_BAR_POS)
+                .unwrap()
+                .progress_chars(PROGRESS_CHARS),
+        );
+        let mut current_versions: Vec<(String, String)> = vec![];
        let mut updatestack: Vec<Version> = vec![];
        for id in mods {
-            let info = mods_get_info(config.clone(), &id)?;
+            let info = mods_get_info(config, &id)?;
-            println!("  ├{}", info.title);
+            list_u_p.set_message(format!("Update {}", info.title));
-            if userlist_get_set_version(config.clone(), &current_list.id, &id)? {
+            //Skip check if version is set
-                println!("  │ └Set version, skipping update");
+            if userlist_get_set_version(config, &current_list.id, &id)? {
+                list_u_p.inc(1);
                continue;
            }
            //Getting current installed version for disable or delete
            let disable_version =
-                userlist_get_current_version(config.clone(), &current_list.id, &id)?;
+                userlist_get_current_version(config, &current_list.id, &id)?;
            updatestack.push(
                match specific_update(
-                    config.clone(),
+                    config,
                    clean,
                    current_list.clone(),
-                    String::from(&id),
+                    &id,
+                    &list_u_p,
                )
                .await
                {
@@ -53,46 +85,94 @@ pub async fn update(
                    }
                    Err(e) => {
                        if e.to_string() == "Mod: NO_UPDATE_AVAILABLE" {
-                            println!(
-                                "  │ └No new version found for the specified minecraft version"
-                            );
                        } else {
                            return Err(e);
                        };
+                        list_u_p.inc(1);
                        continue;
                    }
                },
-            )
+            );
+            list_u_p.inc(1);
        }
+        list_u_p.finish_with_message(format!(
+            "Updated mods in {}",
+            current_list.id
+        ));
        if clean {
+            list_p.set_message("Cleaning");
            clean_list_dir(&current_list)?;
        };
        if direct_download && !updatestack.is_empty() {
-            download_versions(current_list.clone(), config.clone(), updatestack).await?;
+            download_versions(
+                current_list.clone(),
+                config.clone(),
+                updatestack,
+                &mp,
+                &list_p,
+            )
+            .await?;
            //Disable old versions
            if !clean {
+                let d_p = mp.insert_before(
+                    &list_p,
+                    ProgressBar::new(
+                        current_versions.len().try_into().unwrap(),
+                    ),
+                );
+                d_p.set_style(
+                    ProgressStyle::with_template(STYLE_BAR_POS)
+                        .unwrap()
+                        .progress_chars(PROGRESS_CHARS),
+                );
                for ver in current_versions {
                    if delete_old {
-                        println!("    └Delete version {}", ver.0);
+                        d_p.set_message(format!("Delete version {}", ver.0));
-                        delete_version(current_list.clone(), ver.0)?;
+                        d_p.inc(1);
+                        delete_version(&current_list, ver.0)?;
                    } else if ver.0 != "NONE" {
-                        println!("    └Disable version {}", ver.0);
+                        d_p.set_message(format!("Disable version {}", ver.0));
-                        disable_version(config.clone(), current_list.clone(), ver.0, ver.1)?;
+                        d_p.inc(1);
+                        disable_version(
+                            config,
+                            current_list.clone(),
+                            ver.0,
+                            ver.1,
+                        )?;
                    };
                }
+                let del_msg = if delete_old {
+                    "Deleted all old versions"
+                } else {
+                    "Disabled all old versions"
+                };
+                d_p.finish_with_message(del_msg);
            }
        };
+        list_p.finish_with_message(format!("Updated {}", current_list.id));
+        update_p.inc(1);
    }
+    update_p.finish_with_message("Updated all lists");
    Ok(())
 }
-async fn specific_update(config: Cfg, clean: bool, list: List, id: String) -> MLE<Version> {
+async fn specific_update(
+    config: &Cfg,
+    clean: bool,
+    list: List,
+    id: &str,
+    progress: &ProgressBar,
+) -> MLE<Version> {
    let applicable_versions =
-        versions(&config.apis.modrinth, String::from(&id), list.clone()).await;
+        versions(&config.apis.modrinth, String::from(id), list.clone()).await;
    let mut versions: Vec<String> = vec![];
@@ -108,19 +188,19 @@ async fn specific_update(config: Cfg, clean: bool, list: List, id: String) -> ML
    if clean
        || (versions.join("|")
            != userlist_get_applicable_versions(
-                config.clone(),
+                config,
                String::from(&list.id),
-                String::from(&id),
+                String::from(id),
            )?)
    {
        let current_str = extract_current_version(applicable_versions.clone())?;
-        if clean {
+        if !clean {
-            println!("\t  └Add version to downloadstack");
+            progress.println(format!(
-        } else {
+                "Found new version for {}",
-            println!("\t  └Get versions for specified minecraft versions");
+                mods_get_info(config, id).unwrap().title
-            println!("\t  └New current version: {}", current_str);
+            ));
-        };
+        }
        //get new versions
        let current_ver = match applicable_versions
@@ -133,73 +213,27 @@ async fn specific_update(config: Cfg, clean: bool, list: List, id: String) -> ML
        }?;
        current.push(current_ver.clone());
-        let link = match current_ver
+        let files = &current_ver.files;
-            .files
-            .into_iter()
+        let link = match files.clone().into_iter().find(|f| f.primary) {
-            .find(|f| f.primary)
+            Some(f) => f,
-            .ok_or("!no primary in links")
+            None => files[0].clone(),
-        {
+        }
-            Ok(p) => Ok(p),
-            Err(e) => Err(MLError::new(ErrorType::Other, e)),
-        }?
        .url;
-        userlist_change_versions(config, list.id, current_str, versions.join("|"), link, id)?;
+        userlist_change_versions(
+            config,
+            list.id,
+            current_str,
+            versions.join("|"),
+            link,
+            id.to_string(),
+        )?;
    }
    if current.is_empty() {
        return Err(MLError::new(ErrorType::ModError, "NO_UPDATE_AVAILABLE"));
    };
-    //println!(" └✔️");
    Ok(current[0].clone())
 }
-// #[tokio::test]
-// async fn download_updates_test() {
-//     use crate::{
-//         modrinth::{Hash, Version, VersionFile, VersionType},
-//         List, Modloader,
-//     };
-//
-//     let config = Cfg::init().unwrap();
-//     let current_list = List {
-//         id: String::from("..."),
-//         mc_version: String::from("..."),
-//         modloader: Modloader::Fabric,
-//         download_folder: String::from("./dev/tests/dl"),
-//     };
-//
-//     let versions = vec![Version {
-//             id: "dEqtGnT9".to_string(),
-//             project_id: "kYuIpRLv".to_string(),
-//             author_id: "Qnt13hO8".to_string(),
-//             featured: true,
-//             name: "1.2.2-1.19 - Fabric".to_string(),
-//             version_number: "1.2.2-1.19".to_string(),
-//             changelog: None,
-//             date_published: "2022-11-02T17:41:43.072267Z".to_string(),
-//             downloads: 58,
-//             version_type: VersionType::release,
-//             files: vec![VersionFile {
-//                     hashes: Hash {
-//                         sha1: "fdc6dc39427fc92cc1d7ad8b275b5b83325e712b".to_string(),
-//                         sha512: "5b372f00d6e5d6a5ef225c3897826b9f6a2be5506905f7f71b9e939779765b41be6f2a9b029cfc752ad0751d0d2d5f8bb4544408df1363eebdde15641e99a849".to_string()
-//                     },
-//                     url: "https://cdn.modrinth.com/data/kYuIpRLv/versions/dEqtGnT9/waveycapes-fabric-1.2.2-mc1.19.2.jar".to_string(),
-//                     filename: "waveycapes-fabric-1.2.2-mc1.19.2.jar".to_string(),
-//                     primary: true,
-//                     size: 323176
-//             }],
-//             game_versions: vec![
-//                 "1.19".to_string(),
-//                 "1.19.1".to_string(),
-//                 "1.19.2".to_string()
-//             ],
-//             loaders: vec![
-//                 "fabric".to_string()
-//             ]
-//         }];
-//     assert!(download_versions(current_list, config, versions)
-//         .await
-//         .is_ok())
-// }
diff --git a/src/config.rs b/src/config.rs
index e1049d1..f0eb8f7 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -4,9 +4,12 @@ use std::{
    path::Path,
 };
+use indicatif::{ProgressBar, ProgressStyle};
 use serde::{Deserialize, Serialize};
-use crate::{db::db_setup, error::MLE, Modloader, VersionLevel, check_game_versions};
+use crate::{
+    check_game_versions, db::db_setup, error::MLE, Modloader, VersionLevel,
+};
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Cfg {
@@ -31,7 +34,7 @@ pub struct Defaults {
 impl Cfg {
    pub async fn init(path: Option<String>) -> MLE<Self> {
        let configfile = match path.clone() {
-            Some(p) => String::from(p),
+            Some(p) => p,
            None => dirs::config_dir()
                .unwrap()
                .join("modlist")
@@ -43,7 +46,8 @@ impl Cfg {
        let mut file = match File::open(&configfile) {
            Ok(file) => file,
            Err(err) => {
-                if err.kind() == std::io::ErrorKind::NotFound && path.is_none() {
+                if err.kind() == std::io::ErrorKind::NotFound && path.is_none()
+                {
                    create_config(&configfile)?;
                    File::open(&configfile)?
                } else {
@@ -71,16 +75,18 @@ impl Cfg {
            Err(..) => {
                create_versions_dummy(&versionfile).await?;
                check_game_versions(&versionfile, true).await?;
-            },
+            }
        }
        Ok(config)
    }
 }
 fn create_config(path: &str) -> MLE<()> {
-    print!("No config file found, create default");
+    let p = ProgressBar::new(1);
-    //Force flush of stdout, else print! doesn't print instantly
+    p.set_style(ProgressStyle::with_template("{wide_msg}").unwrap());
-    std::io::stdout().flush()?;
+    p.set_message("Create default config");
    let cache_dir = dirs::cache_dir()
        .unwrap()
        .join("modlist")
@@ -89,10 +95,10 @@ fn create_config(path: &str) -> MLE<()> {
    let default_cfg = Cfg {
        data: cache_dir.clone(),
        cache: format!("{}/cache", cache_dir),
-        versions: cache_dir.clone(),
+        versions: cache_dir,
        defaults: Defaults {
            modloader: Modloader::Fabric,
-            version: VersionLevel::Release
+            version: VersionLevel::Release,
        },
        apis: Apis {
            modrinth: String::from("https://api.modrinth.com/v2/"),
@@ -101,37 +107,36 @@ fn create_config(path: &str) -> MLE<()> {
    create_dir_all(path.split("config.toml").collect::<Vec<&str>>()[0])?;
    let mut file = File::create(path)?;
    file.write_all(toml::to_string(&default_cfg)?.as_bytes())?;
-    println!(" ✓");
+    p.finish_with_message(format!("Created default config ({})", path));
    Ok(())
 }
 fn create_database(path: &str) -> MLE<()> {
-    print!("No database found, create base");
+    let p = ProgressBar::new(1);
-    //Force flush of stdout, else print! doesn't print instantly
+    p.set_style(ProgressStyle::with_template("{wide_msg}").unwrap());
-    std::io::stdout().flush()?;
+    p.set_message("Create database");
    File::create(path)?;
    db_setup(path)?;
-    println!(" ✓");
+    p.finish_with_message(format!("Created database ({})", path));
    Ok(())
 }
 fn create_cache(path: &str) -> MLE<()> {
-    print!("No cache direcory found, create one");
+    let p = ProgressBar::new(1);
-    //Force flush of stdout, else print! doesn't print instantly
+    p.set_style(ProgressStyle::with_template("{wide_msg}").unwrap());
-    std::io::stdout().flush()?;
+    p.set_message("Create cache");
    create_dir_all(path)?;
-    println!(" ✓");
+    p.finish_with_message(format!("Created cache ({})", path));
    Ok(())
 }
 async fn create_versions_dummy(path: &str) -> MLE<()> {
-    print!("No version file found, create dummy");
+    let p = ProgressBar::new(1);
-    //Force flush of stdout, else print! doesn't print instantly
+    p.set_style(ProgressStyle::with_template("{wide_msg}").unwrap());
-    std::io::stdout().flush()?;
+    p.set_message("Create version file");
    File::create(path)?;
-    println!(" ✓");
+    p.finish_with_message(format!("Created version file ({})", path));
    Ok(())
 }
diff --git a/src/db.rs b/src/db.rs
index 8fd21b1..49db2fd 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -9,7 +9,7 @@ use crate::{
 };
 //MODS
-pub fn mods_insert(config: Cfg, id: &str, slug: &str, name: &str) -> MLE<()> {
+pub fn mods_insert(config: &Cfg, id: &str, slug: &str, name: &str) -> MLE<()> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
@@ -21,7 +21,9 @@ pub fn mods_insert(config: Cfg, id: &str, slug: &str, name: &str) -> MLE<()> {
    Ok(())
 }
-pub fn mods_get_all_ids(config: Cfg) -> Result<Vec<String>, Box<dyn std::error::Error>> {
+pub fn mods_get_all_ids(
+    config: &Cfg,
+) -> Result<Vec<String>, Box<dyn std::error::Error>> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data).unwrap();
@@ -64,8 +66,10 @@ pub fn mods_get_id(data: &str, slug: &str) -> MLE<String> {
    }
    //get from id if no slug found
    if mod_id.is_empty() {
-        let mut stmt = connection.prepare("SELECT id FROM mods WHERE id = ?")?;
+        let mut stmt =
-        let id_iter = stmt.query_map([slug], |row| row.get::<usize, String>(0))?;
+            connection.prepare("SELECT id FROM mods WHERE id = ?")?;
+        let id_iter =
+            stmt.query_map([slug], |row| row.get::<usize, String>(0))?;
        for id in id_iter {
            mod_id = id?;
@@ -73,8 +77,10 @@ pub fn mods_get_id(data: &str, slug: &str) -> MLE<String> {
    }
    //get from title if no id found from slug
    if mod_id.is_empty() {
-        let mut stmt = connection.prepare("SELECT id FROM mods WHERE title = ?")?;
+        let mut stmt =
-        let id_iter = stmt.query_map([slug], |row| row.get::<usize, String>(0))?;
+            connection.prepare("SELECT id FROM mods WHERE title = ?")?;
+        let id_iter =
+            stmt.query_map([slug], |row| row.get::<usize, String>(0))?;
        for id in id_iter {
            mod_id = id?;
@@ -93,12 +99,13 @@ pub struct ModInfo {
    pub title: String,
 }
-pub fn mods_get_info(config: Cfg, id: &str) -> MLE<ModInfo> {
+pub fn mods_get_info(config: &Cfg, id: &str) -> MLE<ModInfo> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
    let mut mod_info: Option<ModInfo> = None;
-    let mut stmt = connection.prepare("SELECT title, slug FROM mods WHERE id = ?")?;
+    let mut stmt =
+        connection.prepare("SELECT title, slug FROM mods WHERE id = ?")?;
    let name_iter = stmt.query_map([id], |row| {
        Ok(vec![
            row.get::<usize, String>(0)?,
@@ -120,9 +127,7 @@ pub fn mods_get_info(config: Cfg, id: &str) -> MLE<ModInfo> {
    }
 }
-pub fn mods_remove(config: Cfg, id: String) -> MLE<()> {
+pub fn mods_remove(config: &Cfg, id: &str) -> MLE<()> {
-    println!("Removing mod {} from database", id);
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
@@ -137,7 +142,10 @@ pub struct DBModlistVersions {
    pub versions: String,
 }
-pub fn mods_get_versions(config: Cfg, mods: Vec<String>) -> MLE<Vec<DBModlistVersions>> {
+pub fn mods_get_versions(
+    config: &Cfg,
+    mods: Vec<String>,
+) -> MLE<Vec<DBModlistVersions>> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
@@ -155,8 +163,9 @@ pub fn mods_get_versions(config: Cfg, mods: Vec<String>) -> MLE<Vec<DBModlistVer
    }
    let mut versionmaps: Vec<DBModlistVersions> = Vec::new();
-    let mut stmt = connection
+    let mut stmt = connection.prepare(
-        .prepare(format!("SELECT id, versions, title FROM mods {}", wherestr).as_str())?;
+        format!("SELECT id, versions, title FROM mods {}", wherestr).as_str(),
+    )?;
    let id_iter = stmt.query_map([], |row| {
        Ok(vec![
            row.get::<usize, String>(0)?,
@@ -167,11 +176,6 @@ pub fn mods_get_versions(config: Cfg, mods: Vec<String>) -> MLE<Vec<DBModlistVer
    for ver in id_iter {
        let version = ver?;
-        println!(
-            "\t({}) Get versions from the database",
-            String::from(&version[2])
-        );
-        //println!("Found versions {} for mod {}", version[1], version[0]);
        versionmaps.push(DBModlistVersions {
            mod_id: String::from(&version[0]),
            versions: String::from(&version[1]),
@@ -186,7 +190,7 @@ pub fn mods_get_versions(config: Cfg, mods: Vec<String>) -> MLE<Vec<DBModlistVer
 //userlist
 pub fn userlist_insert(
-    config: Cfg,
+    config: &Cfg,
    list_id: &str,
    mod_id: &str,
    current_version: &str,
@@ -220,26 +224,29 @@ pub fn userlist_insert(
    Ok(())
 }
-pub fn userlist_get_all_ids(config: Cfg, list_id: &str) -> MLE<Vec<String>> {
+pub fn userlist_get_all_ids(config: &Cfg, list_id: &str) -> MLE<Vec<String>> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data).unwrap();
    let mut mod_ids: Vec<String> = Vec::new();
-    let mut stmt = connection.prepare(format!("SELECT mod_id FROM {}", list_id).as_str())?;
+    let mut stmt = connection
+        .prepare(format!("SELECT mod_id FROM {}", list_id).as_str())?;
    let id_iter = stmt.query_map([], |row| row.get::<usize, String>(0))?;
    for id in id_iter {
-        //println!("Found id {:?}", id.as_ref().unwrap());
        mod_ids.push(id?)
    }
    match mod_ids.is_empty() {
-        true => Err(MLError::new(ErrorType::DBError, "NO_MODS_USERLIST")),
+        true => Err(MLError::new(
+            ErrorType::DBError,
+            &format!("NO_MODS_USERLIST{}", list_id),
+        )),
        false => Ok(mod_ids),
    }
 }
-pub fn userlist_remove(config: Cfg, list_id: &str, mod_id: &str) -> MLE<()> {
+pub fn userlist_remove(config: &Cfg, list_id: &str, mod_id: &str) -> MLE<()> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
@@ -251,7 +258,7 @@ pub fn userlist_remove(config: Cfg, list_id: &str, mod_id: &str) -> MLE<()> {
 }
 pub fn userlist_get_applicable_versions(
-    config: Cfg,
+    config: &Cfg,
    list_id: String,
    mod_id: String,
 ) -> MLE<String> {
@@ -266,7 +273,8 @@ pub fn userlist_get_applicable_versions(
        )
        .as_str(),
    )?;
-    let ver_iter = stmt.query_map([mod_id], |row| row.get::<usize, String>(0))?;
+    let ver_iter =
+        stmt.query_map([mod_id], |row| row.get::<usize, String>(0))?;
    for ver in ver_iter {
        version = ver?;
@@ -279,15 +287,16 @@ pub fn userlist_get_applicable_versions(
 }
 pub fn userlist_get_all_applicable_versions_with_mods(
-    config: Cfg,
+    config: &Cfg,
    list_id: String,
 ) -> MLE<Vec<(String, String)>> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
    let mut versions: Vec<(String, String)> = Vec::new();
-    let mut stmt = connection
+    let mut stmt = connection.prepare(
-        .prepare(format!("SELECT mod_id, applicable_versions FROM {}", list_id).as_str())?;
+        format!("SELECT mod_id, applicable_versions FROM {}", list_id).as_str(),
+    )?;
    let id_iter = stmt.query_map([], |row| {
        Ok(vec![
            row.get::<usize, String>(0)?,
@@ -307,14 +316,21 @@ pub fn userlist_get_all_applicable_versions_with_mods(
    Ok(versions)
 }
-pub fn userlist_get_current_version(config: Cfg, list_id: &str, mod_id: &str) -> MLE<String> {
+pub fn userlist_get_current_version(
+    config: &Cfg,
+    list_id: &str,
+    mod_id: &str,
+) -> MLE<String> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data).unwrap();
    let mut version: String = String::new();
-    let mut stmt = connection
+    let mut stmt = connection.prepare(
-        .prepare(format!("SELECT current_version FROM {} WHERE mod_id = ?", list_id).as_str())?;
+        format!("SELECT current_version FROM {} WHERE mod_id = ?", list_id)
-    let ver_iter = stmt.query_map([&mod_id], |row| row.get::<usize, String>(0))?;
+            .as_str(),
+    )?;
+    let ver_iter =
+        stmt.query_map([&mod_id], |row| row.get::<usize, String>(0))?;
    for ver in ver_iter {
        version = ver?;
@@ -327,15 +343,15 @@ pub fn userlist_get_current_version(config: Cfg, list_id: &str, mod_id: &str) ->
 }
 pub fn userlist_get_all_current_version_ids(
-    config: Cfg,
+    config: &Cfg,
    list_id: String,
 ) -> MLE<Vec<String>> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
    let mut versions: Vec<String> = Vec::new();
-    let mut stmt =
+    let mut stmt = connection
-        connection.prepare(format!("SELECT current_version FROM {}", list_id).as_str())?;
+        .prepare(format!("SELECT current_version FROM {}", list_id).as_str())?;
    let id_iter = stmt.query_map([], |row| row.get::<usize, String>(0))?;
    for id in id_iter {
@@ -343,25 +359,23 @@ pub fn userlist_get_all_current_version_ids(
    }
    if versions.is_empty() {
-        return Err(MLError::new(
+        return Err(MLError::new(ErrorType::DBError, "NO_MODS_ON_LIST"));
-            ErrorType::DBError,
-            "NO_MODS_ON_LIST",
-        ));
    };
    Ok(versions)
 }
 pub fn userlist_get_all_current_versions_with_mods(
-    config: Cfg,
+    config: &Cfg,
    list_id: String,
 ) -> Result<Vec<(String, String)>, Box<dyn std::error::Error>> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
    let mut versions: Vec<(String, String)> = Vec::new();
-    let mut stmt =
+    let mut stmt = connection.prepare(
-        connection.prepare(format!("SELECT mod_id, current_version FROM {}", list_id).as_str())?;
+        format!("SELECT mod_id, current_version FROM {}", list_id).as_str(),
+    )?;
    let id_iter = stmt.query_map([], |row| {
        Ok(vec![
            row.get::<usize, String>(0)?,
@@ -384,14 +398,21 @@ pub fn userlist_get_all_current_versions_with_mods(
    Ok(versions)
 }
-pub fn userlist_get_set_version(config: Cfg, list_id: &str, mod_id: &str) -> MLE<bool> {
+pub fn userlist_get_set_version(
+    config: &Cfg,
+    list_id: &str,
+    mod_id: &str,
+) -> MLE<bool> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data).unwrap();
    let mut set_version: bool = false;
-    let mut stmt = connection
+    let mut stmt = connection.prepare(
-        .prepare(format!("SELECT set_version FROM {} WHERE mod_id = ?", list_id).as_str())?;
+        format!("SELECT set_version FROM {} WHERE mod_id = ?", list_id)
-    let ver_iter = stmt.query_map([&mod_id], |row| row.get::<usize, bool>(0))?;
+            .as_str(),
+    )?;
+    let ver_iter =
+        stmt.query_map([&mod_id], |row| row.get::<usize, bool>(0))?;
    for ver in ver_iter {
        set_version = ver?;
@@ -401,7 +422,7 @@ pub fn userlist_get_set_version(config: Cfg, list_id: &str, mod_id: &str) -> MLE
 }
 pub fn userlist_change_versions(
-    config: Cfg,
+    config: &Cfg,
    list_id: String,
    current_version: String,
    versions: String,
@@ -416,7 +437,7 @@ pub fn userlist_change_versions(
 }
 pub fn userlist_add_disabled_versions(
-    config: Cfg,
+    config: &Cfg,
    list_id: String,
    disabled_version: String,
    mod_id: String,
@@ -424,11 +445,16 @@ pub fn userlist_add_disabled_versions(
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
-    let currently_disabled_versions =
+    let currently_disabled_versions = userlist_get_disabled_versions(
-        userlist_get_disabled_versions(config, String::from(&list_id), String::from(&mod_id))?;
+        config,
+        String::from(&list_id),
+        String::from(&mod_id),
+    )?;
    let disabled_versions = match currently_disabled_versions == "NONE" {
        true => disabled_version,
-        false => format!("{}|{}", currently_disabled_versions, disabled_version),
+        false => {
+            format!("{}|{}", currently_disabled_versions, disabled_version)
+        }
    };
    connection.execute(
@@ -442,14 +468,21 @@ pub fn userlist_add_disabled_versions(
    Ok(())
 }
-pub fn userlist_get_disabled_versions(config: Cfg, list_id: String, mod_id: String) -> MLE<String> {
+pub fn userlist_get_disabled_versions(
+    config: &Cfg,
+    list_id: String,
+    mod_id: String,
+) -> MLE<String> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data).unwrap();
    let mut version: String = String::new();
-    let mut stmt = connection
+    let mut stmt = connection.prepare(
-        .prepare(format!("SELECT disabled_versions FROM {} WHERE mod_id = ?", list_id).as_str())?;
+        format!("SELECT disabled_versions FROM {} WHERE mod_id = ?", list_id)
-    let ver_iter = stmt.query_map([mod_id], |row| row.get::<usize, String>(0))?;
+            .as_str(),
+    )?;
+    let ver_iter =
+        stmt.query_map([mod_id], |row| row.get::<usize, String>(0))?;
    for ver in ver_iter {
        version = ver?;
@@ -462,20 +495,20 @@ pub fn userlist_get_disabled_versions(config: Cfg, list_id: String, mod_id: Stri
 }
 pub fn userlist_get_all_downloads(
-    config: Cfg,
+    config: &Cfg,
    list_id: String,
 ) -> Result<Vec<String>, Box<dyn std::error::Error>> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data).unwrap();
    let mut links: Vec<String> = Vec::new();
-    let mut stmt =
+    let mut stmt = connection.prepare(
-        connection.prepare(format!("SELECT current_download FROM {}", list_id).as_str())?;
+        format!("SELECT current_download FROM {}", list_id).as_str(),
+    )?;
    let link_iter = stmt.query_map([], |row| row.get::<usize, String>(0))?;
    for link in link_iter {
        let l = link?;
-        println!("Found link {}", String::from(&l));
        links.push(l)
    }
@@ -492,32 +525,25 @@ pub fn userlist_get_all_downloads(
 //lists
 ///Inserts into lists table and creates new table
 pub fn lists_insert(
-    config: Cfg,
+    config: &Cfg,
-    id: String,
+    id: &str,
-    mc_version: String,
+    mc_version: &str,
-    mod_loader: Modloader,
+    mod_loader: &Modloader,
-    download_folder: String,
+    download_folder: &str,
 ) -> MLE<()> {
-    println!("Creating list {}", id);
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
    connection.execute(
        "INSERT INTO lists VALUES (?1, ?2, ?3, ?4)",
-        [
+        [id, mc_version, &mod_loader.to_string(), download_folder],
-            id.clone(),
-            mc_version,
-            mod_loader.to_string(),
-            download_folder,
-        ],
    )?;
    connection.execute(format!("CREATE TABLE {}( 'mod_id' TEXT, 'current_version' TEXT, 'applicable_versions' BLOB, 'current_download' TEXT, 'disabled_versions' TEXT DEFAULT 'NONE', 'set_version' INTEGER, CONSTRAINT {}_PK PRIMARY KEY (mod_id) )", id, id).as_str(), [])?;
    Ok(())
 }
-pub fn lists_remove(config: Cfg, id: String) -> MLE<()> {
+pub fn lists_remove(config: &Cfg, id: &str) -> MLE<()> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
@@ -526,7 +552,7 @@ pub fn lists_remove(config: Cfg, id: String) -> MLE<()> {
    Ok(())
 }
-pub fn lists_get(config: Cfg, list_id: String) -> MLE<List> {
+pub fn lists_get(config: &Cfg, list_id: &str) -> MLE<List> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data).unwrap();
@@ -536,8 +562,9 @@ pub fn lists_get(config: Cfg, list_id: String) -> MLE<List> {
        modloader: Modloader::Fabric,
        download_folder: String::new(),
    };
-    let mut stmt = connection
+    let mut stmt = connection.prepare(
-        .prepare("SELECT mc_version, modloader, download_folder FROM lists WHERE id = ?")?;
+        "SELECT mc_version, modloader, download_folder FROM lists WHERE id = ?",
+    )?;
    let list_iter = stmt.query_map([&list_id], |row| {
        Ok(vec![
@@ -550,7 +577,7 @@ pub fn lists_get(config: Cfg, list_id: String) -> MLE<List> {
    for l in list_iter {
        let li = l?;
        list = List {
-            id: String::from(&list_id),
+            id: list_id.to_string(),
            mc_version: String::from(&li[0]),
            modloader: Modloader::from(&li[1])?,
            download_folder: String::from(&li[2]),
@@ -564,7 +591,7 @@ pub fn lists_get(config: Cfg, list_id: String) -> MLE<List> {
    Ok(list)
 }
-pub fn lists_version(config: Cfg, list_id: &str, version: &str) -> MLE<()> {
+pub fn lists_version(config: &Cfg, list_id: &str, version: &str) -> MLE<()> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data).unwrap();
@@ -575,7 +602,7 @@ pub fn lists_version(config: Cfg, list_id: &str, version: &str) -> MLE<()> {
    Ok(())
 }
-pub fn lists_get_all_ids(config: Cfg) -> MLE<Vec<String>> {
+pub fn lists_get_all_ids(config: &Cfg) -> MLE<Vec<String>> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data).unwrap();
@@ -594,7 +621,7 @@ pub fn lists_get_all_ids(config: Cfg) -> MLE<Vec<String>> {
 }
 //config
-pub fn config_change_current_list(config: Cfg, id: String) -> MLE<()> {
+pub fn config_change_current_list(config: &Cfg, id: &str) -> MLE<()> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
@@ -605,12 +632,13 @@ pub fn config_change_current_list(config: Cfg, id: String) -> MLE<()> {
    Ok(())
 }
-pub fn config_get_current_list(config: Cfg) -> MLE<String> {
+pub fn config_get_current_list(config: &Cfg) -> MLE<String> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data).unwrap();
    let mut list_id = String::new();
-    let mut stmt = connection.prepare("SELECT value FROM user_config WHERE id = 'current_list'")?;
+    let mut stmt = connection
+        .prepare("SELECT value FROM user_config WHERE id = 'current_list'")?;
    let list_iter = stmt.query_map([], |row| row.get::<usize, String>(0))?;
    for list in list_iter {
@@ -626,7 +654,7 @@ pub fn config_get_current_list(config: Cfg) -> MLE<String> {
 //SETUP(UPDATES)
 pub fn s_userlist_update_download(
-    config: Cfg,
+    config: &Cfg,
    list_id: String,
    mod_id: String,
    link: String,
@@ -645,7 +673,9 @@ pub fn s_userlist_update_download(
    Ok(())
 }
-pub fn s_config_create_version(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
+pub fn s_config_create_version(
+    config: &Cfg,
+) -> Result<(), Box<dyn std::error::Error>> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
@@ -656,7 +686,10 @@ pub fn s_config_create_version(config: Cfg) -> Result<(), Box<dyn std::error::Er
    Ok(())
 }
-pub fn s_config_update_version(config: Cfg, ver: String) -> Result<(), Box<dyn std::error::Error>> {
+pub fn s_config_update_version(
+    config: &Cfg,
+    ver: String,
+) -> Result<(), Box<dyn std::error::Error>> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
@@ -667,12 +700,15 @@ pub fn s_config_update_version(config: Cfg, ver: String) -> Result<(), Box<dyn s
    Ok(())
 }
-pub fn s_config_get_version(config: Cfg) -> Result<String, Box<dyn std::error::Error>> {
+pub fn s_config_get_version(
+    config: &Cfg,
+) -> Result<String, Box<dyn std::error::Error>> {
    let data = format!("{}/data.db", config.data);
    let connection = Connection::open(data)?;
    let mut version: String = String::new();
-    let mut stmt = connection.prepare("SELECT value FROM user_config WHERE id = 'db_version'")?;
+    let mut stmt = connection
+        .prepare("SELECT value FROM user_config WHERE id = 'db_version'")?;
    let ver_iter = stmt.query_map([], |row| row.get::<usize, String>(0))?;
    for ver in ver_iter {
@@ -689,7 +725,7 @@ pub fn s_config_get_version(config: Cfg) -> Result<String, Box<dyn std::error::E
 }
 pub fn s_insert_column(
-    config: Cfg,
+    config: &Cfg,
    table: String,
    column: String,
    c_type: String,
diff --git a/src/error.rs b/src/error.rs
index e6afeaa..a2b37a8 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -34,8 +34,12 @@ impl std::error::Error for MLError {
 impl fmt::Display for MLError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self.etype {
-            ErrorType::ArgumentError => write!(f, "User input not accepted: {}", self.message),
+            ErrorType::ArgumentError => {
-            ErrorType::ArgumentCountError => write!(f, "Too many/too few arguments"),
+                write!(f, "User input not accepted: {}", self.message)
+            }
+            ErrorType::ArgumentCountError => {
+                write!(f, "Too many/too few arguments")
+            }
            ErrorType::ConfigError => write!(f, "CONFIG"),
            ErrorType::DBError => write!(f, "Database: {}", self.message),
            ErrorType::ModError => write!(f, "Mod: {}", self.message),
@@ -106,9 +110,11 @@ impl From<std::io::Error> for MLError {
 impl From<serde_json::error::Error> for MLError {
    fn from(value: serde_json::error::Error) -> Self {
-        Self { etype: ErrorType::LibJson, message: value.to_string() }
+        Self {
+            etype: ErrorType::LibJson,
+            message: value.to_string(),
+        }
    }
-    
 }
 impl MLError {
diff --git a/src/files.rs b/src/files.rs
index a4c128e..3a16c62 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -1,10 +1,13 @@
 use futures_util::StreamExt;
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use reqwest::Client;
 use std::{
+    cmp::min,
    collections::HashMap,
    fs::{copy, read_dir, remove_file, rename, File},
    io::Write,
 };
+use tokio::task::JoinSet;
 use crate::{
    cache::{copy_cached_version, get_cached_versions},
@@ -12,99 +15,160 @@ use crate::{
    db::{mods_get_info, userlist_add_disabled_versions},
    error::{ErrorType, MLError, MLE},
    modrinth::Version,
-    List,
+    List, PROGRESS_CHARS, STYLE_BAR_BYTE, STYLE_BAR_POS, STYLE_SPINNER,
 };
-pub async fn download_versions(list: List, config: Cfg, versions: Vec<Version>) -> MLE<String> {
+pub async fn download_versions(
-    let mut cached = get_cached_versions(&config.cache);
+    list: List,
+    config: Cfg,
+    versions: Vec<Version>,
+    progress: &MultiProgress,
+    progress_before: &ProgressBar,
+) -> MLE<()> {
+    let cached = get_cached_versions(&config.cache);
-    // println!("{:#?}", cached);
+    let mut js = JoinSet::new();
-    let dl_path = String::from(&list.download_folder);
+    let style_spinner = ProgressStyle::with_template(STYLE_SPINNER).unwrap();
-    println!("  └Download mods to {}", dl_path);
+    let all = progress.insert_before(
+        progress_before,
+        ProgressBar::new(versions.len().try_into().unwrap()),
+    );
+    all.set_style(
+        ProgressStyle::with_template(STYLE_BAR_POS)
+            .unwrap()
+            .progress_chars(PROGRESS_CHARS),
+    );
+    all.set_message(format!("✓Downloading {}", list.id));
    for ver in versions {
-        let project_info = mods_get_info(config.clone(), &ver.project_id)?;
+        let p = progress.insert_before(&all, ProgressBar::new(1));
+        p.set_style(style_spinner.clone());
-        //Check cache if already downloaded
+        js.spawn(download_version(
-        let c = cached.remove(&ver.id);
+            config.clone(),
-        if c.is_some() {
+            list.clone(),
-            print!(
+            ver,
-                "\t└({})Get version {} from cache",
+            cached.clone(),
-                project_info.title, ver.id
+            p,
-            );
+        ));
-            //Force flush of stdout, else print! doesn't print instantly
+    }
-            std::io::stdout().flush()?;
-            copy_cached_version(&c.unwrap(), &dl_path);
+    while js.join_next().await.is_some() {
-            println!(" ✓");
+        all.inc(1)
-        } else {
+    }
-            print!("\t└({})Download version {}", project_info.title, ver.id);
-            //Force flush of stdout, else print! doesn't print instantly
+    all.finish_with_message(format!("✓Downloading {}", list.id));
-            std::io::stdout().flush().unwrap();
-            let files = ver.files;
+    Ok(())
-            let file = match files.clone().into_iter().find(|f| f.primary) {
+}
-                Some(f) => f,
-                None => files[0].clone()
+async fn download_version(
-            };
+    config: Cfg,
-            let mut splitname: Vec<&str> = file.filename.split('.').collect();
+    list: List,
-            let extension = match splitname.pop().ok_or("") {
+    version: Version,
-                Ok(e) => e,
+    mut cached: HashMap<String, String>,
-                Err(..) => return Err(MLError::new(ErrorType::Other, "NO_FILE_EXTENSION")),
+    progress: ProgressBar,
-            };
+) -> MLE<()> {
-            let filename = format!(
+    let project_info = mods_get_info(&config, &version.project_id)?;
-                "{}.mr.{}.{}.{}",
-                splitname.join("."),
+    let dl_path = String::from(&list.download_folder);
-                ver.project_id,
-                ver.id,
+    progress.set_message(format!("{} - {}", project_info.title, version.id));
-                extension
-            );
+    let mut cache_msg = "";
-            download_file(
+    //Check cache if already downloaded
-                file.url,
+    let c = cached.remove(&version.id);
-                list.clone().download_folder,
+    if c.is_some() {
-                filename.clone(),
+        progress.set_message(format!("Get {} from cache", version.id));
-            )
+        cache_msg = " (cached)";
+        copy_cached_version(&c.unwrap(), &dl_path);
+    } else {
+        let files = version.files;
+        let file = match files.clone().into_iter().find(|f| f.primary) {
+            Some(f) => f,
+            None => files[0].clone(),
+        };
+        let mut splitname: Vec<&str> = file.filename.split('.').collect();
+        let extension = match splitname.pop().ok_or("") {
+            Ok(e) => e,
+            Err(..) => {
+                return Err(MLError::new(ErrorType::Other, "NO_FILE_EXTENSION"))
+            }
+        };
+        let filename = format!(
+            "{}.mr.{}.{}.{}",
+            splitname.join("."),
+            version.project_id,
+            version.id,
+            extension
+        );
+        download_file(&file.url, &list.download_folder, &filename, &progress)
            .await?;
-            println!(" ✓");
-            //Copy file to cache
+        progress.set_message(format!("Copy {} to cache", version.id));
-            print!("\t  └Copy to cache");
+        let dl_path_file = format!("{}/{}", list.download_folder, filename);
-            //Force flush of stdout, else print! doesn't print instantly
+        let cache_path = format!("{}/{}", &config.cache, filename);
-            std::io::stdout().flush().unwrap();
-            let dl_path_file = format!("{}/{}", list.download_folder, filename);
+        copy(dl_path_file, cache_path)?;
-            let cache_path = format!("{}/{}", &config.clone().cache, filename);
-            // println!("{}:{}", dl_path_file, cache_path);
-            copy(dl_path_file, cache_path)?;
-            println!(" ✓");
-        }
    }
-    Ok(dl_path)
+    progress.finish_with_message(format!(
+        "✓{} - {}{}",
+        project_info.title, version.id, cache_msg
+    ));
+    Ok(())
 }
-async fn download_file(url: String, path: String, name: String) -> MLE<()> {
+async fn download_file(
+    url: &str,
+    path: &str,
+    name: &str,
+    progress: &ProgressBar,
+) -> MLE<()> {
    let dl_path_file = format!("{}/{}", path, name);
-    let res = Client::new().get(String::from(&url)).send().await?;
+    let res = Client::new().get(url).send().await?;
+    let size = res.content_length().expect("Couldn't get content length");
+    let style_bar_byte = ProgressStyle::with_template(STYLE_BAR_BYTE)
+        .unwrap()
+        .progress_chars(PROGRESS_CHARS);
+    progress.set_length(size);
+    progress.set_style(style_bar_byte);
    // download chunks
    let mut file = File::create(&dl_path_file)?;
    let mut stream = res.bytes_stream();
+    let mut downloaded: u64 = 0;
    while let Some(item) = stream.next().await {
+        // progress.inc(1);
        let chunk = item?;
        file.write_all(&chunk)?;
+        // Progress bar
+        let new = min(downloaded + (chunk.len() as u64), size);
+        downloaded = new;
+        progress.set_position(new);
+        // std::thread::sleep(std::time::Duration::from_millis(100));
    }
    Ok(())
 }
 pub fn disable_version(
-    config: Cfg,
+    config: &Cfg,
    current_list: List,
    versionid: String,
    mod_id: String,
 ) -> MLE<()> {
-    //println!("Disabling version {} for mod {}", versionid, mod_id);
+    let file = get_file_path(&current_list, String::from(&versionid))?;
-    let file = get_file_path(current_list.clone(), String::from(&versionid))?;
    let disabled = format!("{}.disabled", file);
    rename(file, disabled)?;
@@ -114,7 +178,7 @@ pub fn disable_version(
    Ok(())
 }
-pub fn delete_version(list: List, version: String) -> MLE<()> {
+pub fn delete_version(list: &List, version: String) -> MLE<()> {
    let file = get_file_path(list, version)?;
    remove_file(file)?;
@@ -122,14 +186,16 @@ pub fn delete_version(list: List, version: String) -> MLE<()> {
    Ok(())
 }
-pub fn get_file_path(list: List, versionid: String) -> MLE<String> {
+pub fn get_file_path(list: &List, versionid: String) -> MLE<String> {
    let mut names: HashMap<String, String> = HashMap::new();
-    for file in read_dir(list.download_folder)? {
+    for file in read_dir(&list.download_folder)? {
        let path = file?.path();
        if path.is_file() {
            let pathstr = match path.to_str().ok_or("") {
                Ok(s) => s,
-                Err(..) => return Err(MLError::new(ErrorType::Other, "INVALID_PATH")),
+                Err(..) => {
+                    return Err(MLError::new(ErrorType::Other, "INVALID_PATH"))
+                }
            };
            let namesplit: Vec<&str> = pathstr.split('.').collect();
            let ver_id = namesplit[namesplit.len() - 2];
@@ -168,7 +234,6 @@ pub fn get_downloaded_versions(list: List) -> MLE<HashMap<String, String>> {
 pub fn clean_list_dir(list: &List) -> MLE<()> {
    let dl_path = &list.download_folder;
-    println!("  └Clean directory for: {}", list.id);
    for entry in std::fs::read_dir(dl_path)? {
        let entry = entry?;
        std::fs::remove_file(entry.path())?;
diff --git a/src/lib.rs b/src/lib.rs
index 1c40ceb..f77befc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,14 +6,28 @@ pub mod db;
 pub mod error;
 pub mod files;
-use std::{fmt::Display, fs::{File, remove_file, self}, io::{Write, Read}, time::Duration};
+use std::{
+    fmt::Display,
+    fs::{self, remove_file, File},
+    io::{Read, Write},
+    time::Duration,
+};
-pub use apis::*;
 use apis::modrinth::{get_game_versions, GameVersion, GameVersionType};
+pub use apis::*;
 pub use commands::*;
 use error::{ErrorType, MLError, MLE};
+use indicatif::{ProgressBar, ProgressStyle};
 use serde::{Deserialize, Serialize};
+pub static STYLE_BAR_BYTE: &str =
+    "{spinner:.green}{wide_msg}{bytes}/{total_bytes} [{bar:.green/lime}]";
+pub static STYLE_BAR_POS: &str = " {wide_msg}{pos}/{len} [{bar:.green/lime}]";
+pub static STYLE_SPINNER: &str = "{spinner:.green}{wide_msg}";
+pub static STYLE_OPERATION: &str = " {wide_msg}";
+pub static STYLE_MESSAGE: &str = "{wide_msg}";
+pub static PROGRESS_CHARS: &str = "#>-";
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum Modloader {
    #[serde(rename(serialize = "fabric", deserialize = "fabric"))]
@@ -30,7 +44,9 @@ impl Modloader {
            "forge" => Ok(Modloader::Forge),
            "fabric" => Ok(Modloader::Fabric),
            "quilt" => Ok(Modloader::Quilt),
-            _ => Err(MLError::new(ErrorType::ArgumentError, "UNKNOWN_MODLOADER")),
+            _ => {
+                Err(MLError::new(ErrorType::ArgumentError, "UNKNOWN_MODLOADER"))
+            }
        }
    }
 }
@@ -51,21 +67,29 @@ pub enum VersionLevel {
    Release,
    #[serde(rename(serialize = "snapshot", deserialize = "snapshot"))]
    Snapshot,
-    Version(String)
+    Version(String),
 }
 /// Checks if update needed (time)
 /// if yes: get versions, update
 pub async fn check_game_versions(path: &str, force: bool) -> MLE<()> {
+    let p = ProgressBar::new(1);
+    p.set_style(ProgressStyle::with_template(STYLE_MESSAGE).unwrap());
+    p.set_message("Update minecraft versions");
    let creation_time = fs::metadata(path)?.created()?;
-    if !force && creation_time.elapsed().unwrap() < Duration::from_secs(60 * 60 * 24) { return Ok(()); }
+    if !force
-    print!("Update minecraft versions");
+        && creation_time.elapsed().unwrap() < Duration::from_secs(60 * 60 * 24)
-    std::io::stdout().flush()?;
+    {
+        return Ok(());
+    }
    let versions = get_game_versions().await;
    remove_file(path)?;
    let mut file = File::create(path)?;
-    file.write_all(&serde_json::to_string_pretty(&versions)?.as_bytes())?;
+    file.write_all(serde_json::to_string_pretty(&versions)?.as_bytes())?;
-    println!(" ✓");
+    p.finish_with_message("Updated minecraft versions");
    Ok(())
 }
@@ -79,7 +103,6 @@ pub fn load_game_versions(path: &str) -> MLE<Vec<GameVersion>> {
 }
 impl VersionLevel {
    pub fn from(str: &str) -> Self {
        match str {
            "release" => VersionLevel::Release,
@@ -88,29 +111,38 @@ impl VersionLevel {
        }
    }
-    pub async fn get(self, versions_path: &str, force_update: bool) -> MLE<String> {
+    pub async fn get(
+        self,
+        versions_path: &str,
+        force_update: bool,
+    ) -> MLE<String> {
        let path = format!("{}/versions.json", versions_path);
        check_game_versions(&path, force_update).await?;
        let mut versions = load_game_versions(&path)?.into_iter();
        match self {
            VersionLevel::Release => {
-                let release = versions.find(|ver| ver.version_type == GameVersionType::release).unwrap();
+                let release = versions
-                println!("{:?}", release);
+                    .find(|ver| ver.version_type == GameVersionType::release)
+                    .unwrap();
                Ok(release.version)
-            },
+            }
            VersionLevel::Snapshot => {
-                let snapshot = versions.find(|ver| ver.version_type == GameVersionType::snapshot).unwrap();
+                let snapshot = versions
-                println!("{:?}", snapshot);
+                    .find(|ver| ver.version_type == GameVersionType::snapshot)
+                    .unwrap();
                Ok(snapshot.version)
-            },
+            }
            VersionLevel::Version(v) => {
-                if versions.find(|ver| ver.version == v).is_some() {
+                if versions.any(|ver| ver.version == v) {
                    Ok(v)
                } else {
-                    Err(MLError::new(ErrorType::ConfigError, "unknown minecraft version"))
+                    Err(MLError::new(
+                        ErrorType::ConfigError,
+                        "unknown minecraft version",
+                    ))
                }
-            },
+            }
        }
    }
 }
diff --git a/src/main.rs b/src/main.rs
index 31a320b..5d60a17 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,8 +2,9 @@ use clap::{Parser, Subcommand};
 use modlist::{
    config::Cfg,
    db::{config_get_current_list, lists_get, lists_get_all_ids},
-    download, export, get_current_list, import, list_add, list_change, list_remove, list_version,
+    download, export, get_current_list, import, list_add, list_change,
-    mod_add, mod_remove, update, IDSelector, List, Modloader, VersionLevel, list_list, AddMod,
+    list_list, list_remove, list_version, mod_add, mod_remove, update, AddMod,
+    IDSelector, List, Modloader, VersionLevel,
 };
 #[derive(Parser)]
@@ -15,10 +16,6 @@ struct Cli {
    /// config file path
    #[arg(short, long)]
    config: Option<String>,
-    /// Force GameVersion update
-    #[arg(long)]
-    force_gameupdate: bool,
 }
 #[derive(Subcommand)]
@@ -30,6 +27,10 @@ enum Commands {
    List {
        #[command(subcommand)]
        command: ListCommands,
+        /// Force GameVersion update
+        #[arg(long)]
+        force_gameupdate: bool,
    },
    Download {
        /// download all lists
@@ -43,7 +44,7 @@ enum Commands {
        /// remove disabled versions
        #[arg(short, long)]
        remove: bool,
-        
        /// optional List selection, else default list will be used
        #[arg(short, long)]
        list: Option<String>,
@@ -81,7 +82,7 @@ enum Commands {
        /// the list you want to export
        list: Option<String>,
    },
-    Test
+    Test,
 }
 #[derive(Subcommand)]
@@ -160,119 +161,134 @@ async fn main() {
    let config = Cfg::init(cli.config).await.unwrap();
    match cli.command {
-        Commands::Mod { command } => {
+        Commands::Mod { command } => match command {
-            match command {
+            ModCommands::Add {
-                #[allow(unused_variables)]
+                id,
-                ModCommands::Add {
+                version,
-                    id,
+                list,
-                    version,
+                download,
-                    list,
+                lock,
-                    download,
+            } => {
-                    lock,
+                let listf = match list {
-                } => {
+                    Some(list) => lists_get(&config, &list).unwrap(),
-                    let listf = match list {
+                    None => lists_get(
-                        Some(list) => lists_get(config.clone(), list).unwrap(),
+                        &config,
-                        None => lists_get(
+                        &config_get_current_list(&config).unwrap(),
-                            config.clone(),
+                    )
-                            config_get_current_list(config.clone()).unwrap(),
+                    .unwrap(),
-                        )
+                };
-                        .unwrap(),
-                    };
-                    let marked_id = match version {
+                let marked_id = match version {
-                        true => IDSelector::VersionID(id),
+                    true => IDSelector::VersionID(id),
-                        false => IDSelector::ModificationID(id),
+                    false => IDSelector::ModificationID(id),
-                    };
+                };
-                    let add_id = AddMod { id: marked_id, set_version: lock };
+                let add_id = AddMod {
+                    id: marked_id,
+                    set_version: lock,
+                };
-                    mod_add(config, vec![add_id], listf, download).await
+                mod_add(&config, vec![add_id], listf, download).await
-                }
-                ModCommands::Remove { id, list } => {
-                    let listf = match list {
-                        Some(list) => lists_get(config.clone(), list).unwrap(),
-                        None => lists_get(
-                            config.clone(),
-                            config_get_current_list(config.clone()).unwrap(),
-                        )
-                        .unwrap(),
-                    };
-                    mod_remove(config, &id, listf)
-                }
            }
-        }
+            ModCommands::Remove { id, list } => {
-        Commands::List { command } => {
+                let listf = match list {
-            match command {
+                    Some(list) => lists_get(&config, &list).unwrap(),
-                ListCommands::Add {
+                    None => lists_get(
-                    id,
+                        &config,
-                    directory,
+                        &config_get_current_list(&config).unwrap(),
-                    modloader,
+                    )
-                    version,
+                    .unwrap(),
-                } => {
+                };
-                    let ml = match modloader {
+                mod_remove(&config, &id, &listf)
-                        Some(ml) => Modloader::from(&ml).unwrap(),
-                        None => config.clone().defaults.modloader,
-                    };
-                    let versions_path = &config.versions;
-                    let ver = match version {
-                        Some(ver) => VersionLevel::from(&ver).get(versions_path, cli.force_gameupdate).await.unwrap(),
-                        None => config.clone().defaults.version.get(versions_path, cli.force_gameupdate).await.unwrap(),
-                    };
-                    list_add(config, id, ver, ml, directory)
-                }
-                ListCommands::Remove { id } => list_remove(config, id),
-                ListCommands::List => {
-                    list_list(config)
-                }
-                ListCommands::Change { id } => list_change(config, id),
-                ListCommands::Version {
-                    id,
-                    version,
-                    download,
-                    remove,
-                } => list_version(config, id, version, download, remove).await,
            }
-        }
+        },
+        Commands::List {
+            command,
+            force_gameupdate,
+        } => match command {
+            ListCommands::Add {
+                id,
+                directory,
+                modloader,
+                version,
+            } => {
+                let ml = match modloader {
+                    Some(ml) => Modloader::from(&ml).unwrap(),
+                    None => config.defaults.modloader.clone(),
+                };
+                let versions_path = &config.versions;
+                let ver = match version {
+                    Some(ver) => VersionLevel::from(&ver)
+                        .get(versions_path, force_gameupdate)
+                        .await
+                        .unwrap(),
+                    None => config
+                        .defaults
+                        .version
+                        .clone()
+                        .get(versions_path, force_gameupdate)
+                        .await
+                        .unwrap(),
+                };
+                list_add(&config, &id, &ver, &ml, &directory)
+            }
+            ListCommands::Remove { id } => list_remove(&config, &id),
+            ListCommands::List => list_list(&config),
+            ListCommands::Change { id } => list_change(&config, &id),
+            ListCommands::Version {
+                id,
+                version,
+                download,
+                remove,
+            } => list_version(&config, &id, version, download, remove).await,
+        },
        Commands::Update {
            all,
            download,
            clean,
            remove,
-            list
+            list,
        } => {
            let mut liststack: Vec<List> = vec![];
            if all {
-                let list_ids = lists_get_all_ids(config.clone()).unwrap();
+                let list_ids = lists_get_all_ids(&config).unwrap();
                for id in list_ids {
-                    liststack.push(lists_get(config.clone(), id).unwrap());
+                    liststack.push(lists_get(&config, &id).unwrap());
                }
            } else {
-                let current = match list  {
+                let current = match list {
-                    Some(l) => lists_get(config.clone(), l).unwrap(),
+                    Some(l) => lists_get(&config, &l).unwrap(),
-                    None => get_current_list(config.clone()).unwrap(),
+                    None => get_current_list(&config).unwrap(),
                };
                liststack.push(current)
            }
-            update(config, liststack, clean, download, remove).await
+            update(&config, liststack, clean, download, remove).await
        }
-        Commands::Download { all, clean, remove, list } => {
+        Commands::Download {
+            all,
+            clean,
+            remove,
+            list,
+        } => {
            let mut liststack: Vec<List> = vec![];
            if all {
-                let list_ids = lists_get_all_ids(config.clone()).unwrap();
+                let list_ids = lists_get_all_ids(&config).unwrap();
                for id in list_ids {
-                    liststack.push(lists_get(config.clone(), id).unwrap());
+                    liststack.push(lists_get(&config, &id).unwrap());
                }
            } else {
-                let current = match list  {
+                let current = match list {
-                    Some(l) => lists_get(config.clone(), l).unwrap(),
+                    Some(l) => lists_get(&config, &l).unwrap(),
-                    None => get_current_list(config.clone()).unwrap(),
+                    None => get_current_list(&config).unwrap(),
                };
                liststack.push(current)
            }
-            download(config, liststack, clean, remove).await
-        },
+            download(&config, liststack, clean, remove).await
+        }
        Commands::Import { file, download } => {
            let filestr: String = match file {
                Some(args) => args,
@@ -284,9 +300,9 @@ async fn main() {
                    .unwrap(),
            };
-            import(config, filestr, download).await
+            import(&config, &filestr, download).await
        }
-        Commands::Export { list } => export(config, list),
+        Commands::Export { list } => export(&config, list),
        Commands::Test => Ok(()),
    }
    .unwrap();